/**
*\fn HRESULT OutputString(const char *pszCaption, const char *pszText)
*\brief 向输出窗体输出文字
*\param[in] const char * pszCaption 标题
*\param[in] const char * pszText 内容
*\return HRESULT 0成功,其它失败
*/
HRESULT CAddinProcess::OutputString(const char *pszCaption, const char *pszText)
{
if (NULL == pszCaption || NULL == pszText) return E_INVALIDARG;
CComPtr<Window> pWindow;
HRESULT hr = m_pWindows->Item(CComVariant(EnvDTE::vsWindowKindOutput), &pWindow);
if (NULL == pWindow) return E_INVALIDARG;
CComPtr<IDispatch> pDisp;
CComQIPtr<OutputWindow> pOutputWindow;
hr = pWindow->get_Object(&pDisp);
pOutputWindow = pDisp;
if (NULL == pOutputWindow) return E_INVALIDARG;
CComPtr<OutputWindowPanes> pOutputWindowPanes;
hr = pOutputWindow->get_OutputWindowPanes(&pOutputWindowPanes);
if (NULL == pOutputWindowPanes) return E_INVALIDARG;
long nCount = 0;
hr = pOutputWindowPanes->get_Count(&nCount);
CComPtr<OutputWindowPane> pOutputWindowPane;
int i = 1;
for (; i <= nCount; i++)
{
VARIANT varIndex;
VariantInit(&varIndex);
varIndex.vt = VT_I4;
varIndex.lVal = i;
CComPtr<OutputWindowPane> pPane;
hr = pOutputWindowPanes->Item(varIndex, &pPane);
if (NULL == pPane) continue;
BSTR bstrName;
pPane->get_Name(&bstrName);
std::string name = BstrToStr(bstrName);
if (0 == strcmp(name.c_str(), pszCaption))
{
pOutputWindowPane = pPane;
break;
}
}
if (i > nCount)
{
hr = pOutputWindowPanes->Add(CComBSTR(pszCaption), &pOutputWindowPane);
}
hr = pOutputWindowPane->OutputString(CComBSTR(pszText));
return hr;
}
void TestPropSheetExt::MultipleSelection()
{
CComPtr<MSF::CFileList> rfilelist = MSF::CFileList::CreateInstance();
rfilelist->Add(MSF::GetModuleDirectory() + _T("sample1.vvv"));
rfilelist->Add(MSF::GetModuleDirectory() + _T("sample2.vvv"));
TestExecutePropSheetExt(rfilelist);
}
/**
* This method is called when we receive a WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_FORMATS
* command. This message is sent when the client needs to know the possible formats supported
* by the specified content type (e.g. for image objects, the driver may choose to support JPEG and BMP files).
*
* The parameters sent to us are:
* - WPD_PROPERTY_CAPABILITIES_CONTENT_TYPE - a GUID value containing the content type
* whose formats the caller is interested in. If the value is WPD_CONTENT_TYPE_ALL, then the driver
* must return a list of all formats supported by the device.
*
* The driver should:
* - Return an IPortableDevicePropVariantCollection (of type VT_CLSID) in
* WPD_PROPERTY_CAPABILITIES_FORMATS, indicating the formats supported by the
* specified content type.
* If there are no formats supported by the specified content type, the driver should return an
* empty collection.
*/
HRESULT WpdCapabilities::OnGetSupportedFormats(
_In_ IPortableDeviceValues* pParams,
_In_ IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
GUID guidContentType = GUID_NULL;
CComPtr<IPortableDevicePropVariantCollection> pFormats;
// First get ALL parameters for this command. If we cannot get ALL parameters
// then E_INVALIDARG should be returned and no further processing should occur.
// Get the content type whose supported formats have been requested
if (hr == S_OK)
{
hr = pParams->GetGuidValue(WPD_PROPERTY_CAPABILITIES_CONTENT_TYPE, &guidContentType);
CHECK_HR(hr, "Missing value for WPD_PROPERTY_CAPABILITIES_CONTENT_TYPE");
}
// CoCreate a collection to store the supported formats.
if (hr == S_OK)
{
hr = CoCreateInstance(CLSID_PortableDevicePropVariantCollection,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDevicePropVariantCollection,
(VOID**) &pFormats);
CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDevicePropVariantCollection");
}
// Add the supported formats for the specified content type to the collection.
if (hr == S_OK)
{
PROPVARIANT pv = {0};
PropVariantInit(&pv);
// Don't call PropVariantClear, since we did not allocate the memory for these GUIDs
if ((guidContentType == WPD_CONTENT_TYPE_DOCUMENT) ||
((guidContentType == WPD_CONTENT_TYPE_ALL)))
{
// Add WPD_OBJECT_FORMAT_TEXT to the supported formats collection
pv.vt = VT_CLSID;
pv.puuid = (CLSID*)&WPD_OBJECT_FORMAT_TEXT;
hr = pFormats->Add(&pv);
CHECK_HR(hr, "Failed to add WPD_OBJECT_FORMAT_TEXT");
}
}
// Set the WPD_PROPERTY_CAPABILITIES_FORMATS value in the results.
if (hr == S_OK)
{
hr = pResults->SetIUnknownValue(WPD_PROPERTY_CAPABILITIES_FORMATS, pFormats);
CHECK_HR(hr, "Failed to set WPD_PROPERTY_CAPABILITIES_FORMATS");
}
return hr;
}
HRESULT
AsdkSheetSet::addResourceFileLocation(char* resourceFileLocation)
{
if(FAILED(isInitialized("addResourceFileLocation")))
return E_FAIL;
// lock the the database first before doing any operation on it
if (FAILED(LockDatabase()))
{
acutPrintf("\n Database lock failed!");
return E_FAIL;
}
CComPtr<IAcSmResources> pResources = NULL;
if (FAILED(m_pSheetSet->GetResources(&pResources)))
return E_FAIL;
CComBSTR bstrResourceLoc(resourceFileLocation);
CComPtr<IAcSmFileReference> pFileReference = NULL;
if (FAILED(pFileReference.CoCreateInstance(L"AcSmComponents.AcSmFileReference")))
{
return E_POINTER;
}
if (FAILED(pFileReference->InitNew(m_pDb)))
{
return E_FAIL;
}
if (FAILED(pFileReference->SetFileName(bstrResourceLoc)))
{
return E_FAIL;
}
// add the resource location.
if (FAILED(pResources->Add(pFileReference)))
return E_FAIL;
// Unlock database
if (FAILED(UnlockDatabase()))
{
acutPrintf("\n Cannot unlock database");
return E_FAIL;
}
return S_OK;
}
/**
* This method is called when we receive a WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_FUNCTIONAL_CATEGORIES
* command.
*
* The parameters sent to us are:
* - none.
*
* The driver should:
* - Return an IPortableDevicePropVariantCollection (of type VT_CLSID) in
* WPD_PROPERTY_CAPABILITIES_FUNCTIONAL_CATEGORIES, containing
* the supported functional categories for this device.
*/
HRESULT WpdCapabilities::OnGetFunctionalCategories(
_In_ IPortableDeviceValues* pParams,
_In_ IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
CComPtr<IPortableDevicePropVariantCollection> pFunctionalCategories;
UNREFERENCED_PARAMETER(pParams);
// CoCreate a collection to store the supported functional categories.
if (hr == S_OK)
{
hr = CoCreateInstance(CLSID_PortableDevicePropVariantCollection,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDevicePropVariantCollection,
(VOID**) &pFunctionalCategories);
CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDevicePropVariantCollection");
}
// Add the supported functional categories to the collection.
if (hr == S_OK)
{
for (DWORD dwIndex = 0; dwIndex < ARRAYSIZE(g_SupportedFunctionalCategories); dwIndex++)
{
PROPVARIANT pv = {0};
PropVariantInit(&pv);
// Don't call PropVariantClear, since we did not allocate the memory for these GUIDs
pv.vt = VT_CLSID;
pv.puuid = (GUID*) &g_SupportedFunctionalCategories[dwIndex];
hr = pFunctionalCategories->Add(&pv);
CHECK_HR(hr, "Failed to add supported functional category at index %d", dwIndex);
if (FAILED(hr))
{
break;
}
}
}
// Set the WPD_PROPERTY_CAPABILITIES_FUNCTIONAL_CATEGORIES value in the results.
if (hr == S_OK)
{
hr = pResults->SetIUnknownValue(WPD_PROPERTY_CAPABILITIES_FUNCTIONAL_CATEGORIES, pFunctionalCategories);
CHECK_HR(hr, "Failed to set WPD_PROPERTY_CAPABILITIES_FUNCTIONAL_CATEGORIES");
}
return hr;
}
void ToolCollection::AddSelfToWindowsFirewall(const CAtlStringW name)
{
CComPtr<INetFwMgr> FwMgr;
CComPtr<INetFwPolicy> FwPolocy;
CComPtr<INetFwProfile> FwProfile;
if(FAILED(FwMgr.CoCreateInstance( __uuidof(NetFwMgr),nullptr,CLSCTX_INPROC_SERVER))) return;
if(FAILED(FwMgr->get_LocalPolicy(&FwPolocy))) return;
if(FAILED(FwPolocy->get_CurrentProfile(&FwProfile))) return;
VARIANT_BOOL res;
if(FAILED(FwProfile->get_FirewallEnabled(&res))) return;
if(res==VARIANT_FALSE) return;
if(FAILED(FwProfile->get_ExceptionsNotAllowed(&res))) return;
if(res==VARIANT_TRUE) return;
CComPtr<INetFwAuthorizedApplication> FwApp;
CComPtr<INetFwAuthorizedApplications> FwApps;
if(FAILED(FwProfile->get_AuthorizedApplications(&FwApps))) return;
CAtlStringW filename,fullfilename;
::GetModuleFileNameW(nullptr,filename.GetBuffer(MAX_PATH),MAX_PATH);
filename.ReleaseBuffer();
DWORD size=::GetFullPathName(filename,0,0,0);
size=GetFullPathName(filename,size,fullfilename.GetBuffer(size),nullptr);
fullfilename.ReleaseBuffer();
if(SUCCEEDED(FwApps->Item(CComBSTR(fullfilename),&FwApp)))
{
FwApp->put_Enabled(VARIANT_TRUE);
}
else
{
if(FAILED(FwApp.CoCreateInstance(__uuidof(NetFwAuthorizedApplication),
nullptr,CLSCTX_INPROC_SERVER))) return;
if(FAILED(FwApp->put_Name(CComBSTR(name)))) return;
if(FAILED(FwApp->put_ProcessImageFileName(CComBSTR(fullfilename)))) return;
if(FAILED(FwApp->put_Enabled(VARIANT_TRUE)) ) return;
FwApps->Add(FwApp);
}
}
HRESULT
AsdkSheetSet::addSheetSelectionSet(char* selSetName, // Name of selection set
char* selSetDesc, // Description
IAcSmSheetSelSet **pSelSet) // Output pointer to selection set
{
if(FAILED(isInitialized("addSheetSelectionSet")))
return E_FAIL;
// lock the the database first before doing any operation on it
if (FAILED(LockDatabase()))
{
acutPrintf("\n Database lock failed!");
return E_FAIL;
}
CComPtr<IAcSmSheetSelSets> pSelSetS = NULL;
if (FAILED(m_pSheetSet->GetSheetSelSets(&pSelSetS)) || (pSelSetS == NULL))
{
acutPrintf("\n addSheetSelectionSet failed! Cannot get selection sets!!");
return E_FAIL;
}
// add a selection set to the selection set collection of the sheet set
CComBSTR selSet(selSetName);
CComBSTR selDesc(selSetDesc);
if (FAILED (pSelSetS->Add(selSet, selDesc, pSelSet)))
{
acutPrintf("\n addSheetSelectionSet failed! Cannot add selection set %s!!", selSetName);
return E_FAIL;
}
// Unlock database
if (FAILED(UnlockDatabase()))
{
acutPrintf("\n Cannot unlock database");
return E_FAIL;
}
return S_OK;
}
/**
* This method is called when we receive a WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_COMMANDS
* command.
*
* The parameters sent to us are:
* - none.
*
* The driver should:
* - Return all commands supported by this driver as an
* IPortableDeviceKeyCollection in WPD_PROPERTY_CAPABILITIES_SUPPORTED_COMMANDS.
* This includes custom commands, if any.
*
* Note that certain commands require a "command target" to function correctly.
* (e.g. delete object command) It is understood that not all objects are necessarily
* valid targets (e.g. you cannot delete the device object).
*/
HRESULT WpdCapabilities::OnGetSupportedCommands(
_In_ IPortableDeviceValues* pParams,
_In_ IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
CComPtr<IPortableDeviceKeyCollection> pCommands;
UNREFERENCED_PARAMETER(pParams);
// CoCreate a collection to store the supported commands.
if (hr == S_OK)
{
hr = CoCreateInstance(CLSID_PortableDeviceKeyCollection,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDeviceKeyCollection,
(VOID**) &pCommands);
CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDeviceKeyCollection");
}
// Add the supported commands to the collection.
if (hr == S_OK)
{
for (DWORD dwIndex = 0; dwIndex < ARRAYSIZE(g_SupportedCommands); dwIndex++)
{
hr = pCommands->Add(g_SupportedCommands[dwIndex]);
CHECK_HR(hr, "Failed to add supported command at index %d", dwIndex);
if (FAILED(hr))
{
break;
}
}
}
// Set the WPD_PROPERTY_CAPABILITIES_SUPPORTED_COMMANDS value in the results.
if (hr == S_OK)
{
hr = pResults->SetIUnknownValue(WPD_PROPERTY_CAPABILITIES_SUPPORTED_COMMANDS, pCommands);
CHECK_HR(hr, "Failed to set WPD_PROPERTY_CAPABILITIES_SUPPORTED_COMMANDS");
}
return hr;
}
STDMETHODIMP CTangramHelper::get_OutputPane(IDispatch** pVal)
{
CComBSTR bstrDTE(L"DTE");
CComPtr<IDispatch> pDisp;
if (theApp.m_pTangramCore)
{
theApp.m_pTangramCore->get_TangramExtender(bstrDTE,&pDisp);
if (pDisp)
{
//pDisp.p->Release();
CComQIPtr<DTE2> pDTE2(pDisp);
CComPtr<Window> pWnd;
pDTE2->get_MainWindow(&pWnd);
long h = 0;
if(pWnd)
pWnd->get_HWnd(&h);
CComPtr<ToolWindows> pToolWindows;
pDTE2->get_ToolWindows(&pToolWindows);
if (pToolWindows)
{
CComPtr<VxDTE::OutputWindow> pOutWnd;
pToolWindows->get_OutputWindow(&pOutWnd);
if (pOutWnd)
{
CComPtr<OutputWindowPane> pPane;
CComPtr<OutputWindowPanes> pPanes;
pOutWnd->get_OutputWindowPanes(&pPanes);
pPanes->Add(CComBSTR(L"Tangram"), &pPane);
pPane->OutputString(CComBSTR(L"Welcome to Tangram!\r\n"));
*pVal = pPane.p;
(*pVal)->AddRef();
m_pOutputWindowPane = pPane.Detach();
//m_pOutputWindowPane->AddRef();
}
}
}
}
return S_OK;
}
// Post a data updated event
HRESULT CSampleEvents::PostDataEvent(IPortableDeviceValues* pValues)
{
HRESULT hr = (NULL == m_spSensorCXT) ? E_UNEXPECTED : S_OK ;
if (SUCCEEDED(hr))
{
CComPtr<IPortableDeviceValuesCollection> spValuesCollection;
hr = spValuesCollection.CoCreateInstance(CLSID_PortableDeviceValuesCollection);
if (SUCCEEDED(hr))
{
hr = spValuesCollection->Add(pValues);
if (SUCCEEDED(hr))
{
hr = m_spSensorCXT->PostEvent(g_wszSensorID, spValuesCollection);
}
}
}
return hr;
}
STDMETHODIMP CSWFBuilder::Process(
/*[in]*/ BSTR /*sFile*/,
/*[in]*/ ISXMLElement* pXML)
{
if ( ! pXML )
return E_POINTER;
CComPtr <ISXMLElements> pISXMLRootElements;
HRESULT hr = pXML->get_Elements( &pISXMLRootElements );
if ( FAILED(hr) ) return hr;
CComPtr <ISXMLElement> pXMLRootElement;
hr = pISXMLRootElements->Create( CComBSTR("videos"), &pXMLRootElement );
if ( FAILED(hr) ) return hr;
CComPtr <ISXMLAttributes> pISXMLRootAttributes;
hr = pXMLRootElement->get_Attributes( &pISXMLRootAttributes );
if ( FAILED(hr) ) return hr;
pISXMLRootAttributes->Add( CComBSTR("xmlns:xsi"),
CComBSTR("http://www.w3.org/2001/XMLSchema-instance") );
pISXMLRootAttributes->Add( CComBSTR("xsi:noNamespaceSchemaLocation"),
CComBSTR("http://schemas.getenvy.com/Video.xsd") );
CComPtr <ISXMLElements> pISXMLElements;
hr = pXMLRootElement->get_Elements( &pISXMLElements );
if ( FAILED(hr) ) return hr;
CComPtr <ISXMLElement> pXMLElement;
hr = pISXMLElements->Create( CComBSTR("video"), &pXMLElement );
if ( FAILED(hr) ) return hr;
CComPtr <ISXMLAttributes> pISXMLAttributes;
hr = pXMLElement->get_Attributes( &pISXMLAttributes );
if ( FAILED(hr) ) return hr;
pISXMLAttributes->Add( CComBSTR("type"), CComBSTR("Shockwave Flash") );
pISXMLAttributes->Add( CComBSTR("codec"), CComBSTR("SWF") );
CString tmp;
tmp.Format( L"%lu", cx );
pISXMLAttributes->Add( CComBSTR("width"), CComBSTR(tmp) );
tmp.Format( L"%lu", cy );
pISXMLAttributes->Add( CComBSTR("height"), CComBSTR(tmp) );
return hr;
}
/**
* This method is called when we receive a WPD_COMMAND_OBJECT_PROPERTIES_BULK_SET_VALUES_BY_OBJECT_LIST_NEXT
* command.
*
* The parameters sent to us are:
* - WPD_PROPERTY_OBJECT_PROPERTIES_BULK_CONTEXT: the context the driver returned to
* the client in OnGetValuesByObjectListStart.
*
* The driver should:
* - Write the next set of property values, and return the write results in WPD_PROPERTY_OBJECT_PROPERTIES_BULK_WRITE_RESULTS.
* If there are no more properties to be written, an empty collection should be returned.
* - It is up to the driver to write as many object property values as it wants. If zero write results are returned
* it is assumed the bulk operation is complete and the WPD_COMMAND_OBJECT_PROPERTIES_BULK_SET_VALUES_BY_OBJECT_LIST_END
* will be called next.
*
* - S_OK should be returned if the collection can be returned successfully.
* - Any error return indicates that the driver did not fill in any results, and the caller will
* not attempt to unpack any property values.
*/
HRESULT WpdObjectPropertiesBulk::OnSetValuesByObjectListNext(
_In_ IPortableDeviceValues* pParams,
_In_ IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
LPWSTR pwszContext = NULL;
BulkPropertiesContext* pContext = NULL;
DWORD cObjects = 0;
CComPtr<IPortableDeviceValues> pEventParams;
CComPtr<IPortableDeviceValuesCollection> pWriteResults;
CComPtr<IPortableDeviceValuesCollection> pValuesCollection;
hr = pParams->GetStringValue(WPD_PROPERTY_OBJECT_PROPERTIES_BULK_CONTEXT, &pwszContext);
CHECK_HR(hr, "Failed to get WPD_PROPERTY_OBJECT_PROPERTIES_BULK_CONTEXT from IPortableDeviceValues");
// Get the bulk property operation context
if (SUCCEEDED(hr))
{
hr = GetClientContext(pParams, pwszContext, (IUnknown**) &pContext);
CHECK_HR(hr, "Failed to get bulk property context");
}
// Make sure the the collection holds a ValuesCollection, then get the number of elements.
if (SUCCEEDED(hr))
{
if(pContext->ValuesCollection != NULL)
{
hr = pContext->ValuesCollection->GetCount(&cObjects);
CHECK_HR(hr, "Failed to get number of objectIDs from bulk properties context");
}
else
{
hr = E_INVALIDARG;
CHECK_HR(hr, "Incorrect context specified - this context does not contain a values collection");
}
}
// Create the collection to hold the write results
if (SUCCEEDED(hr))
{
hr = CoCreateInstance(CLSID_PortableDeviceValuesCollection,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDeviceValuesCollection,
(VOID**) &pWriteResults);
CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDeviceValuesCollection");
}
// Create the collection to hold the event parameters
if (SUCCEEDED(hr))
{
hr = CoCreateInstance(CLSID_PortableDeviceValues,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDeviceValues,
(VOID**) &pEventParams);
CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDeviceValues");
}
if (SUCCEEDED(hr))
{
for (DWORD dwIndex = pContext->NextObject; dwIndex < cObjects; dwIndex++)
{
CComPtr<IPortableDeviceValues> pValues;
CComPtr<IPortableDeviceValues> pSetResults;
bool bObjectChanged = false;
hr = pContext->ValuesCollection->GetAt(dwIndex, &pValues);
CHECK_HR(hr, "Failed to get next values from bulk properties context");
// CoCreate a collection to store the per object results.
if (SUCCEEDED(hr))
{
hr = CoCreateInstance(CLSID_PortableDeviceValues,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDeviceValues,
(VOID**) &pSetResults);
CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDeviceValues");
}
if (SUCCEEDED(hr))
{
LPWSTR pszObjectID = NULL;
// Get which object this is for
hr = pValues->GetStringValue(WPD_OBJECT_ID, &pszObjectID);
if (SUCCEEDED(hr))
{
hr = m_pDevice->SetPropertyValues(pContext->Scope, pszObjectID, pValues, pSetResults, pEventParams, &bObjectChanged);
CHECK_HR(hr, "Failed to get count of values");
}
if (SUCCEEDED(hr))
{
// Ensure the write results contain which ObjectID this was for
hr = pSetResults->SetStringValue(WPD_OBJECT_ID, pszObjectID);
CHECK_HR(hr, "Failed to set WPD_OBJECT_ID in write results");
if (SUCCEEDED(hr) && bObjectChanged)
{
// set property values is successful and object has changed, so we post an event.
// This is best effort, so errors are ignored
HRESULT hrEvent = PostWpdEvent(pParams, pEventParams);
CHECK_HR(hrEvent, "Failed post event for updated object [%ws] (errors ignored)", pszObjectID);
}
pEventParams->Clear();
}
CoTaskMemFree(pszObjectID);
}
if (SUCCEEDED(hr))
{
hr = pWriteResults->Add(pSetResults);
CHECK_HR(hr, "Failed to add IPortableDeviceValues to IPortableDeviceValuesCollection");
}
pContext->NextObject++;
}
}
if (SUCCEEDED(hr))
{
hr = pResults->SetIUnknownValue(WPD_PROPERTY_OBJECT_PROPERTIES_BULK_WRITE_RESULTS, pWriteResults);
CHECK_HR(hr, "Failed to set WPD_PROPERTY_OBJECT_PROPERTIES_BULK_WRITE_RESULTS");
}
// Free the memory. CoTaskMemFree ignores NULLs so no need to check.
CoTaskMemFree(pwszContext);
SAFE_RELEASE(pContext);
return hr;
}
HRESULT
AsdkSheetSet::addCalloutBlock(char* blockName,
char* drawingName)
{
if(FAILED(isInitialized("addCalloutBlock")))
return E_FAIL;
// lock the the database first before doing any operation on it
if (FAILED(LockDatabase()))
{
acutPrintf("\n Database lock failed!");
return E_FAIL;
}
CComPtr<IAcSmCalloutBlocks> pCalloutBlk = NULL;
if (FAILED(m_pSheetSet->GetCalloutBlocks(&pCalloutBlk)))
{
acutPrintf("\n addCalloutBlock failed! Cannot get callout blocks!!");
return E_FAIL;
}
CComBSTR bstrBlockName(blockName);
CComBSTR bstrFileName(drawingName);
CComPtr<IAcSmAcDbBlockRecordReference> pCalloutRef = NULL;
if (FAILED(pCalloutRef.CoCreateInstance(L"AcSmComponents.AcSmAcDbBlockRecordReference")))
{
acutPrintf("\n addCalloutBlock failed! Cannot get named object reference!!");
return E_POINTER;
}
if (FAILED(pCalloutRef->InitNew(m_pDb)))
return E_FAIL;
if (FAILED(pCalloutRef->SetFileName(bstrFileName)))
{
acutPrintf("\n addCalloutBlock failed! Cannot set file name %s!!", drawingName);
return E_FAIL;
}
if (FAILED(pCalloutRef->SetName(bstrBlockName)))
{
acutPrintf("\n addCalloutBlock failed! Cannot set block name %s!!", blockName);
return E_FAIL;
}
if(FAILED(pCalloutBlk->Add(pCalloutRef)))
{
acutPrintf("\n addCalloutBlock failed! Cannot add callout reference!!");
return E_FAIL;
}
// Unlock database
if (FAILED(UnlockDatabase()))
{
acutPrintf("\n Cannot unlock database");
return E_FAIL;
}
return S_OK;
}
// Retreives the object identifier for the persistent unique identifer
void GetObjectIdentifierFromPersistentUniqueIdentifier(
IPortableDevice* pDevice)
{
if (pDevice == NULL)
{
printf("! A NULL IPortableDevice interface pointer was received\n");
return;
}
HRESULT hr = S_OK;
WCHAR szSelection[81] = {0};
CComPtr<IPortableDeviceContent> pContent;
CComPtr<IPortableDevicePropVariantCollection> pPersistentUniqueIDs;
CComPtr<IPortableDevicePropVariantCollection> pObjectIDs;
//<SnippetContentProp7>
// Prompt user to enter an unique identifier to convert to an object idenifier.
printf("Enter the Persistant Unique Identifier of the object you wish to convert into an object identifier.\n>");
hr = StringCbGetsW(szSelection,sizeof(szSelection));
if (FAILED(hr))
{
printf("An invalid persistent object identifier was specified, aborting the query operation\n");
}
//</SnippetContentProp7>
// 1) Get an IPortableDeviceContent interface from the IPortableDevice interface to
// access the content-specific methods.
//<SnippetContentProp8>
if (SUCCEEDED(hr))
{
hr = pDevice->Content(&pContent);
if (FAILED(hr))
{
printf("! Failed to get IPortableDeviceContent from IPortableDevice, hr = 0x%lx\n",hr);
}
}
//</SnippetContentProp8>
// 2) CoCreate an IPortableDevicePropVariantCollection interface to hold the the Unique Identifiers
// to query for Object Identifiers.
//
// NOTE: This is a collection interface so more than 1 identifier can be requested at a time.
// This sample only requests a single unique identifier.
//<SnippetContentProp9>
hr = CoCreateInstance(CLSID_PortableDevicePropVariantCollection,
NULL,
CLSCTX_INPROC_SERVER,
IID_PPV_ARGS(&pPersistentUniqueIDs));
//</SnippetContentProp9>
//<SnippetContentProp10>
if (SUCCEEDED(hr))
{
if (pPersistentUniqueIDs != NULL)
{
PROPVARIANT pv = {0};
PropVariantInit(&pv);
// Initialize a PROPVARIANT structure with the object identifier string
// that the user selected above. Notice we are allocating memory for the
// PWSTR value. This memory will be freed when PropVariantClear() is
// called below.
pv.vt = VT_LPWSTR;
pv.pwszVal = AtlAllocTaskWideString(szSelection);
if (pv.pwszVal != NULL)
{
// Add the object identifier to the objects-to-delete list
// (We are only deleting 1 in this example)
hr = pPersistentUniqueIDs->Add(&pv);
if (SUCCEEDED(hr))
{
// 3) Attempt to get the unique idenifier for the object from the device
hr = pContent->GetObjectIDsFromPersistentUniqueIDs(pPersistentUniqueIDs,
&pObjectIDs);
if (SUCCEEDED(hr))
{
PROPVARIANT pvId = {0};
hr = pObjectIDs->GetAt(0, &pvId);
if (SUCCEEDED(hr))
{
printf("The persistent unique identifier '%ws' relates to object identifier '%ws' on the device.\n", szSelection, pvId.pwszVal);
}
else
{
printf("! Failed to get the object identifier for '%ws' from the IPortableDevicePropVariantCollection, hr = 0x%lx\n",szSelection, hr);
}
// Free the returned allocated string from the GetAt() call
PropVariantClear(&pvId);
}
else
{
printf("! Failed to get the object identifier from persistent object idenifier '%ws', hr = 0x%lx\n",szSelection, hr);
}
}
else
{
printf("! Failed to get the object identifier from persistent object idenifier because we could no add the persistent object identifier string to the IPortableDevicePropVariantCollection, hr = 0x%lx\n",hr);
}
}
else
{
hr = E_OUTOFMEMORY;
printf("! Failed to get the object identifier because we could no allocate memory for the persistent object identifier string, hr = 0x%lx\n",hr);
}
// Free any allocated values in the PROPVARIANT before exiting
PropVariantClear(&pv);
}
}
//</SnippetContentProp10>
}
/**
* This method is called when we receive a WPD_COMMAND_OBJECT_PROPERTIES_BULK_GET_VALUES_BY_OBJECT_FORMAT_NEXT
* command.
*
* The parameters sent to us are:
* - WPD_PROPERTY_OBJECT_PROPERTIES_BULK_CONTEXT: the context the driver returned to
* the client in OnGetValuesByObjectFormatStart.
*
* The driver should:
* - Return the next set of property values in WPD_PROPERTY_OBJECT_PROPERTIES_BULK_VALUES.
* If there are no more properties to be read an
* empty collection should be returned.
* - It is up to the driver to return as many object property values as it wants. If zero values are returned
* it is assumed the bulk operation is complete and the WPD_COMMAND_OBJECT_PROPERTIES_BULK_GET_VALUES_BY_OBJECT_FORMAT_END
* will be called next.
*
* - S_OK should be returned if the collection can be returned successfully.
* - Any error return indicates that the driver did not fill in any results, and the caller will
* not attempt to unpack any property values.
*/
HRESULT WpdObjectPropertiesBulk::OnGetValuesByObjectFormatNext(
_In_ IPortableDeviceValues* pParams,
_In_ IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
LPWSTR pwszContext = NULL;
BulkPropertiesContext* pContext = NULL;
DWORD cObjects = 0;
CComPtr<IPortableDeviceValuesCollection> pCollection;
hr = pParams->GetStringValue(WPD_PROPERTY_OBJECT_PROPERTIES_BULK_CONTEXT, &pwszContext);
CHECK_HR(hr, "Failed to get WPD_PROPERTY_OBJECT_PROPERTIES_BULK_CONTEXT from IPortableDeviceValues");
// Get the bulk property operation context
if (SUCCEEDED(hr))
{
hr = GetClientContext(pParams, pwszContext, (IUnknown**) &pContext);
CHECK_HR(hr, "Failed to get bulk property context");
}
// Make sure the the collection holds VT_LPWSTR values.
if (SUCCEEDED(hr))
{
hr = pContext->ObjectIDs->ChangeType(VT_LPWSTR);
CHECK_HR(hr, "Failed to change objectIDs collection to VT_LPWSTR");
}
if (SUCCEEDED(hr))
{
hr = pContext->ObjectIDs->GetCount(&cObjects);
CHECK_HR(hr, "Failed to get number of objectIDs from bulk properties context");
}
if (SUCCEEDED(hr))
{
cObjects = cObjects - pContext->NextObject;
if(cObjects > MAX_OBJECTS_TO_RETURN)
{
cObjects = MAX_OBJECTS_TO_RETURN;
}
}
if (SUCCEEDED(hr))
{
hr = CoCreateInstance(CLSID_PortableDeviceValuesCollection,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDeviceValuesCollection,
(VOID**) &pCollection);
CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDeviceValuesCollection");
}
if (SUCCEEDED(hr))
{
for (DWORD dwIndex = pContext->NextObject, dwCount = 0; dwCount < cObjects; dwCount++, dwIndex++)
{
CComPtr<IPortableDeviceValues> pValues;
PROPVARIANT pv = {0};
PropVariantInit(&pv);
hr = pContext->ObjectIDs->GetAt(dwIndex, &pv);
CHECK_HR(hr, "Failed to get next object ID from bulk properties context");
if (SUCCEEDED(hr))
{
hr = CoCreateInstance(CLSID_PortableDeviceValues,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDeviceValues,
(VOID**) &pValues);
CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDeviceValuesCollection");
}
if (SUCCEEDED(hr))
{
// If a key list was supplied, get the specified object properties, other get all
// properties.
if(pContext->Properties != NULL)
{
hr = m_pDevice->GetPropertyValues(pContext->Scope, pv.pwszVal, pContext->Properties, pValues);
CHECK_HR(hr, "Failed to get property values for [%ws]", pv.pwszVal);
}
else
{
hr = m_pDevice->GetAllPropertyValues(pContext->Scope,pv.pwszVal, pValues);
CHECK_HR(hr, "Failed to get property values for [%ws]", pv.pwszVal);
}
}
// Add the ObjectID to the returned results
if (SUCCEEDED(hr))
{
hr = pValues->SetStringValue(WPD_OBJECT_ID, pv.pwszVal);
CHECK_HR(hr, "Failed to set WPD_OBJECT_ID for %ws", pv.pwszVal);
}
if (SUCCEEDED(hr))
{
hr = pCollection->Add(pValues);
CHECK_HR(hr, "Failed to add IPortableDeviceValues to IPortableDeviceValuesCollection");
}
PropVariantClear(&pv);
pContext->NextObject++;
}
}
if (SUCCEEDED(hr))
{
hr = pResults->SetIUnknownValue(WPD_PROPERTY_OBJECT_PROPERTIES_BULK_VALUES, pCollection);
CHECK_HR(hr, "Failed to set WPD_PROPERTY_OBJECT_PROPERTIES_BULK_VALUES");
}
// Free the memory. CoTaskMemFree ignores NULLs so no need to check.
CoTaskMemFree(pwszContext);
SAFE_RELEASE(pContext);
return hr;
}
// Reads a set of properties for all objects.
void ReadContentPropertiesBulk(
IPortableDevice* pDevice)
{
if (pDevice == NULL)
{
printf("! A NULL IPortableDevice interface pointer was received\n");
return;
}
HRESULT hr = S_OK;
GUID guidContext = GUID_NULL;
CGetBulkValuesCallback* pCallback = NULL;
CComPtr<IPortableDeviceProperties> pProperties;
CComPtr<IPortableDevicePropertiesBulk> pPropertiesBulk;
CComPtr<IPortableDeviceValues> pObjectProperties;
CComPtr<IPortableDeviceContent> pContent;
CComPtr<IPortableDeviceKeyCollection> pPropertiesToRead;
CComPtr<IPortableDevicePropVariantCollection> pObjectIDs;
// 1) Get an IPortableDeviceContent interface from the IPortableDevice interface to
// access the content-specific methods.
hr = pDevice->Content(&pContent);
if (FAILED(hr))
{
printf("! Failed to get IPortableDeviceContent from IPortableDevice, hr = 0x%lx\n",hr);
}
// 2) Get an IPortableDeviceProperties interface from the IPortableDeviceContent interface
// to access the property-specific methods.
if (SUCCEEDED(hr))
{
hr = pContent->Properties(&pProperties);
if (FAILED(hr))
{
printf("! Failed to get IPortableDeviceProperties from IPortableDevice, hr = 0x%lx\n",hr);
}
}
// 3) Check to see if the driver supports BULK property operations by call QueryInterface
// on the IPortableDeviceProperties interface for IPortableDevicePropertiesBulk
if (SUCCEEDED(hr))
{
hr = pProperties->QueryInterface(IID_PPV_ARGS(&pPropertiesBulk));
if (FAILED(hr))
{
printf("This driver does not support BULK property operations.\n");
}
}
// 4) CoCreate an IPortableDeviceKeyCollection interface to hold the the property keys
// we wish to read.
if (SUCCEEDED(hr))
{
hr = CoCreateInstance(CLSID_PortableDeviceKeyCollection,
NULL,
CLSCTX_INPROC_SERVER,
IID_PPV_ARGS(&pPropertiesToRead));
if (FAILED(hr))
{
printf("! Failed to CoCreate IPortableDeviceKeyCollection to hold the property keys to read, hr = 0x%lx\n",hr);
}
}
if (SUCCEEDED(hr))
{
// 5) Populate the IPortableDeviceKeyCollection with the keys we wish to read.
// NOTE: We are not handling any special error cases here so we can proceed with
// adding as many of the target properties as we can.
if (pPropertiesToRead != NULL)
{
HRESULT hrTemp = S_OK;
hrTemp = pPropertiesToRead->Add(WPD_OBJECT_PARENT_ID);
if (FAILED(hrTemp))
{
printf("! Failed to add WPD_OBJECT_PARENT_ID to IPortableDeviceKeyCollection, hr= 0x%lx\n", hrTemp);
}
hrTemp = pPropertiesToRead->Add(WPD_OBJECT_NAME);
if (FAILED(hrTemp))
{
printf("! Failed to add WPD_OBJECT_NAME to IPortableDeviceKeyCollection, hr= 0x%lx\n", hrTemp);
}
hrTemp = pPropertiesToRead->Add(WPD_OBJECT_PERSISTENT_UNIQUE_ID);
if (FAILED(hrTemp))
{
printf("! Failed to add WPD_OBJECT_PERSISTENT_UNIQUE_ID to IPortableDeviceKeyCollection, hr= 0x%lx\n", hrTemp);
}
hrTemp = pPropertiesToRead->Add(WPD_OBJECT_FORMAT);
if (FAILED(hrTemp))
{
printf("! Failed to add WPD_OBJECT_FORMAT to IPortableDeviceKeyCollection, hr= 0x%lx\n", hrTemp);
}
hrTemp = pPropertiesToRead->Add(WPD_OBJECT_CONTENT_TYPE);
if (FAILED(hrTemp))
{
printf("! Failed to add WPD_OBJECT_CONTENT_TYPE to IPortableDeviceKeyCollection, hr= 0x%lx\n", hrTemp);
}
}
}
// 6) Create an instance of the IPortableDevicePropertiesBulkCallback object.
if (SUCCEEDED(hr))
{
pCallback = new (std::nothrow) CGetBulkValuesCallback();
if (pCallback == NULL)
{
hr = E_OUTOFMEMORY;
printf("! Failed to allocate CGetBulkValuesCallback, hr = 0x%lx\n", hr);
}
}
// 7) Call our helper function CreateIPortableDevicePropVariantCollectionWithAllObjectIDs
// to enumerate and create an IPortableDevicePropVariantCollection with the object
// identifiers needed to perform the bulk operation on.
if (SUCCEEDED(hr))
{
hr = CreateIPortableDevicePropVariantCollectionWithAllObjectIDs(pContent,
&pObjectIDs);
}
// 8) Call QueueGetValuesByObjectList to initialize the Asynchronous
// property operation.
if (SUCCEEDED(hr))
{
hr = pPropertiesBulk->QueueGetValuesByObjectList(pObjectIDs,
pPropertiesToRead,
pCallback,
&guidContext);
// 9) Call Start() to actually being the property operation
if(SUCCEEDED(hr))
{
// Cleanup any previously created global event handles.
if (g_hBulkPropertyOperationEvent != NULL)
{
CloseHandle(g_hBulkPropertyOperationEvent);
g_hBulkPropertyOperationEvent = NULL;
}
// In order to create a simpler to follow example we create and wait infinitly
// for the bulk property operation to complete and ignore any errors.
// Production code should be written in a more robust manner.
// Create the global event handle to wait on for the bulk operation
// to complete.
g_hBulkPropertyOperationEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
if (g_hBulkPropertyOperationEvent != NULL)
{
// Call Start() to actually being the Asynchronous bulk operation.
hr = pPropertiesBulk->Start(guidContext);
if(FAILED(hr))
{
printf("! Failed to start property operation, hr = 0x%lx\n", hr);
}
}
else
{
printf("! Failed to create the global event handle to wait on for the bulk operation. Aborting operation.\n");
}
}
else
{
printf("! QueueGetValuesByObjectList Failed, hr = 0x%lx\n", hr);
}
}
// In order to create a simpler to follow example we will wait infinitly for the operation
// to complete and ignore any errors. Production code should be written in a more
// robust manner.
if (SUCCEEDED(hr))
{
if (g_hBulkPropertyOperationEvent != NULL)
{
WaitForSingleObject(g_hBulkPropertyOperationEvent, INFINITE);
}
}
if (pCallback != NULL)
{
pCallback->Release();
pCallback = NULL;
}
// Cleanup any created global event handles before exiting..
if (g_hBulkPropertyOperationEvent != NULL)
{
CloseHandle(g_hBulkPropertyOperationEvent);
g_hBulkPropertyOperationEvent = NULL;
}
}
HRESULT CConnect::OnConnection(LPDISPATCH Application, ext_ConnectMode ConnectMode, LPDISPATCH AddInInst, SAFEARRAY **custom)
{
TSAUTO();
Application->QueryInterface(__uuidof(IDispatch), reinterpret_cast<LPVOID*>(&this->m_spApplication));
AddInInst->QueryInterface(__uuidof(IDispatch), reinterpret_cast<LPVOID*>(&this->m_spAddInInstance));
//是否显示按钮
CRegKey key;
DWORD dwValue;
if(key.Open(HKEY_CURRENT_USER, _T("Software\\WordEncLock")) == ERROR_SUCCESS){
if (key.QueryValue(dwValue, _T("silent")) == ERROR_SUCCESS){
if (dwValue == 1){
g_sIsSilent = TRUE;
}
}
}
key.Close();
if (g_sIsSilent){
return S_OK;
}
CComQIPtr<_Application> spApp(Application);
ATLASSERT(spApp);
if (!spApp){//获取失败说明是excel
//g_sIsSilent = TRUE;
return S_OK;
}
g_Application = spApp;
HRESULT hr;
CComPtr<Office::_CommandBars> spCmdBars;
hr = g_Application->get_CommandBars(&spCmdBars);
if(FAILED(hr))
return hr;
ATLASSERT(spCmdBars);
// now we add a new toolband to Word
// to which we''ll add 2 buttons
CComVariant vName("");
CComPtr<Office::CommandBar> spNewCmdBar;
CComVariant vPos(1);
CComVariant vTemp(VARIANT_TRUE); // menu is temporary
CComVariant vEmpty(DISP_E_PARAMNOTFOUND, VT_ERROR);
spNewCmdBar = spCmdBars->Add(vName, vPos, vEmpty, vTemp);
CComPtr < Office::CommandBarControls> spBarControls;
spBarControls = spNewCmdBar->GetControls();
ATLASSERT(spBarControls);
CComVariant vToolBarType(1);
CComVariant vShow(VARIANT_TRUE);
CComPtr<Office::CommandBarControl> spNewBar;
// add first button
spNewBar = spBarControls->Add(vToolBarType,vEmpty,vEmpty,vEmpty,vShow);
ATLASSERT(spNewBar);
CComQIPtr < Office::_CommandBarButton> spCmdButton(spNewBar);
ATLASSERT(spCmdButton);
m_spButton = spCmdButton;
AppEvents::DispEventAdvise(m_spButton);
HBITMAP hBmp =(HBITMAP)::LoadImage(g_hModule,
MAKEINTRESOURCE(IDB_BITMAP1),IMAGE_BITMAP,0,0,LR_LOADMAP3DCOLORS);
::OpenClipboard(NULL);
::EmptyClipboard();
::SetClipboardData(CF_BITMAP, (HANDLE)hBmp);
::CloseClipboard();
::DeleteObject(hBmp);
spCmdButton->PutStyle(Office::msoButtonIconAndWrapCaption);
hr = spCmdButton->PasteFace();
if (FAILED(hr))
return hr;
spCmdButton->PutVisible(VARIANT_TRUE);
spCmdButton->PutCaption(OLESTR("Word安全锁"));
spCmdButton->PutEnabled(VARIANT_TRUE);
spCmdButton->PutTooltipText(OLESTR("Word安全锁"));
spCmdButton->PutTag(OLESTR("给Word文档加密"));
spNewCmdBar->PutVisible(VARIANT_TRUE);
return S_OK;
}
HRESULT CDevice::GetDeviceFriendlyName(
__deref_out_opt LPWSTR* pwszDeviceFriendlyName)
{
HRESULT hr = S_OK;
CComPtr<IPortableDeviceValues> pParams;
CComPtr<IPortableDeviceValues> pResults;
CComPtr<IPortableDeviceKeyCollection> pKeys;
CComPtr<IPortableDeviceValues> pValues;
if (pwszDeviceFriendlyName == NULL)
{
hr = E_INVALIDARG;
return hr;
}
*pwszDeviceFriendlyName = NULL;
// CoCreate a collection to store the WPD_COMMAND_OBJECT_PROPERTIES_GET command parameters.
if (hr == S_OK)
{
hr = CoCreateInstance(CLSID_PortableDeviceValues,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDeviceValues,
(VOID**)&pParams);
CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDeviceValues");
}
// CoCreate a collection to store the WPD_COMMAND_OBJECT_PROPERTIES_GET command results.
if (hr == S_OK)
{
hr = CoCreateInstance(CLSID_PortableDeviceValues,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDeviceValues,
(VOID**)&pResults);
CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDeviceValues");
}
// CoCreate a collection to store the requested property keys. In our case, we are requesting just the device friendly name
// (WPD_DEVICE_FRIENDLY_NAME)
if (hr == S_OK)
{
hr = CoCreateInstance(CLSID_PortableDeviceKeyCollection,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDeviceKeyCollection,
(VOID**)&pKeys);
CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDeviceKeyCollection for results");
}
// Set the params
if (hr == S_OK)
{
hr = pParams->SetGuidValue(WPD_PROPERTY_COMMON_COMMAND_CATEGORY, WPD_COMMAND_OBJECT_PROPERTIES_GET.fmtid);
CHECK_HR(hr, ("Failed to set WPD_PROPERTY_COMMON_COMMAND_CATEGORY"));
}
if (hr == S_OK)
{
hr = pParams->SetUnsignedIntegerValue(WPD_PROPERTY_COMMON_COMMAND_ID, WPD_COMMAND_OBJECT_PROPERTIES_GET.pid);
CHECK_HR(hr, ("Failed to set WPD_PROPERTY_COMMON_COMMAND_ID"));
}
if (hr == S_OK)
{
hr = pParams->SetStringValue(WPD_PROPERTY_OBJECT_PROPERTIES_OBJECT_ID, WPD_DEVICE_OBJECT_ID);
CHECK_HR(hr, ("Failed to set WPD_PROPERTY_OBJECT_PROPERTIES_OBJECT_ID"));
}
if (hr == S_OK)
{
hr = pKeys->Add(WPD_DEVICE_FRIENDLY_NAME);
CHECK_HR(hr, ("Failed to add WPD_DEVICE_FRIENDLY_NAME to key collection"));
}
if (hr == S_OK)
{
hr = pParams->SetIPortableDeviceKeyCollectionValue(WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_KEYS, pKeys);
CHECK_HR(hr, ("Failed to set WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_KEYS"));
}
// Make the call
if (hr == S_OK)
{
hr = m_pWpdBaseDriver->DispatchWpdMessage(pParams, pResults);
CHECK_HR(hr, ("Failed to dispatch message to get supported content types"));
}
// Get the results
if (hr == S_OK)
{
hr = pResults->GetIPortableDeviceValuesValue(WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_VALUES, &pValues);
CHECK_HR(hr, ("Failed to get WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_VALUES"));
}
if (hr == S_OK)
{
hr = pValues->GetStringValue(WPD_DEVICE_FRIENDLY_NAME, pwszDeviceFriendlyName);
CHECK_HR(hr, ("Failed to get WPD_DEVICE_FRIENDLY_NAME"));
}
return hr;
}
/**
* This method is called when we receive a WPD_COMMAND_OBJECT_MANAGEMENT_MOVE_OBJECTS
* command.
*
* This command will move the specified objects to the destination folder.
*
* The parameters sent to us are:
* - WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS : the ObjectIDs, indicating which objects to move. These may
* be folder objects.
* - WPD_PROPERTY_OBJECT_MANAGEMENT_DESTINATION_FOLDER_OBJECT_ID: Indicates the destination folder for the move operation.
*
* The driver should:
* - Attempt to Move the object specified in WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS to the folder specified in
* WPD_PROPERTY_OBJECT_MANAGEMENT_DESTINATION_FOLDER_OBJECT_ID.
* - Fill out the operation results in WPD_PROPERTY_OBJECT_MANAGEMENT_MOVE_RESULTS. It contains an IportableDevicePropVariantCollection of
* VT_ERROR values indicating the success or failure of the operation for that element.
* Order is implicit, i.e. the first element of WPD_PROPERTY_OBJECT_MANAGEMENT_MOVE_RESULTS corresponds to the first element of WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS and so on.
* - The driver should return:
* - S_OK if all objects were moved successfully.
* - S_FALSE if any object move failed.
* - An error return indicates that the driver did not move any objects, and
* WPD_PROPERTY_OBJECT_MANAGEMENT_MOVE_RESULTS is ignored.
*/
HRESULT WpdObjectManagement::OnMove(
IPortableDeviceValues* pParams,
IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
LPWSTR pszDestFolderObjectID = NULL;
CComPtr<IPortableDevicePropVariantCollection> pObjectIDs;
CComPtr<IPortableDevicePropVariantCollection> pMoveResults;
BOOL bMoveFailed = FALSE;
VARTYPE vt = VT_EMPTY;
if (hr == S_OK)
{
hr = pParams->GetIPortableDevicePropVariantCollectionValue(WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS, &pObjectIDs);
CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS");
}
// Ensure that this is a collection of VT_LPWSTR
if (hr == S_OK)
{
hr = pObjectIDs->GetType(&vt);
CHECK_HR(hr, "Failed to get the VARTYP of WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS");
if (hr == S_OK)
{
if (vt != VT_LPWSTR)
{
hr = E_INVALIDARG;
CHECK_HR(hr, "WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS is not a collection of VT_LPWSTR");
}
}
}
if (hr == S_OK)
{
hr = pParams->GetStringValue(WPD_PROPERTY_OBJECT_MANAGEMENT_DESTINATION_FOLDER_OBJECT_ID, &pszDestFolderObjectID);
CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_MANAGEMENT_DESTINATION_FOLDER_OBJECT_ID");
}
if (hr == S_OK)
{
hr = CoCreateInstance(CLSID_PortableDevicePropVariantCollection,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDevicePropVariantCollection,
(VOID**) &pMoveResults);
CHECK_HR(hr, "Failed to CoCreateInstance CLSID_PortableDevicePropVariantCollection");
}
if (hr == S_OK)
{
DWORD cObjects = 0;
// Loop through the object list and attempt to move
hr = pObjectIDs->GetCount(&cObjects);
CHECK_HR(hr, "Failed to get number of objects to move");
if (hr == S_OK)
{
for(DWORD dwIndex = 0; dwIndex < cObjects; dwIndex++)
{
HRESULT hrTemp = S_OK;
PROPVARIANT pv = {0};
PropVariantInit(&pv);
// Get the next Object to move
hrTemp = pObjectIDs->GetAt(dwIndex, &pv);
CHECK_HR(hr, "Failed to get next object id at index %d", dwIndex);
if (hrTemp == S_OK)
{
// Move this object
hrTemp = m_pFakeDevice->MoveObject(pv.pwszVal, pszDestFolderObjectID);
CHECK_HR(hrTemp, "Failed to move object [%ws] to folder [%ws]", pv.pwszVal, pszDestFolderObjectID);
if(FAILED(hrTemp))
{
bMoveFailed = TRUE;
}
PROPVARIANT pvResult = {0};
PropVariantInit(&pvResult);
// Save this result
pvResult.vt = VT_ERROR;
pvResult.scode = hrTemp;
hrTemp = pMoveResults->Add(&pvResult);
CHECK_HR(hrTemp, "Failed to add result for [%ws] to list of results", pv.pwszVal);
PropVariantClear(&pvResult);
}
PropVariantClear(&pv);
}
}
}
// Set the results
if (hr == S_OK)
{
hr = pResults->SetIPortableDevicePropVariantCollectionValue(WPD_PROPERTY_OBJECT_MANAGEMENT_MOVE_RESULTS, pMoveResults);
CHECK_HR(hr, "Failed to set WPD_PROPERTY_OBJECT_MANAGEMENT_MOVE_RESULTS");
}
CoTaskMemFree(pszDestFolderObjectID);
// If an object failed to move, make sure we return S_FALSE
if ((hr == S_OK) && (bMoveFailed))
{
hr = S_FALSE;
}
return hr;
}
// Writes a set of properties for all objects.
void WriteContentPropertiesBulk(
IPortableDevice* pDevice)
{
if (pDevice == NULL)
{
printf("! A NULL IPortableDevice interface pointer was received\n");
return;
}
HRESULT hr = S_OK;
GUID guidContext = GUID_NULL;
CSetBulkValuesCallback* pCallback = NULL;
CComPtr<IPortableDeviceProperties> pProperties;
CComPtr<IPortableDevicePropertiesBulk> pPropertiesBulk;
CComPtr<IPortableDeviceValues> pObjectProperties;
CComPtr<IPortableDeviceContent> pContent;
CComPtr<IPortableDeviceValuesCollection> pPropertiesToWrite;
CComPtr<IPortableDevicePropVariantCollection> pObjectIDs;
DWORD cObjectIDs = 0;
// 1) Get an IPortableDeviceContent interface from the IPortableDevice interface to
// access the content-specific methods.
hr = pDevice->Content(&pContent);
if (FAILED(hr))
{
printf("! Failed to get IPortableDeviceContent from IPortableDevice, hr = 0x%lx\n",hr);
}
// 2) Get an IPortableDeviceProperties interface from the IPortableDeviceContent interface
// to access the property-specific methods.
if (SUCCEEDED(hr))
{
hr = pContent->Properties(&pProperties);
if (FAILED(hr))
{
printf("! Failed to get IPortableDeviceProperties from IPortableDevice, hr = 0x%lx\n",hr);
}
}
// 3) Check to see if the driver supports BULK property operations by call QueryInterface
// on the IPortableDeviceProperties interface for IPortableDevicePropertiesBulk
if (SUCCEEDED(hr))
{
hr = pProperties->QueryInterface(IID_PPV_ARGS(&pPropertiesBulk));
if (FAILED(hr))
{
printf("This driver does not support BULK property operations.\n");
}
}
// 4) CoCreate an IPortableDeviceValuesCollection interface to hold the the properties
// we wish to write.
if (SUCCEEDED(hr))
{
hr = CoCreateInstance(CLSID_PortableDeviceValuesCollection,
NULL,
CLSCTX_INPROC_SERVER,
IID_PPV_ARGS(&pPropertiesToWrite));
if (FAILED(hr))
{
printf("! Failed to CoCreate IPortableDeviceValuesCollection for bulk property values, hr = 0x%lx\n", hr);
}
}
// 6) Create an instance of the IPortableDevicePropertiesBulkCallback object.
if (SUCCEEDED(hr))
{
pCallback = new (std::nothrow) CSetBulkValuesCallback();
if (pCallback == NULL)
{
hr = E_OUTOFMEMORY;
printf("! Failed to allocate CSetBulkValuesCallback, hr = 0x%lx\n", hr);
}
}
// 7) Call our helper function CreateIPortableDevicePropVariantCollectionWithAllObjectIDs
// to enumerate and create an IPortableDevicePropVariantCollection with the object
// identifiers needed to perform the bulk operation on.
if (SUCCEEDED(hr))
{
hr = CreateIPortableDevicePropVariantCollectionWithAllObjectIDs(pContent,
&pObjectIDs);
}
if (SUCCEEDED(hr))
{
hr = pObjectIDs->GetCount(&cObjectIDs);
if (FAILED(hr))
{
printf("! Failed to get number of objectIDs from IPortableDevicePropVariantCollection, hr = 0x%lx\n", hr);
}
}
// 8) Iterate through object list and add appropriate IPortableDeviceValues to collection
if (SUCCEEDED(hr))
{
for(DWORD dwIndex = 0; (dwIndex < cObjectIDs) && (hr == S_OK); dwIndex++)
{
CComPtr<IPortableDeviceValues> pValues;
PROPVARIANT pv = {0};
PropVariantInit(&pv);
hr = CoCreateInstance(CLSID_PortableDeviceValues,
NULL,
CLSCTX_INPROC_SERVER,
IID_PPV_ARGS(&pValues));
if (FAILED(hr))
{
printf("! Failed to CoCreate CLSID_PortableDeviceValues, hr = 0x%lx\n", hr);
}
// Get the Object ID whose properties we will set
if (hr == S_OK)
{
hr = pObjectIDs->GetAt(dwIndex, &pv);
if (FAILED(hr))
{
printf("! Failed to get next Object ID from list, hr = 0x%lx\n", hr);
}
}
// Save them into the IPortableDeviceValues so the driver knows which object this proeprty set belongs to
if (hr == S_OK)
{
hr = pValues->SetStringValue(WPD_OBJECT_ID, pv.pwszVal);
if (FAILED(hr))
{
printf("! Failed to set WPD_OBJECT_ID, hr = 0x%lx\n", hr);
}
}
// Set the new values. In this sample, we attempt to set the name property.
if (hr == S_OK)
{
CAtlStringW strValue;
strValue.Format(L"NewName%d", dwIndex);
hr = pValues->SetStringValue(WPD_OBJECT_NAME, strValue.GetString());
if (FAILED(hr))
{
printf("! Failed to set WPD_OBJECT_NAME, hr = 0x%lx\n", hr);
}
}
// Add this property set to the collection
if (hr == S_OK)
{
hr = pPropertiesToWrite->Add(pValues);
if (FAILED(hr))
{
printf("! Failed to add values to collection, hr = 0x%lx\n", hr);
}
}
PropVariantClear(&pv);
}
}
// 9) Call QueueSetValuesByObjectList to initialize the Asynchronous
// property operation.
if (SUCCEEDED(hr))
{
hr = pPropertiesBulk->QueueSetValuesByObjectList(pPropertiesToWrite,
pCallback,
&guidContext);
// 10) Call Start() to actually being the property operation
if(SUCCEEDED(hr))
{
// Cleanup any previously created global event handles.
if (g_hBulkPropertyOperationEvent != NULL)
{
CloseHandle(g_hBulkPropertyOperationEvent);
g_hBulkPropertyOperationEvent = NULL;
}
// In order to create a simpler to follow example we create and wait infinitly
// for the bulk property operation to complete and ignore any errors.
// Production code should be written in a more robust manner.
// Create the global event handle to wait on for the bulk operation
// to complete.
g_hBulkPropertyOperationEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
if (g_hBulkPropertyOperationEvent != NULL)
{
// Call Start() to actually being the Asynchronous bulk operation.
hr = pPropertiesBulk->Start(guidContext);
if(FAILED(hr))
{
printf("! Failed to start property operation, hr = 0x%lx\n", hr);
}
}
else
{
printf("! Failed to create the global event handle to wait on for the bulk operation. Aborting operation.\n");
}
}
else
{
printf("! QueueSetValuesByObjectList Failed, hr = 0x%lx\n", hr);
}
}
// In order to create a simpler to follow example we will wait infinitly for the operation
// to complete and ignore any errors. Production code should be written in a more
// robust manner.
if (SUCCEEDED(hr))
{
if (g_hBulkPropertyOperationEvent != NULL)
{
WaitForSingleObject(g_hBulkPropertyOperationEvent, INFINITE);
}
}
if (pCallback != NULL)
{
pCallback->Release();
pCallback = NULL;
}
// Cleanup any created global event handles before exiting..
if (g_hBulkPropertyOperationEvent != NULL)
{
CloseHandle(g_hBulkPropertyOperationEvent);
g_hBulkPropertyOperationEvent = NULL;
}
}
/**
* This method is called when we receive a WPD_COMMAND_CAPABILITIES_GET_FUNCTIONAL_OBJECTS
* command. It is sent when the caller is interesting in finding the object IDs for all
* functional objects belonging to the specified functional category.
* Note: the number of functional objects is expected to be very small (less than 8 for the
* whole device).
*
* The parameters sent to us are:
* - WPD_PROPERTY_CAPABILITIES_FUNCTIONAL_CATEGORY - a GUID value containing the category
* the caller is looking for. If the value is WPD_FUNCTIONAL_CATEGORY_ALL, then the driver
* must return all functional objects, no matter which category they belong to.
*
* The driver should:
* - Return an IPortableDevicePropVariantCollection (of type VT_LPWSTR) in
* WPD_PROPERTY_CAPABILITIES_FUNCTIONAL_OBJECTS, containing
* the ids of the functional objects who belong to the specified functional category.
* If there are no objects in the specified category, the driver should return an
* empty collection.
*/
HRESULT WpdCapabilities::OnGetFunctionalObjects(
_In_ IPortableDeviceValues* pParams,
_In_ IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
GUID guidFunctionalCategory = GUID_NULL;
CComPtr<IPortableDevicePropVariantCollection> pFunctionalObjects;
// First get ALL parameters for this command. If we cannot get ALL parameters
// then E_INVALIDARG should be returned and no further processing should occur.
// Get the functional category whose functional object identifiers have been requested
if (hr == S_OK)
{
hr = pParams->GetGuidValue(WPD_PROPERTY_CAPABILITIES_FUNCTIONAL_CATEGORY, &guidFunctionalCategory);
CHECK_HR(hr, "Missing value for WPD_PROPERTY_CAPABILITIES_FUNCTIONAL_CATEGORY");
}
// CoCreate a collection to store the supported functional object identifiers.
if (hr == S_OK)
{
hr = CoCreateInstance(CLSID_PortableDevicePropVariantCollection,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDevicePropVariantCollection,
(VOID**) &pFunctionalObjects);
CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDevicePropVariantCollection");
}
// Add the supported functional object identifiers for the specified functional
// category to the collection.
if (hr == S_OK)
{
PROPVARIANT pv = {0};
PropVariantInit(&pv);
// Don't call PropVariantClear, since we did not allocate the memory for these object identifiers
// Add WPD_DEVICE_OBJECT_ID to the functional object identifiers collection
if (hr == S_OK)
{
if ((guidFunctionalCategory == WPD_FUNCTIONAL_CATEGORY_DEVICE) ||
(guidFunctionalCategory == WPD_FUNCTIONAL_CATEGORY_ALL))
{
pv.vt = VT_LPWSTR;
pv.pwszVal = WPD_DEVICE_OBJECT_ID;
hr = pFunctionalObjects->Add(&pv);
CHECK_HR(hr, "Failed to add device object ID");
}
}
// Add STORAGE_OBJECT_ID to the functional object identifiers collection
if (hr == S_OK)
{
if ((guidFunctionalCategory == WPD_FUNCTIONAL_CATEGORY_STORAGE) ||
(guidFunctionalCategory == WPD_FUNCTIONAL_CATEGORY_ALL))
{
pv.vt = VT_LPWSTR;
pv.pwszVal = STORAGE_OBJECT_ID;
hr = pFunctionalObjects->Add(&pv);
CHECK_HR(hr, "Failed to add storage object ID");
}
}
}
// Set the WPD_PROPERTY_CAPABILITIES_FUNCTIONAL_OBJECTS value in the results.
if (hr == S_OK)
{
hr = pResults->SetIUnknownValue(WPD_PROPERTY_CAPABILITIES_FUNCTIONAL_OBJECTS, pFunctionalObjects);
CHECK_HR(hr, "Failed to set WPD_PROPERTY_CAPABILITIES_FUNCTIONAL_OBJECTS");
}
return hr;
}
// Reads properties for the user specified object.
void ReadContentProperties(
IPortableDevice* pDevice)
{
if (pDevice == NULL)
{
printf("! A NULL IPortableDevice interface pointer was received\n");
return;
}
HRESULT hr = S_OK;
WCHAR szSelection[81] = {0};
CComPtr<IPortableDeviceProperties> pProperties;
CComPtr<IPortableDeviceValues> pObjectProperties;
CComPtr<IPortableDeviceContent> pContent;
CComPtr<IPortableDeviceKeyCollection> pPropertiesToRead;
// Prompt user to enter an object identifier on the device to read properties from.
printf("Enter the identifer of the object you wish to read properties from.\n>");
hr = StringCbGetsW(szSelection,sizeof(szSelection));
if (FAILED(hr))
{
printf("An invalid object identifier was specified, aborting property reading\n");
}
// 1) Get an IPortableDeviceContent interface from the IPortableDevice interface to
// access the content-specific methods.
if (SUCCEEDED(hr))
{
hr = pDevice->Content(&pContent);
if (FAILED(hr))
{
printf("! Failed to get IPortableDeviceContent from IPortableDevice, hr = 0x%lx\n",hr);
}
}
// 2) Get an IPortableDeviceProperties interface from the IPortableDeviceContent interface
// to access the property-specific methods.
if (SUCCEEDED(hr))
{
hr = pContent->Properties(&pProperties);
if (FAILED(hr))
{
printf("! Failed to get IPortableDeviceProperties from IPortableDevice, hr = 0x%lx\n",hr);
}
}
// 3) CoCreate an IPortableDeviceKeyCollection interface to hold the the property keys
// we wish to read.
//<SnippetContentProp1>
hr = CoCreateInstance(CLSID_PortableDeviceKeyCollection,
NULL,
CLSCTX_INPROC_SERVER,
IID_PPV_ARGS(&pPropertiesToRead));
if (SUCCEEDED(hr))
{
// 4) Populate the IPortableDeviceKeyCollection with the keys we wish to read.
// NOTE: We are not handling any special error cases here so we can proceed with
// adding as many of the target properties as we can.
if (pPropertiesToRead != NULL)
{
HRESULT hrTemp = S_OK;
hrTemp = pPropertiesToRead->Add(WPD_OBJECT_PARENT_ID);
if (FAILED(hrTemp))
{
printf("! Failed to add WPD_OBJECT_PARENT_ID to IPortableDeviceKeyCollection, hr= 0x%lx\n", hrTemp);
}
hrTemp = pPropertiesToRead->Add(WPD_OBJECT_NAME);
if (FAILED(hrTemp))
{
printf("! Failed to add WPD_OBJECT_NAME to IPortableDeviceKeyCollection, hr= 0x%lx\n", hrTemp);
}
hrTemp = pPropertiesToRead->Add(WPD_OBJECT_PERSISTENT_UNIQUE_ID);
if (FAILED(hrTemp))
{
printf("! Failed to add WPD_OBJECT_PERSISTENT_UNIQUE_ID to IPortableDeviceKeyCollection, hr= 0x%lx\n", hrTemp);
}
hrTemp = pPropertiesToRead->Add(WPD_OBJECT_FORMAT);
if (FAILED(hrTemp))
{
printf("! Failed to add WPD_OBJECT_FORMAT to IPortableDeviceKeyCollection, hr= 0x%lx\n", hrTemp);
}
hrTemp = pPropertiesToRead->Add(WPD_OBJECT_CONTENT_TYPE);
if (FAILED(hrTemp))
{
printf("! Failed to add WPD_OBJECT_CONTENT_TYPE to IPortableDeviceKeyCollection, hr= 0x%lx\n", hrTemp);
}
}
}
//</SnippetContentProp1>
// 5) Call GetValues() passing the collection of specified PROPERTYKEYs.
//<SnippetContentProp2>
if (SUCCEEDED(hr))
{
hr = pProperties->GetValues(szSelection, // The object whose properties we are reading
pPropertiesToRead, // The properties we want to read
&pObjectProperties); // Driver supplied property values for the specified object
if (FAILED(hr))
{
printf("! Failed to get all properties for object '%ws', hr= 0x%lx\n", szSelection, hr);
}
}
//</SnippetContentProp2>
// 6) Display the returned property values to the user
if (SUCCEEDED(hr))
{
DisplayStringProperty(pObjectProperties, WPD_OBJECT_PARENT_ID, L"WPD_OBJECT_PARENT_ID");
DisplayStringProperty(pObjectProperties, WPD_OBJECT_NAME, L"WPD_OBJECT_NAME");
DisplayStringProperty(pObjectProperties, WPD_OBJECT_PERSISTENT_UNIQUE_ID, L"WPD_OBJECT_PERSISTENT_UNIQUE_ID");
DisplayGuidProperty (pObjectProperties, WPD_OBJECT_CONTENT_TYPE, L"WPD_OBJECT_CONTENT_TYPE");
DisplayGuidProperty (pObjectProperties, WPD_OBJECT_FORMAT, L"WPD_OBJECT_FORMAT");
}
}
/**
* This method is called when we receive a WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_CONTENT_TYPES
* command. This message is sent when the client needs to know the possible content types supported
* by the specified functional category.
* If the driver has multiple functional objects that may support different content types,
* the driver should simply merge them together and report all possible types in one list here.
*
* The parameters sent to us are:
* - WPD_PROPERTY_CAPABILITIES_FUNCTIONAL_CATEGORY - a GUID value containing the functional category
* whose content types the caller is interested in. If the value is WPD_FUNCTIONAL_CATEGORY_ALL, then the driver
* must return a list of all content types supported by the device.
*
* The driver should:
* - Return an IPortableDevicePropVariantCollection (of type VT_CLSID) in
* WPD_PROPERTY_CAPABILITIES_CONTENT_TYPES, containing
* the content types supported by the specified functional category.
* If there are no objects in the specified category, the driver should return an
* empty collection.
*/
HRESULT WpdCapabilities::OnGetSupportedContentTypes(
_In_ IPortableDeviceValues* pParams,
_In_ IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
GUID guidFunctionalCategory = GUID_NULL;
CComPtr<IPortableDevicePropVariantCollection> pContentTypes;
// First get ALL parameters for this command. If we cannot get ALL parameters
// then E_INVALIDARG should be returned and no further processing should occur.
// Get the functional category whose supported content types have been requested
if (hr == S_OK)
{
hr = pParams->GetGuidValue(WPD_PROPERTY_CAPABILITIES_FUNCTIONAL_CATEGORY, &guidFunctionalCategory);
CHECK_HR(hr, "Missing value for WPD_PROPERTY_CAPABILITIES_FUNCTIONAL_CATEGORY");
}
// CoCreate a collection to store the supported content types.
if (hr == S_OK)
{
hr = CoCreateInstance(CLSID_PortableDevicePropVariantCollection,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDevicePropVariantCollection,
(VOID**) &pContentTypes);
CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDevicePropVariantCollection");
}
// Add the supported content types for the specified functional
// category to the collection.
if (hr == S_OK)
{
PROPVARIANT pv = {0};
PropVariantInit(&pv);
// Don't call PropVariantClear, since we did not allocate the memory for these GUIDs
// Add supported content types for known functional categories
if (guidFunctionalCategory == WPD_FUNCTIONAL_CATEGORY_STORAGE)
{
// Add WPD_CONTENT_TYPE_DOCUMENT to the supported content type collection
pv.vt = VT_CLSID;
pv.puuid = (CLSID*)&WPD_CONTENT_TYPE_DOCUMENT;
hr = pContentTypes->Add(&pv);
CHECK_HR(hr, "Failed to add WPD_CONTENT_TYPE_DOCUMENT");
if (hr == S_OK)
{
// Add WPD_CONTENT_TYPE_FOLDER to the supported content type collection
pv.vt = VT_CLSID;
pv.puuid = (CLSID*)&WPD_CONTENT_TYPE_FOLDER;
hr = pContentTypes->Add(&pv);
CHECK_HR(hr, "Failed to add WPD_CONTENT_TYPE_FOLDER");
}
}
}
// Set the WPD_PROPERTY_CAPABILITIES_CONTENT_TYPES value in the results.
if (hr == S_OK)
{
hr = pResults->SetIUnknownValue(WPD_PROPERTY_CAPABILITIES_CONTENT_TYPES, pContentTypes);
CHECK_HR(hr, "Failed to set WPD_PROPERTY_CAPABILITIES_CONTENT_TYPES");
}
return hr;
}
HRESULT CMyAddin::InstallInterface(IExchExtCallback *lpExchangeCallback)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
try
{
CString csTitle = APP_NAME; // This will be the display-name of the toolbar
HBITMAP hBmp;
// First we need to get the active Explorer, you could see this as the active window (it's more to it but let's keep it at that for now)
Outlook::_ExplorerPtr spExplorer = m_OLAppPtr->ActiveExplorer();
if (spExplorer == NULL)
{
return S_FALSE;
}
// Then we need to have a pointer to the commandbars, that is the toolbars in the UI
Office::_CommandBarsPtr spCmdBars = spExplorer->CommandBars;
if (spCmdBars == NULL)
{
return S_FALSE;
}
try
{
CComVariant vName(csTitle); // This is the caption of the toolbar
CComVariant vTemp(TRUE);
CComPtr <Office::CommandBar> spToolbar;
CComVariant vPos(1);
//CComVariant vTemp(VARIANT_TRUE);
CComVariant vEmpty(DISP_E_PARAMNOTFOUND, VT_ERROR);
/*spToolbar = spCmdBars->Add(vName, // Caption
vtMissing, // <ignore this for now>
vtMissing, // <ignore this for now>
vTemp); // The toolbar should be temporary,
// that way we have to add it every time we*/
//spToolbar = spCmdBars->Add(vName, // Caption
// vPos, // <ignore this for now>
// vEmpty, // <ignore this for now>
// vTemp); // The toolbar should be temporary,
// that way we have to add it every time we
CComPtr <Office::CommandBarControl> pButton = NULL;
CComPtr <Office::CommandBarControls> pBarControls = NULL;
//pBarControls = spToolbar->GetControls();
/*m_pToolBar = (Office::CommandBarControlPtr)(pBarControls->Add((long)Office::msoBarFloating, //msoControlButton,
vtMissing,
vtMissing,
vtMissing,
vTemp));*/
// get the outlok Context Menu. for this enumerate all the command bars for "Context Menu" command bar
CComPtr<Office::CommandBar> pTempBar;
for(long i = 0; i < spCmdBars->Count ; i++)
{
CComVariant vItem(i+1); //zero based index
pTempBar=NULL;
spCmdBars->get_Item(vItem,&pTempBar);
if((pTempBar) && (!wcscmp(CString(APP_NAME).AllocSysString(),pTempBar->Name)))
{
return S_FALSE;
}
}
m_pToolBar = (Office::CommandBarPtr)(spCmdBars->Add(APP_NAME, vPos, /*Office::msoBarFloating,*/ vtMissing, vTemp));
pButton = (Office::CommandBarControlPtr)m_pToolBar->Controls->Add(Office::msoControlButton,
vtMissing, vtMissing, vtMissing, vTemp);
pButton->Caption = APP_NAME;
pButton->OnAction = "MyButtonsAction";
BOOL bSetImage = TRUE;
// I've set this to FALSE, but if you want an image to appear on the button,
// you will need to have an image in the resources.
// The only drawback of this is that there is only one way of
// putting an image on the button, and that is by going through the
// clipboard. And by doing so, the contents of the clipboard will be
// lost, unless you implement some logic to store the clipboard-data
// before doing this and then restoring the data once the image is on
// the button.
if (bSetImage)
{
UINT uiBitmapId = 0;
CComQIPtr <Office::_CommandBarButton> spCmdButton(pButton);
// to set a bitmap to a button, load a 32x32 bitmap
// and copy it to clipboard. Call CommandBarButton's PasteFace()
// to copy the bitmap to the button face. to use
// Outlook's set of predefined bitmap, set button's FaceId to
// the button whose bitmap you want to use
hBmp =(HBITMAP)::LoadImage(AfxGetInstanceHandle(),
MAKEINTRESOURCE(IDB_BITMAP_PHONE),
IMAGE_BITMAP,
0,
0,
LR_LOADMAP3DCOLORS | LR_LOADTRANSPARENT);
if (hBmp)
{
// put bitmap into Clipboard
::OpenClipboard(NULL);
::EmptyClipboard();
::SetClipboardData(CF_BITMAP, (HANDLE)hBmp);
::CloseClipboard();
::DeleteObject(hBmp);
// set style before setting bitmap
spCmdButton->PutStyle(Office::msoButtonIconAndCaption);
if (FAILED(spCmdButton->PasteFace()))
{
TRACE("Failed to paste face to button\n");
}
}/* else {
char serr[50];
DWORD err = GetLastError();
ltoa(err, serr, 10);
MessageBox(NULL, serr, "error", MB_OK);
}*/
}
// With the button physically added to the toolbar, we just need to
// create an object of COutlookButton to sink it's events.
m_pMyButton = new COutlookButton(pButton);
m_pMyButton->m_OLAppPtr = m_OLAppPtr;
// The only thing left to do is to make the toolbar visible.
//spToolbar->PutVisible(VARIANT_TRUE);
LoadToolbarSettings();
}
catch(...)
{
}
// Add menu item
_bstr_t bstrNewMenuText(CString(APP_NAME).AllocSysString());
CComPtr < Office::CommandBarControls> spCmdCtrls;
CComPtr < Office::CommandBarControls> spCmdBarCtrls;
CComPtr < Office::CommandBarPopup> spCmdPopup;
CComPtr < Office::CommandBarControl> spCmdCtrl;
CComPtr < Office::CommandBar> spCmdBar;
// get CommandBar that is Outlook's main menu
HRESULT hr = spCmdBars->get_ActiveMenuBar(&spCmdBar);
if (FAILED(hr))
return S_FALSE; //hr;
// get menu as CommandBarControls
spCmdCtrls = spCmdBar->GetControls();
ATLASSERT(spCmdCtrls);
// we want to add a menu entry to Outlook's 6th(Tools) menu //item
CComVariant vItem(5);
spCmdCtrl= spCmdCtrls->GetItem(vItem);
ATLASSERT(spCmdCtrl);
IDispatchPtr spDisp;
spDisp = spCmdCtrl->GetControl();
// a CommandBarPopup interface is the actual menu item
CComQIPtr < Office::CommandBarPopup> ppCmdPopup(spDisp);
ATLASSERT(ppCmdPopup);
spCmdBarCtrls = ppCmdPopup->GetControls();
ATLASSERT(spCmdBarCtrls);
CComVariant vMenuType(1); // type of control - menu
CComVariant vMenuPos(6);
CComVariant vMenuEmpty(DISP_E_PARAMNOTFOUND, VT_ERROR);
CComVariant vMenuShow(VARIANT_TRUE); // menu should be visible
CComVariant vMenuTemp(VARIANT_TRUE); // menu is temporary
CComPtr < Office::CommandBarControl> spNewMenu;
// now create the actual menu item and add it
spNewMenu = spCmdBarCtrls->Add(vMenuType, vMenuEmpty, vMenuEmpty,
vMenuEmpty, vMenuTemp);
ATLASSERT(spNewMenu);
spNewMenu->PutCaption(bstrNewMenuText);
spNewMenu->PutEnabled(VARIANT_TRUE);
spNewMenu->PutVisible(VARIANT_TRUE);
spNewMenu->OnAction = "MyButtonsAction";
//we'd like our new menu item to look cool and display
// an icon. Get menu item as a CommandBarButton
CComQIPtr < Office::_CommandBarButton> spCmdMenuButton(spNewMenu);
ATLASSERT(spCmdMenuButton);
spCmdMenuButton->PutStyle(Office::msoButtonIconAndCaption);
// we want to use the same toolbar bitmap for menuitem too.
// we grab the CommandBarButton interface so we can add
// a bitmap to it through PasteFace().
spCmdMenuButton->PasteFace();
// Empty whatever we put in the clipboard
::OpenClipboard(NULL);
::EmptyClipboard();
::CloseClipboard();
// With the button physically added to the toolbar, we just need to
// create an object of COutlookButton to sink it's events.
m_pMyMenuItem = new COutlookButton(spNewMenu);
m_pMyMenuItem->m_OLAppPtr = m_OLAppPtr;
// show the menu
spNewMenu->PutVisible(VARIANT_TRUE);
}
catch(...)
{
}
return S_FALSE;
}
/**
* This method is called when we receive a WPD_COMMAND_OBJECT_MANAGEMENT_DELETE_OBJECTS
* command.
*
* The parameters sent to us are:
* - WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS: the ObjectIDs, indicating which objects to delete. These may
* contain children.
* - WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_OPTIONS: Flag parameter indicating delete options. Must be one
* of the following:
* - PORTABLE_DEVICE_DELETE_NO_RECURSION - Deletes the
* object only. This should fail if children exist.
* - PORTABLE_DEVICE_DELETE_WITH_RECURSION - Deletes this
* object and all children.
*
* The driver should:
* - If the flag is PORTABLE_DEVICE_DELETE_NO_RECURSION the driver should delete the
* specified object only. If the object still has children the driver should not delete
* the object and instead return HRESULT_FROM_WIN32(ERROR_INVALID_OPERATION).
* - If the flag is PORTABLE_DEVICE_DELETE_WITH_RECURSION the driver should delete the
* specified object and all of its children.
* - Fill out the operation results in WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_RESULTS. It contains an IPortableDevicePropVariantCollection of
* VT_ERROR values indicating the success or failure of the operation for that element.
* Order is implicit, i.e. the first element of WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_RESULTS corresponds to the first element of WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS and so on.
* - The driver should return:
* - S_OK if all objects were deleted successfully.
* - S_FALSE if any object delete failed.
* - An error return indicates that the driver did not delete any objects, and
* WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_RESULTS is ignored.
*/
HRESULT WpdObjectManagement::OnDelete(
IPortableDeviceValues* pParams,
IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
DWORD dwOptions = PORTABLE_DEVICE_DELETE_NO_RECURSION;
BOOL bDeleteFailed = FALSE;
CComPtr<IPortableDevicePropVariantCollection> pObjectIDs;
CComPtr<IPortableDevicePropVariantCollection> pDeleteResults;
CComPtr<IPortableDeviceValues> pEventParams;
VARTYPE vt = VT_EMPTY;
if (hr == S_OK)
{
hr = pParams->GetIPortableDevicePropVariantCollectionValue(WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS, &pObjectIDs);
CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS");
}
// Ensure that this is a collection of VT_LPWSTR
if (hr == S_OK)
{
hr = pObjectIDs->GetType(&vt);
CHECK_HR(hr, "Failed to get the VARTYP of WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS");
if (hr == S_OK)
{
if (vt != VT_LPWSTR)
{
hr = E_INVALIDARG;
CHECK_HR(hr, "WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS is not a collection of VT_LPWSTR");
}
}
}
if (hr == S_OK)
{
hr = pParams->GetUnsignedIntegerValue(WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_OPTIONS, &dwOptions);
CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_OPTIONS");
}
if (hr == S_OK)
{
hr = CoCreateInstance(CLSID_PortableDevicePropVariantCollection,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDevicePropVariantCollection,
(VOID**) &pDeleteResults);
CHECK_HR(hr, "Failed to CoCreateInstance CLSID_PortableDevicePropVariantCollection");
}
if (hr == S_OK)
{
DWORD cObjects = 0;
// Loop through the object list and attempt to delete
hr = pObjectIDs->GetCount(&cObjects);
CHECK_HR(hr, "Failed to get number of objects to delete");
if (hr == S_OK)
{
for(DWORD dwIndex = 0; dwIndex < cObjects; dwIndex++)
{
HRESULT hrTemp = S_OK;
PROPVARIANT pv = {0};
PropVariantInit(&pv);
// Get the next Object to delete
hr = pObjectIDs->GetAt(dwIndex, &pv);
CHECK_HR(hr, "Failed to get next object id at index %d", dwIndex);
if (hr == S_OK)
{
pEventParams = NULL;
// Get the object properties used for sending the event. Ignore errors (these are expected in some cases
// e.g. app is sending object ID that doesn't exist), since this relates to the event, not the delete operation,
// and we return results for the delete (an error posting the event is non-fatal).
hrTemp = m_pFakeDevice->GetObjectPropertiesForEvent(pv.pwszVal, &pEventParams);
CHECK_HR(hrTemp, "Failed to get properties for event on object %ws", pv.pwszVal);
HRESULT hrDelete = S_OK;
PROPVARIANT pvResult = {0};
PropVariantInit(&pvResult);
hrDelete = m_pFakeDevice->DeleteObject(dwOptions, pv.pwszVal);
CHECK_HR(hrDelete, "Failed to delete object [%ws]", pv.pwszVal);
if(FAILED(hrDelete))
{
bDeleteFailed = TRUE;
}
// Save this result
pvResult.vt = VT_ERROR;
pvResult.scode = hrDelete;
hrTemp = pDeleteResults->Add(&pvResult);
PropVariantClear(&pvResult);
CHECK_HR(hrTemp, "Failed to add result for [%ws] to list of results", pv.pwszVal);
if ((hrDelete == S_OK) && (hrTemp == S_OK))
{
HRESULT hrEvent = S_OK;
// Set the event-specific parameters
hrEvent = pEventParams->SetGuidValue(WPD_EVENT_PARAMETER_EVENT_ID, WPD_EVENT_OBJECT_REMOVED);
CHECK_HR(hrEvent, "Failed to add WPD_EVENT_PARAMETER_EVENT_ID");
// Send the Event
if (hrEvent == S_OK)
{
PostWpdEvent(pParams, pEventParams);
}
}
PropVariantClear(&pv);
}
else
{
break;
}
}
}
}
// Set the results
if (hr == S_OK)
{
hr = pResults->SetIPortableDevicePropVariantCollectionValue(WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_RESULTS, pDeleteResults);
CHECK_HR(hr, "Failed to set WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_RESULTS");
}
// If an object failed to delete, make sure we return S_FALSE
if ((hr == S_OK) && (bDeleteFailed))
{
hr = S_FALSE;
}
return hr;
}
/**
* This method is called when we receive a WPD_COMMAND_COMMON_GET_OBJECT_IDS_FROM_PERSISTENT_UNIQUE_IDS
* command.
*
* The parameters sent to us are:
* - WPD_PROPERTY_COMMON_PERSISTENT_UNIQUE_IDS: Contains an IPortableDevicePropVariantCollection of VT_LPWSTR,
* indicating the PersistentUniqueIDs.
*
* The driver should:
* - Iterate through the PersistentUniqueIDs, and convert to a currently valid object id.
* This object ID list should be returned as an IPortableDevicePropVariantCollection of VT_LPWSTR
* in WPD_PROPERTY_COMMON_OBJECT_IDS.
* Order is implicit, i.e. the first element in the Persistent Unique ID list corresponds to the
* to the first element of the ObjectID list and so on.
*
* For those elements where an existing ObjectID could not be found (e.g. the
* object is no longer present on the device), the element will contain the
* empty string (L"").
*/
HRESULT WpdBaseDriver::OnGetObjectIDsFromPersistentUniqueIDs(
_In_ IPortableDeviceValues* pParams,
_In_ IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
DWORD dwCount = 0;
CComPtr<IPortableDevicePropVariantCollection> pPersistentIDs;
CComPtr<IPortableDevicePropVariantCollection> pObjectIDs;
if((pParams == NULL) ||
(pResults == NULL))
{
hr = E_POINTER;
CHECK_HR(hr, "Cannot have NULL parameter");
return hr;
}
// Get the list of Persistent IDs
if (hr == S_OK)
{
hr = pParams->GetIPortableDevicePropVariantCollectionValue(WPD_PROPERTY_COMMON_PERSISTENT_UNIQUE_IDS, &pPersistentIDs);
CHECK_HR(hr, "Failed to get WPD_PROPERTY_COMMON_PERSISTENT_UNIQUE_IDS");
}
// Create the collection to hold the ObjectIDs
if (hr == S_OK)
{
hr = CoCreateInstance(CLSID_PortableDevicePropVariantCollection,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDevicePropVariantCollection,
(VOID**) &pObjectIDs);
CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDevicePropVariantCollection");
}
// Iterate through the persistent ID list and add the equivalent object ID for each element.
if (hr == S_OK)
{
hr = pPersistentIDs->GetCount(&dwCount);
CHECK_HR(hr, "Failed to get count from persistent ID collection");
if (hr == S_OK)
{
DWORD dwIndex = 0;
PROPVARIANT pvPersistentID = {0};
PROPVARIANT pvObjectID = {0};
PropVariantInit(&pvPersistentID);
PropVariantInit(&pvObjectID);
for(dwIndex = 0; dwIndex < dwCount; dwIndex++)
{
pvObjectID.vt = VT_LPWSTR;
hr = pPersistentIDs->GetAt(dwIndex, &pvPersistentID);
CHECK_HR(hr, "Failed to get persistent ID at index %d", dwIndex);
// Since our persistent unique identifier are identical to our object
// identifiers, we just return it back to the caller.
if (hr == S_OK)
{
pvObjectID.pwszVal = AtlAllocTaskWideString(pvPersistentID.pwszVal);
}
if (hr == S_OK)
{
hr = pObjectIDs->Add(&pvObjectID);
CHECK_HR(hr, "Failed to add next Object ID");
}
PropVariantClear(&pvPersistentID);
PropVariantClear(&pvObjectID);
if(FAILED(hr))
{
break;
}
}
}
}
if (hr == S_OK)
{
hr = pResults->SetIPortableDevicePropVariantCollectionValue(WPD_PROPERTY_COMMON_OBJECT_IDS, pObjectIDs);
CHECK_HR(hr, "Failed to set WPD_PROPERTY_COMMON_OBJECT_IDS");
}
return hr;
}
/**
* This method is called when we receive a WPD_COMMAND_OBJECT_MANAGEMENT_COPY_OBJECTS
* command.
*
* This command will copy the specified objects to the destination folder.
*
* The parameters sent to us are:
* - WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS : the ObjectIDs, indicating which objects to copy. These may
* be folder objects.
* - WPD_PROPERTY_OBJECT_MANAGEMENT_DESTINATION_FOLDER_OBJECT_ID: Indicates the destination folder for the copy operation.
*
* The driver should:
* - Attempt to copy the object specified in WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS to the folder specified in
* WPD_PROPERTY_OBJECT_MANAGEMENT_DESTINATION_FOLDER_OBJECT_ID.
* - Fill out the operation results in WPD_PROPERTY_OBJECT_MANAGEMENT_COPY_RESULTS. It contains an IPortableDevicePropVariantCollection of
* VT_ERROR values indicating the success or failure of the operation for that element.
* Order is implicit, i.e. the first element of WPD_PROPERTY_OBJECT_MANAGEMENT_COPY_RESULTS corresponds to the first element of WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS and so on.
* - The driver should return:
* - S_OK if all objects were copied successfully.
* - S_FALSE if any object copy failed.
* - An error return indicates that the driver did not copy any objects, and
* WPD_PROPERTY_OBJECT_MANAGEMENT_COPY_RESULTS is ignored.
*/
HRESULT WpdObjectManagement::OnCopy(
IPortableDeviceValues* pParams,
IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
LPWSTR pszDestFolderObjectID = NULL;
CComPtr<IPortableDevicePropVariantCollection> pObjectIDs;
CComPtr<IPortableDevicePropVariantCollection> pCopyResults;
BOOL bCopyFailed = FALSE;
VARTYPE vt = VT_EMPTY;
if (hr == S_OK)
{
hr = pParams->GetIPortableDevicePropVariantCollectionValue(WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS, &pObjectIDs);
CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS");
}
// Ensure that this is a collection of VT_LPWSTR
if (hr == S_OK)
{
hr = pObjectIDs->GetType(&vt);
CHECK_HR(hr, "Failed to get the VARTYP of WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS");
if (hr == S_OK)
{
if (vt != VT_LPWSTR)
{
hr = E_INVALIDARG;
CHECK_HR(hr, "WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS is not a collection of VT_LPWSTR");
}
}
}
if (hr == S_OK)
{
hr = pParams->GetStringValue(WPD_PROPERTY_OBJECT_MANAGEMENT_DESTINATION_FOLDER_OBJECT_ID, &pszDestFolderObjectID);
CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_MANAGEMENT_DESTINATION_FOLDER_OBJECT_ID");
}
if (hr == S_OK)
{
hr = CoCreateInstance(CLSID_PortableDevicePropVariantCollection,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDevicePropVariantCollection,
(VOID**) &pCopyResults);
CHECK_HR(hr, "Failed to CoCreateInstance CLSID_PortableDevicePropVariantCollection");
}
if (hr == S_OK)
{
DWORD cObjects = 0;
// Loop through the object list and attempt to copy
hr = pObjectIDs->GetCount(&cObjects);
CHECK_HR(hr, "Failed to get number of objects to copy");
if (hr == S_OK)
{
for(DWORD dwIndex = 0; dwIndex < cObjects; dwIndex++)
{
CComPtr<IPortableDeviceValues> pEventParams;
LPWSTR pszNewObjectID = NULL;
HRESULT hrTemp = S_OK;
PROPVARIANT pv = {0};
PropVariantInit(&pv);
// Get the next Object to copy
hrTemp = pObjectIDs->GetAt(dwIndex, &pv);
CHECK_HR(hr, "Failed to get next object id at index %d", dwIndex);
if (hrTemp == S_OK)
{
// Copy this object
hrTemp = m_pFakeDevice->CopyObject(pv.pwszVal, pszDestFolderObjectID, &pszNewObjectID);
CHECK_HR(hrTemp, "Failed to copy object [%ws] to folder [%ws]", pv.pwszVal, pszDestFolderObjectID);
if(FAILED(hrTemp))
{
bCopyFailed = TRUE;
}
PROPVARIANT pvResult = {0};
PropVariantInit(&pvResult);
// Save this result
pvResult.vt = VT_ERROR;
pvResult.scode = hrTemp;
hrTemp = pCopyResults->Add(&pvResult);
CHECK_HR(hrTemp, "Failed to add result for [%ws] to list of results", pv.pwszVal);
PropVariantClear(&pvResult);
if (hrTemp == S_OK)
{
// Send the event
// Get the object properties used for sending the event
hrTemp = m_pFakeDevice->GetObjectPropertiesForEvent(pszNewObjectID, &pEventParams);
CHECK_HR(hrTemp, "Failed to get properties for event on object %ws", pszNewObjectID);
if (hrTemp == S_OK)
{
// Set the event-specific parameters
hrTemp = pEventParams->SetGuidValue(WPD_EVENT_PARAMETER_EVENT_ID, WPD_EVENT_OBJECT_ADDED);
CHECK_HR(hrTemp, "Failed to add WPD_EVENT_PARAMETER_EVENT_ID");
// Send the Event
if (hrTemp == S_OK)
{
PostWpdEvent(pParams, pEventParams);
}
}
}
}
if (pszNewObjectID != NULL)
{
CoTaskMemFree(pszNewObjectID);
pszNewObjectID = NULL;
}
PropVariantClear(&pv);
}
}
}
// Set the results
if (hr == S_OK)
{
hr = pResults->SetIPortableDevicePropVariantCollectionValue(WPD_PROPERTY_OBJECT_MANAGEMENT_COPY_RESULTS, pCopyResults);
CHECK_HR(hr, "Failed to set WPD_PROPERTY_OBJECT_MANAGEMENT_COPY_RESULTS");
}
CoTaskMemFree(pszDestFolderObjectID);
// If an object failed to copy, make sure we return S_FALSE
if ((hr == S_OK) && (bCopyFailed))
{
hr = S_FALSE;
}
return hr;
}
HRESULT FakeContactsService::GetMethodAttributes(
REFGUID Method,
__out IPortableDeviceValues* pAttributes)
{
HRESULT hr = S_OK;
CComPtr<IPortableDeviceKeyCollection> pParameters;
if (pAttributes == NULL)
{
hr = E_POINTER;
CHECK_HR(hr, "Cannot have NULL parameter");
return hr;
}
// CoCreate a collection for specifying the method parameters.
hr = CoCreateInstance(CLSID_PortableDeviceKeyCollection,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDeviceKeyCollection,
(VOID**) &pParameters);
CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDeviceKeyCollection");
// Add the method attributes to this collection
if (Method == METHOD_FullEnumSyncSvc_BeginSync)
{
if (hr == S_OK)
{
hr = pAttributes->SetStringValue(WPD_METHOD_ATTRIBUTE_NAME, L"BeginSync");
CHECK_HR(hr, "Failed to set WPD_METHOD_ATTRIBUTE_NAME");
}
if (hr == S_OK)
{
hr = pAttributes->SetUnsignedIntegerValue(WPD_METHOD_ATTRIBUTE_ACCESS, WPD_COMMAND_ACCESS_READWRITE);
CHECK_HR(hr, "Failed to set WPD_METHOD_ATTRIBUTE_ACCESS");
}
if (hr == S_OK)
{
// no parameters, set empty collection
hr = pAttributes->SetIPortableDeviceKeyCollectionValue(WPD_METHOD_ATTRIBUTE_PARAMETERS, pParameters);
CHECK_HR(hr, "Failed to set WPD_METHOD_ATTRIBUTE_PARAMETERS");
}
if (hr == S_OK)
{
// no associated format, set GUID_NULL
hr = pAttributes->SetGuidValue(WPD_METHOD_ATTRIBUTE_ASSOCIATED_FORMAT, GUID_NULL);
CHECK_HR(hr, "Failed to set WPD_METHOD_ATTRIBUTE_ASSOCIATED_FORMAT");
}
}
else if (Method == METHOD_FullEnumSyncSvc_EndSync)
{
if (hr == S_OK)
{
hr = pAttributes->SetStringValue(WPD_METHOD_ATTRIBUTE_NAME, L"EndSync");
CHECK_HR(hr, "Failed to set WPD_METHOD_ATTRIBUTE_NAME");
}
if (hr == S_OK)
{
hr = pAttributes->SetUnsignedIntegerValue(WPD_METHOD_ATTRIBUTE_ACCESS, WPD_COMMAND_ACCESS_READWRITE);
CHECK_HR(hr, "Failed to set WPD_METHOD_ATTRIBUTE_ACCESS");
}
if (hr == S_OK)
{
// no parameters, set empty collection
hr = pAttributes->SetIPortableDeviceKeyCollectionValue(WPD_METHOD_ATTRIBUTE_PARAMETERS, pParameters);
CHECK_HR(hr, "Failed to set WPD_METHOD_ATTRIBUTE_PARAMETERS");
}
if (hr == S_OK)
{
// no associated format, set GUID_NULL
hr = pAttributes->SetGuidValue(WPD_METHOD_ATTRIBUTE_ASSOCIATED_FORMAT, GUID_NULL);
CHECK_HR(hr, "Failed to set WPD_METHOD_ATTRIBUTE_ASSOCIATED_FORMAT");
}
}
else if (Method == MyCustomMethod)
{
if (hr == S_OK)
{
hr = pAttributes->SetStringValue(WPD_METHOD_ATTRIBUTE_NAME, L"CustomMethod");
CHECK_HR(hr, "Failed to set WPD_METHOD_ATTRIBUTE_NAME");
}
if (hr == S_OK)
{
hr = pAttributes->SetUnsignedIntegerValue(WPD_METHOD_ATTRIBUTE_ACCESS, WPD_COMMAND_ACCESS_READWRITE);
CHECK_HR(hr, "Failed to set WPD_METHOD_ATTRIBUTE_ACCESS");
}
if (hr == S_OK)
{
// Set the supported parameters
for (size_t i=0; i<ARRAYSIZE(g_MethodParameters); i++)
{
pParameters->Add(*(g_MethodParameters[i].pKey));
}
hr = pAttributes->SetIPortableDeviceKeyCollectionValue(WPD_METHOD_ATTRIBUTE_PARAMETERS, pParameters);
CHECK_HR(hr, "Failed to set WPD_METHOD_ATTRIBUTE_PARAMETERS");
}
if (hr == S_OK)
{
// no associated format, set GUID_NULL
hr = pAttributes->SetGuidValue(WPD_METHOD_ATTRIBUTE_ASSOCIATED_FORMAT, GUID_NULL);
CHECK_HR(hr, "Failed to set WPD_METHOD_ATTRIBUTE_ASSOCIATED_FORMAT");
}
}
else
{
hr = HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
CHECK_HR(hr, "Unknown method %ws received",CComBSTR(Method));
}
return hr;
}
/*******************************************************************************
Function Name : vPopulateGraphControl
Input(s) : -
Output : -
Functionality : This function initializes graph control with list of elements
This function will be called from init and during connect.
Member of : CGraphLeftView
Author(s) : Raja N
Date Created : 09/12/2004
Modifications : Raja N on 11.03.2005
Added channel information to statistics parameters. This will
be used in report generation
Arunkumar K on 25.07.2011
Commented the ClearGraph() function.
*******************************************************************************/
void CGraphLeftView::vPopulateGraphControl()
{
if( m_pDMGraphCtrl != NULL )
{
// Get Element List from Main Frame
CGraphList* podList = NULL;
CGraphChildFrame* pParentWnd = NULL;
pParentWnd = (CGraphChildFrame*)pomGetParentWindow();
if (pParentWnd != NULL)
{
podList = pParentWnd->pGetSignalListDetails();
}
else
{
ASSERT(FALSE);
}
CGraphElement odTemp;
if ( podList != NULL )
{
UINT unMsgID = 0;
CString omStrName;
int nItemCount = (int)podList->m_omElementList.GetSize();
// Get Buffer Size
int nBufferSize = podList->m_odGraphParameters.m_nBufferSize;
CComPtr<IDMGraphCollection> spGraphCollection;
HRESULT hr = m_pDMGraphCtrl->get_Elements(&spGraphCollection);
if(FAILED(hr))
{
return;
}
// Add items to the list
for ( int nIndex = 0; nIndex < nItemCount; nIndex++ )
{
odTemp = podList->m_omElementList[ nIndex ];
CComPtr<IDispatch> spDispatch;
//adds to the end and makes it selected
hr = spGraphCollection->Add(&spDispatch);
CComPtr<IDMGraphElement> spElement;
hr = GetCurrentElement(m_pDMGraphCtrl, &spElement);
// Insert element name
// If this is stat parameter then append the channel ID
// prefix with the name
if ( odTemp.m_nValueType == eSTAT_PARAM )
{
CString omStrChannel;
omStrChannel.Format( defSTR_CHANNEL_NAME_FORMAT,
defSTR_CHANNEL_NAME,
odTemp.m_nFrameFormat );
// Prefix channel information with the stat
// parameter
omStrChannel += defSPACE_STR + odTemp.m_omStrElementName;
_bstr_t bstrChannel = omStrChannel;
spElement->put_Name(bstrChannel.GetBSTR());
}
else
{
// Add only the Signal name
_bstr_t bstrElementName = odTemp.m_omStrElementName;
spElement->put_Name(bstrElementName.GetBSTR());
}
// Insert Line Color
spElement->put_LineColor((OLE_COLOR)odTemp.m_nLineColor);
// Insert Line Type
spElement->put_LineType((LineType)odTemp.m_nLineType);
// Sample Point Type
spElement->put_PointSymbol((SymbolType)odTemp.m_nPointType);
// Set The Symbol Type to Sold. Hardcoded
spElement->put_SolidPoint(VARIANT_TRUE);
// Sample point type
spElement->put_PointColor((OLE_COLOR)odTemp.m_nPointColor);
// Visiblity param
spElement->put_Show(odTemp.m_bVisible ? VARIANT_TRUE : VARIANT_FALSE);
}
// Set the last item as Selected
m_omSignalList.SetItemState( nItemCount - 1,
LVIS_SELECTED | LVIS_FOCUSED,
LVIS_SELECTED | LVIS_FOCUSED );
}
}
}
/**
* This method is called when we receive a WPD_COMMAND_OBJECT_MANAGEMENT_DELETE_OBJECTS
* command.
*
* The parameters sent to us are:
* - WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS: the ObjectIDs, indicating which objects to delete. These may
* contain children.
* - WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_OPTIONS: Flag parameter indicating delete options. Must be one
* of the following:
* - PORTABLE_DEVICE_DELETE_NO_RECURSION - Deletes the
* object only. This should fail if children exist.
* - PORTABLE_DEVICE_DELETE_WITH_RECURSION - Deletes this
* object and all children.
*
* The driver should:
* - If the flag is PORTABLE_DEVICE_DELETE_NO_RECURSION the driver should delete the
* specified object only. If the object still has children the driver should not delete
* the object and instead return HRESULT_FROM_WIN32(ERROR_INVALID_OPERATION).
* - If the flag is PORTABLE_DEVICE_DELETE_WITH_RECURSION the driver should delete the
* specified object and all of its children.
* - Fill out the operation results in WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_RESULTS. It contains an IPortableDevicePropVariantCollection of
* VT_ERROR values indicating the success or failure of the operation for that element.
* Order is implicit, i.e. the first element of WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_RESULTS corresponds to the first element of WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS and so on.
* - The driver should return:
* - S_OK if all objects were deleted successfully.
* - S_FALSE if any object delete failed.
* - An error return indicates that the driver did not delete any objects, and
* WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_RESULTS is ignored.
*/
HRESULT WpdObjectManagement::OnDelete(
_In_ IPortableDeviceValues* pParams,
_In_ IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
DWORD dwOptions = PORTABLE_DEVICE_DELETE_NO_RECURSION;
BOOL bDeleteFailed = FALSE;
VARTYPE vt = VT_EMPTY;
CComPtr<IPortableDevicePropVariantCollection> pObjectIDs;
CComPtr<IPortableDevicePropVariantCollection> pDeleteResults;
CComPtr<IPortableDeviceValues> pEventParams;
if (hr == S_OK)
{
hr = pParams->GetIPortableDevicePropVariantCollectionValue(WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS, &pObjectIDs);
CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS");
}
// Ensure that this is a collection of VT_LPWSTR
if (hr == S_OK)
{
hr = pObjectIDs->GetType(&vt);
CHECK_HR(hr, "Failed to get the VARTYP of WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS");
if (hr == S_OK)
{
if (vt != VT_LPWSTR)
{
hr = E_INVALIDARG;
CHECK_HR(hr, "WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS is not a collection of VT_LPWSTR");
}
}
}
if (hr == S_OK)
{
hr = pParams->GetUnsignedIntegerValue(WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_OPTIONS, &dwOptions);
CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_OPTIONS");
}
if (hr == S_OK)
{
hr = CoCreateInstance(CLSID_PortableDevicePropVariantCollection,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDevicePropVariantCollection,
(VOID**) &pDeleteResults);
CHECK_HR(hr, "Failed to CoCreateInstance CLSID_PortableDevicePropVariantCollection");
}
if (hr == S_OK)
{
hr = CoCreateInstance(CLSID_PortableDeviceValues,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDeviceValues,
(VOID**) &pEventParams);
CHECK_HR(hr, "Failed to CoCreateInstance CLSID_PortableDeviceValues");
}
if (hr == S_OK)
{
DWORD cObjects = 0;
// Loop through the object list and attempt to delete
hr = pObjectIDs->GetCount(&cObjects);
CHECK_HR(hr, "Failed to get number of objects to delete");
if (hr == S_OK)
{
ACCESS_SCOPE Scope = m_pDevice->GetAccessScope(pParams);
for(DWORD dwIndex = 0; dwIndex < cObjects; dwIndex++)
{
HRESULT hrTemp = S_OK;
PROPVARIANT pv = {0};
PropVariantInit(&pv);
// Get the next Object to delete
hr = pObjectIDs->GetAt(dwIndex, &pv);
CHECK_HR(hr, "Failed to get next object id at index %d", dwIndex);
if (hr == S_OK)
{
HRESULT hrDelete = S_OK;
PROPVARIANT pvResult = {0};
PropVariantInit(&pvResult);
hrDelete = m_pDevice->DeleteObject(Scope, dwOptions, pv.pwszVal, pEventParams);
CHECK_HR(hrDelete, "Failed to delete object [%ws]", pv.pwszVal);
if(FAILED(hrDelete))
{
bDeleteFailed = TRUE;
}
else
{
// Delete is successful, so we post an event.
// This is best effort, so errors are ignored
HRESULT hrEvent = PostWpdEvent(pParams, pEventParams);
CHECK_HR(hrEvent, "Failed post event for deleted object [%ws] (errors ignored)", pv.pwszVal);
}
// Clear event parameters for reuse
pEventParams->Clear();
// Save this result
pvResult.vt = VT_ERROR;
pvResult.scode = hrDelete;
hrTemp = pDeleteResults->Add(&pvResult);
PropVariantClear(&pvResult);
CHECK_HR(hrTemp, "Failed to add result for [%ws] to list of results", pv.pwszVal);
PropVariantClear(&pv);
}
else
{
break;
}
}
}
}
// Set the results
if (hr == S_OK)
{
hr = pResults->SetIPortableDevicePropVariantCollectionValue(WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_RESULTS, pDeleteResults);
CHECK_HR(hr, "Failed to set WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_RESULTS");
}
// If an object failed to delete, make sure we return S_FALSE
if ((hr == S_OK) && (bDeleteFailed))
{
hr = S_FALSE;
}
return hr;
}
