STDMETHODIMP CShellPropSheetExt::AddPages(LPFNADDPROPSHEETPAGE pfnAddPage, LPARAM lParam) { PROPSHEETPAGE psp; HPROPSHEETPAGE hPage; size_t pos = filepath.find_last_of('.'); if(pos == std::wstring::npos || _tcsicmp(filepath.substr(pos + 1).c_str(), TEXT("zip"))) return S_OK; psp.dwSize = sizeof(PROPSHEETPAGE); psp.dwFlags = PSP_USEREFPARENT | PSP_USETITLE | PSP_USECALLBACK; psp.hInstance = hDllInstance; psp.pszTemplate = MAKEINTRESOURCE(IDD_PROPSHEET1); psp.hIcon = 0; psp.pszTitle = TEXT("CubeICE"); psp.pfnDlgProc = (DLGPROC)DialogProc; psp.lParam = (LPARAM)this; psp.pfnCallback = PropSheetPageProc; psp.pcRefParent = (PUINT)&dllRefCount; hPage = CreatePropertySheetPage(&psp); if (hPage == NULL) return E_OUTOFMEMORY; if (!pfnAddPage(hPage, lParam)) { DestroyPropertySheetPage(hPage); return E_FAIL; } AddRef(); return S_OK; }
BOOL APIENTRY PropSheetExtProc(PSP_PROPSHEETPAGE_REQUEST PropPageRequest, LPFNADDPROPSHEETPAGE fAddFunc, LPARAM lParam) { PROPSHEETPAGE PropSheetPage; HPROPSHEETPAGE hPropSheetPage; if(PropPageRequest->PageRequested != SPPSR_ENUM_ADV_DEVICE_PROPERTIES) return FALSE; if ((!PropPageRequest->DeviceInfoSet) || (!PropPageRequest->DeviceInfoData)) return FALSE; ZeroMemory(&PropSheetPage, sizeof(PROPSHEETPAGE)); PropSheetPage.dwSize = sizeof(PROPSHEETPAGE); PropSheetPage.hInstance = g_hInstance; PropSheetPage.pszTemplate = MAKEINTRESOURCE(DLG_PROCESSORINFO); PropSheetPage.pfnDlgProc = ProcessorDlgProc; hPropSheetPage = CreatePropertySheetPage(&PropSheetPage); if(!hPropSheetPage) return FALSE; if(!(fAddFunc)(hPropSheetPage, lParam)) { DestroyPropertySheetPage (hPropSheetPage); return FALSE; } return TRUE; }
static HMODULE AddNetIdPage(PROPSHEETHEADER *ppsh) { HPROPSHEETPAGE hPage; HMODULE hMod; PCreateNetIDPropertyPage pCreateNetIdPage; hMod = LoadLibrary(TEXT("netid.dll")); if (hMod != NULL) { pCreateNetIdPage = (PCreateNetIDPropertyPage)GetProcAddress(hMod, "CreateNetIDPropertyPage"); if (pCreateNetIdPage != NULL) { hPage = pCreateNetIdPage(); if (hPage == NULL) goto Fail; if (!PropSheetAddPage(hPage, (LPARAM)ppsh)) { DestroyPropertySheetPage(hPage); goto Fail; } } else { Fail: FreeLibrary(hMod); hMod = NULL; } } return hMod; }
void CBasePropertySheet::AddPage(CPropertyPage* pPage) { ASSERT_VALID(this); ASSERT(pPage != NULL); ASSERT_KINDOF(CPropertyPage, pPage); ASSERT_VALID(pPage); // add page to internal list m_pages.Add(pPage); // add page externally if (m_hWnd != NULL) { // build new prop page array AFX_OLDPROPSHEETPAGE *ppsp = new AFX_OLDPROPSHEETPAGE[m_pages.GetSize()]; memcpy(ppsp, m_psh.ppsp, sizeof(AFX_OLDPROPSHEETPAGE) * (m_pages.GetSize()-1)); delete[] (PROPSHEETPAGE*)m_psh.ppsp; m_psh.ppsp = (PROPSHEETPAGE*)ppsp; ppsp += m_pages.GetSize()-1; // copy processed PROPSHEETPAGE struct to end memcpy(ppsp, &pPage->m_psp, sizeof(pPage->m_psp)); // pPage->PreProcessPageTemplate((PROPSHEETPAGE&)*ppsp, IsWizard()); CPropertyPage_PreProcessPageTemplate((_CCPropertyPage*)pPage, (PROPSHEETPAGE&)*ppsp, IsWizard()); HPROPSHEETPAGE hPSP = CreatePropertySheetPage((PROPSHEETPAGE*)ppsp); if (hPSP == NULL) AfxThrowMemoryException(); if (!SendMessage(PSM_ADDPAGE, 0, (LPARAM)hPSP)) { DestroyPropertySheetPage(hPSP); AfxThrowMemoryException(); } } }
void CListViewWalkerPropertySheet::InsertPage(int iIndex, CPropertyPage* pPage) { ASSERT_VALID( this ); ASSERT( pPage != NULL ); ASSERT_KINDOF( CPropertyPage, pPage ); ASSERT_VALID( pPage ); m_pages.InsertAt(iIndex, pPage); BuildPropPageArray(); if (m_hWnd != NULL) { PROPSHEETPAGE* ppsp = const_cast<PROPSHEETPAGE*>(m_psh.ppsp); for (UINT i = 0; i < m_psh.nPages; i++) { if (i == (UINT)iIndex) break; (BYTE*&)ppsp += ppsp->dwSize; } HPROPSHEETPAGE hPSP = CreatePropertySheetPage(ppsp); if (hPSP == NULL) AfxThrowMemoryException(); if (!SendMessage(PSM_INSERTPAGE, iIndex, (LPARAM)hPSP)) { DestroyPropertySheetPage(hPSP); AfxThrowMemoryException(); } } }
// ---------------------------------------------------------------------------- // Function: // CSwapPropPage::AddPages // // Description: // Implementation of IShellPropSheetExt::AddPages. Adds one or more pages // to a property sheet that the Shell displays for a file object. // // Parameters: // lpfnAddPage - [in] Address of a function that the property sheet // handler calls to add a page to the property sheet. The // function takes a property sheet handle returned by the // CreatePropertySheetPage function and the lParam parameter // passed to the AddPages method. // lParam - [in] Parameter to pass to the function specified by the // lpfnAddPage method. // // Return values: // Returns S_OK if successful. If the method fails, an OLE-defined error // code is returned // ---------------------------------------------------------------------------- _Use_decl_annotations_ HRESULT STDMETHODCALLTYPE CSwapPropPage::AddPages ( LPFNADDPROPSHEETPAGE lpfnAddPage, // See PrSht.h LPARAM lParam // Used by caller, don't modify ) { HRESULT hr = S_OK; PROPSHEETPAGE psp; HPROPSHEETPAGE hPage1 = NULL; AudioFXExtensionParams* pAudioFXParams = (AudioFXExtensionParams*)lParam; #pragma warning(push) #pragma warning(disable: 28197) AudioFXExtensionParams* pAudioFXParamsCopy = new AudioFXExtensionParams; #pragma warning(pop) if (pAudioFXParamsCopy == NULL) { return E_OUTOFMEMORY; } // Make a copy of the params CopyMemory(pAudioFXParamsCopy, pAudioFXParams, sizeof(AudioFXExtensionParams)); SAFE_ADDREF(pAudioFXParamsCopy->pFxProperties); // Initialize property page params and create page psp.dwSize = sizeof(psp); psp.dwFlags = PSP_USEREFPARENT | PSP_USECALLBACK; psp.hInstance = _AtlBaseModule.GetModuleInstance(); psp.hIcon = 0; psp.pcRefParent = (UINT*)&m_dwRef; psp.lParam = (LPARAM)pAudioFXParamsCopy; psp.pszTemplate = MAKEINTRESOURCE(IDD_SWAP_PROP_PAGE); psp.pfnDlgProc = (DLGPROC)DialogProcPage1; psp.pfnCallback = PropSheetPageProc; // Create the property sheet page and add the page hPage1 = CreatePropertySheetPage(&psp); if (hPage1) { if (!lpfnAddPage(hPage1, pAudioFXParams->AddPageParam)) { hr = E_FAIL; delete pAudioFXParamsCopy; DestroyPropertySheetPage(hPage1); } else { // Add ref for page this->AddRef(); } } else { delete pAudioFXParamsCopy; hr = E_OUTOFMEMORY; } return(hr); }
STDMETHODIMP CHashCheck::AddPages( LPFNADDPROPSHEETPAGE pfnAddPage, LPARAM lParam ) { PROPSHEETPAGE psp; psp.dwSize = sizeof(psp); psp.dwFlags = PSP_USECALLBACK | PSP_USEREFPARENT | PSP_USETITLE; psp.hInstance = g_hModThisDll; psp.pszTemplate = MAKEINTRESOURCE(IDD_HASHPROP); psp.pszTitle = MAKEINTRESOURCE(IDS_HP_TITLE); psp.pfnDlgProc = HashPropDlgProc; psp.lParam = (LPARAM)m_hList; psp.pfnCallback = HashPropCallback; psp.pcRefParent = (PUINT)&g_cRefThisDll; if (ActivateManifest(FALSE)) { psp.dwFlags |= PSP_USEFUSIONCONTEXT; psp.hActCtx = g_hActCtx; } HPROPSHEETPAGE hPage = CreatePropertySheetPage(&psp); if (hPage && !pfnAddPage(hPage, lParam)) DestroyPropertySheetPage(hPage); // HashProp has AddRef'ed and now owns our list SLRelease(m_hList); m_hList = NULL; return(S_OK); }
STDMETHODIMP CSSHProperty::AddPages( LPFNADDPROPSHEETPAGE lpfnAddPageProc, LPARAM lParam) { PROPSHEETPAGE psp; HPROPSHEETPAGE hPage; // Set up the PROPSHEETPAGE struct. ZeroMemory(&psp, sizeof(PROPSHEETPAGE)); psp.dwSize = sizeof(PROPSHEETPAGE); psp.dwFlags = PSP_USEREFPARENT | PSP_USETITLE | PSP_DEFAULT | PSP_USEICONID | PSP_USECALLBACK; psp.hInstance = _AtlBaseModule.GetResourceInstance(); psp.pszTemplate = MAKEINTRESOURCE(IDD_SSH_PROPERTY); psp.pszIcon = NULL;//MAKEINTRESOURCE(IDI_TAB_ICON); psp.pszTitle = TEXT("Permission"); psp.pfnDlgProc = PropPageDlgProc; psp.lParam = (LPARAM)new string_list(m_lsFiles); psp.pfnCallback = PropPageCallbackProc; psp.pcRefParent = (UINT*) &_AtlModule.m_nLockCnt; // Create the page & get a handle. hPage = CreatePropertySheetPage(&psp); if (NULL != hPage) { // Call the shell's callback function, so it adds the page to // the property sheet. if (!lpfnAddPageProc(hPage, lParam)) DestroyPropertySheetPage(hPage); } return S_OK; }
/*++ Routine Description: SerialPortPropPageProvider Entry-point for adding additional device manager property sheet pages. Registry specifies this routine under Control\Class\PortNode::EnumPropPage32="msports.dll,thisproc" entry. This entry-point gets called only when the Device Manager asks for additional property pages. Arguments: Info - points to PROPSHEETPAGE_REQUEST, see setupapi.h AddFunc - function ptr to call to add sheet. Lparam - add sheet functions private data handle. Return Value: BOOL: FALSE if pages could not be added, TRUE on success --*/ BOOL CALLBACK SerialPortPropPageProvider(LPVOID Info, LPFNADDPROPSHEETPAGE AddFunc, LPARAM Lparam ) { PSP_PROPSHEETPAGE_REQUEST pprPropPageRequest; PROPSHEETPAGE psp; HPROPSHEETPAGE hpsp; PPORT_PARAMS params = NULL; pprPropPageRequest = (PSP_PROPSHEETPAGE_REQUEST) Info; if (PortTypeSerial != GetPortType(pprPropPageRequest->DeviceInfoSet, pprPropPageRequest->DeviceInfoData, FALSE)) { return FALSE; } // // Allocate and zero out memory for the struct that will contain // page specific data // params = (PPORT_PARAMS) LocalAlloc(LPTR, sizeof(PORT_PARAMS)); if (!params) { ErrMemDlg(GetFocus()); return FALSE; } if (pprPropPageRequest->PageRequested == SPPSR_ENUM_ADV_DEVICE_PROPERTIES) { InitPortParams(params, pprPropPageRequest->DeviceInfoSet, pprPropPageRequest->DeviceInfoData); hpsp = InitSettingsPage(&psp, params); if (!hpsp) { LocalFree(params); return FALSE; } if (!(*AddFunc)(hpsp, Lparam)) { DestroyPropertySheetPage(hpsp); return FALSE; } } else { LocalFree(params); } return TRUE; } /* SerialPortPropPageProvider */
BOOL WINAPI SerialPortPropPageProvider(PSP_PROPSHEETPAGE_REQUEST lpPropSheetPageRequest, LPFNADDPROPSHEETPAGE lpfnAddPropSheetPageProc, LPARAM lParam) { PROPSHEETPAGEW PropSheetPage; HPROPSHEETPAGE hPropSheetPage; FIXME("SerialPortPropPageProvider(%p %p %lx)\n", lpPropSheetPageRequest, lpfnAddPropSheetPageProc, lParam); if (lpPropSheetPageRequest->PageRequested == SPPSR_ENUM_ADV_DEVICE_PROPERTIES) { FIXME("SPPSR_ENUM_ADV_DEVICE_PROPERTIES\n"); PropSheetPage.dwSize = sizeof(PROPSHEETPAGEW); PropSheetPage.dwFlags = 0; PropSheetPage.hInstance = hInstance; PropSheetPage.pszTemplate = MAKEINTRESOURCE(IDD_SERIALSETTINGS); PropSheetPage.pfnDlgProc = SerialSettingsDlgProc; PropSheetPage.lParam = 0; PropSheetPage.pfnCallback = NULL; hPropSheetPage = CreatePropertySheetPageW(&PropSheetPage); if (hPropSheetPage == NULL) { FIXME("CreatePropertySheetPageW() failed!\n"); return FALSE; } if (!(*lpfnAddPropSheetPageProc)(hPropSheetPage, lParam)) { FIXME("lpfnAddPropSheetPageProc() failed!\n"); DestroyPropertySheetPage(hPropSheetPage); return FALSE; } } FIXME("Done!\n"); return TRUE; }
static HRESULT WINAPI INetConnectionPropertyUi2_fnAddPages( INetConnectionPropertyUi2 * iface, HWND hwndParent, LPFNADDPROPSHEETPAGE pfnAddPage, LPARAM lParam) { HPROPSHEETPAGE hProp; BOOL ret; HRESULT hr = E_FAIL; INITCOMMONCONTROLSEX initEx; INetConnectionPropertyUiImpl * This = (INetConnectionPropertyUiImpl*)iface; initEx.dwSize = sizeof(initEx); initEx.dwICC = ICC_LISTVIEW_CLASSES; if(!InitCommonControlsEx(&initEx)) return E_FAIL; hr = INetConnection_GetProperties(This->pCon, &This->pProperties); if (FAILED(hr)) return hr; hProp = InitializePropertySheetPage(MAKEINTRESOURCEW(IDD_NETPROPERTIES), LANPropertiesUIDlg, (LPARAM)This, This->pProperties->pszwName); if (hProp) { ret = (*pfnAddPage)(hProp, lParam); if (ret) { hr = NOERROR; } else { DestroyPropertySheetPage(hProp); } } return hr; }
extern "C" BOOL CALLBACK AddPersonalTrustDBPages( // // Add the pages of our trust database editor to the indicated property // sheet by using the indicated callback function. Return success or failure // LPVOID lpv, LPFNADDPROPSHEETPAGE lpfnAddPage, LPARAM lParam ) { PROPSHEETPAGE psp; CDialogTrustDB* pdlg = new CDialogTrustDB; if (!pdlg) return FALSE; psp.dwSize = sizeof(psp); // no extra data psp.dwFlags = PSP_USECALLBACK | PSP_USETITLE; psp.hInstance = hinst; psp.pszTemplate = MAKEINTRESOURCE(IDD_TRUSTDIALOG); psp.pfnDlgProc = TrustPropSheetDialogProc; psp.pfnCallback = TrustPropSheetDialogReleaseProc; psp.lParam = (LPARAM)pdlg; psp.pszTitle = MAKEINTRESOURCE(IDS_TRUSTDIALOG); BOOL fSuccess = TRUE; HPROPSHEETPAGE hpage = CreatePropertySheetPage(&psp); if (hpage) { if (!lpfnAddPage(hpage, lParam)) { DestroyPropertySheetPage(hpage); fSuccess = FALSE; } } else fSuccess = FALSE; return fSuccess; }
//---------------------------------------------------------------------------- // // Description: // Adds another property page to the handler's properties dialog. // // Parameters: // lpfnAddPage - Pointer to the function which we call to add the page. // lParam - Reserved, must be passed to lpfnAddPage. // // Return Values: // S_OK - Page was successfully added. // Other HRESULTs - Page was not added. // //---------------------------------------------------------------------------- STDMETHODIMP CMyDevicePropertySheet::AddPages( __in LPFNADDPROPSHEETPAGE lpfnAddPage, __in LPARAM lParam) { HRESULT hr = E_FAIL; PROPSHEETPAGEW psp = {0}; HPROPSHEETPAGE hPage = NULL;; // Build the PROPSHEETPAGEW structure which // describes the page we will add psp.dwSize = sizeof(psp); psp.dwFlags = PSP_DEFAULT | PSP_USETITLE; psp.hInstance = g_hmodThisDll; psp.pszTemplate = MAKEINTRESOURCEW(IDD_PROPPAGE); psp.pfnDlgProc = _DlgProc; psp.lParam = (LPARAM) this; psp.pszTitle = MAKEINTRESOURCEW(IDS_PROPS_TITLE); hPage = CreatePropertySheetPageW(&psp); if (hPage != NULL) { // Add the page. If it fails, then destroy the // page we have created. if (!lpfnAddPage(hPage, lParam)) { DestroyPropertySheetPage(hPage); hPage = NULL; } } if (hPage != NULL) { hr = S_OK; } return hr; } //*** CMyDevicePropertySheet::AddPages
HRESULT CFileTimeShlExt::AddPages ( LPFNADDPROPSHEETPAGE lpfnAddPageProc, LPARAM lParam ) { PROPSHEETPAGE psp; HPROPSHEETPAGE hPage; TCHAR szPageTitle [MAX_PATH]; string_list::const_iterator it, itEnd; for ( it = m_lsFiles.begin(), itEnd = m_lsFiles.end(); it != itEnd; it++ ) { // 'it' points at the next filename. Allocate a new copy of the string // that the page will own. LPCTSTR szFile = _tcsdup ( it->c_str() ); if ( NULL == szFile ) return E_OUTOFMEMORY; // Strip the path and extension from the filename - this will be the // page title. The name is truncated at 24 chars so it fits on the tab. lstrcpy ( szPageTitle, it->c_str() ); PathStripPath ( szPageTitle ); PathRemoveExtension ( szPageTitle ); szPageTitle[24] = '\0'; // Set up the PROPSHEETPAGE struct. ZeroMemory ( &psp, sizeof(PROPSHEETPAGE) ); psp.dwSize = sizeof(PROPSHEETPAGE); psp.dwFlags = PSP_USEREFPARENT | PSP_USETITLE | PSP_DEFAULT | PSP_USEICONID | PSP_USECALLBACK; psp.hInstance = _Module.GetModuleInstance(); psp.pszTemplate = MAKEINTRESOURCE(IDD_FILETIME_PROPPAGE); psp.pszIcon = MAKEINTRESOURCE(IDI_ICON); psp.pszTitle = szPageTitle; psp.pfnDlgProc = PropPageDlgProc; psp.lParam = (LPARAM) szFile; psp.pfnCallback = PropPageCallbackProc; psp.pcRefParent = (UINT*) &_Module.m_nLockCnt; // Create the page & get a handle. hPage = CreatePropertySheetPage ( &psp ); if ( NULL != hPage ) { // Call the shell's callback function, so it adds the page to // the property sheet. if ( !lpfnAddPageProc ( hPage, lParam )) { DestroyPropertySheetPage ( hPage ); } } } // end for return S_OK; }
static void test_PSM_INSERTPAGE(void) { HPROPSHEETPAGE hpsp[5]; PROPSHEETPAGEA psp; PROPSHEETHEADERA psh; HWND hdlg, tab; BOOL ret; DWORD r; memset(&psp, 0, sizeof(psp)); psp.dwSize = sizeof(psp); psp.dwFlags = 0; psp.hInstance = GetModuleHandleA(NULL); U(psp).pszTemplate = (LPCSTR)MAKEINTRESOURCE(IDD_PROP_PAGE_MESSAGE_TEST); U2(psp).pszIcon = NULL; psp.pfnDlgProc = page_dlg_proc_messages; psp.lParam = 0; /* multiple pages with the same data */ hpsp[0] = CreatePropertySheetPageA(&psp); hpsp[1] = CreatePropertySheetPageA(&psp); hpsp[2] = CreatePropertySheetPageA(&psp); U(psp).pszTemplate = (LPCSTR)MAKEINTRESOURCE(IDD_PROP_PAGE_ERROR); hpsp[3] = CreatePropertySheetPageA(&psp); psp.dwFlags = PSP_PREMATURE; hpsp[4] = CreatePropertySheetPageA(&psp); memset(&psh, 0, sizeof(psh)); psh.dwSize = PROPSHEETHEADERA_V1_SIZE; psh.dwFlags = PSH_MODELESS; psh.pszCaption = "test caption"; psh.nPages = 1; psh.hwndParent = GetDesktopWindow(); U3(psh).phpage = hpsp; hdlg = (HWND)PropertySheetA(&psh); ok(hdlg != INVALID_HANDLE_VALUE, "got invalid handle %p\n", hdlg); /* add pages one by one */ ret = SendMessageA(hdlg, PSM_INSERTPAGE, 5, (LPARAM)hpsp[1]); ok(ret == TRUE, "got %d\n", ret); /* try with invalid values */ ret = SendMessageA(hdlg, PSM_INSERTPAGE, 0, 0); ok(ret == FALSE, "got %d\n", ret); if (0) { /* crashes on native */ ret = SendMessageA(hdlg, PSM_INSERTPAGE, 0, (LPARAM)INVALID_HANDLE_VALUE); } ret = SendMessageA(hdlg, PSM_INSERTPAGE, (LPARAM)INVALID_HANDLE_VALUE, (LPARAM)hpsp[2]); ok(ret == FALSE, "got %d\n", ret); /* check item count */ tab = (HWND)SendMessageA(hdlg, PSM_GETTABCONTROL, 0, 0); r = SendMessageA(tab, TCM_GETITEMCOUNT, 0, 0); ok(r == 2, "got %d\n", r); ret = SendMessageA(hdlg, PSM_INSERTPAGE, (WPARAM)hpsp[1], (LPARAM)hpsp[2]); ok(ret == TRUE, "got %d\n", ret); r = SendMessageA(tab, TCM_GETITEMCOUNT, 0, 0); ok(r == 3, "got %d\n", r); /* add property sheet page that can't be created */ ret = SendMessageA(hdlg, PSM_INSERTPAGE, 1, (LPARAM)hpsp[3]); ok(ret == TRUE, "got %d\n", ret); r = SendMessageA(tab, TCM_GETITEMCOUNT, 0, 0); ok(r == 4, "got %d\n", r); /* select page that can't be created */ ret = SendMessageA(hdlg, PSM_SETCURSEL, 1, 0); ok(ret == TRUE, "got %d\n", ret); r = SendMessageA(tab, TCM_GETITEMCOUNT, 0, 0); ok(r == 3, "got %d\n", r); /* test PSP_PREMATURE flag with incorrect property sheet page */ ret = SendMessageA(hdlg, PSM_INSERTPAGE, 0, (LPARAM)hpsp[4]); ok(ret == FALSE, "got %d\n", ret); r = SendMessageA(tab, TCM_GETITEMCOUNT, 0, 0); ok(r == 3, "got %d\n", r); DestroyPropertySheetPage(hpsp[4]); DestroyWindow(hdlg); }
//------------------------------------------------------------------------------ // CDevicePropertyPage::AddPages // // This method is called by the Windows Shell to give oportunity to // register one or more property pages with the property sheet. Minimal // work should be done here. Essentially only enough work to figure out // whether the property page should be added or not (i.e. no critical data // is missing). All other work should be done in the DlgProc function // when the WM_INITDIALOG message is sent. //------------------------------------------------------------------------------ IFACEMETHODIMP CDevicePropertyPage::AddPages( __in LPFNADDPROPSHEETPAGE pfnAddPage, __in LPARAM lParam ) { HPROPSHEETPAGE hPage; HRESULT hr = S_OK; PROPSHEETPAGE psp = {0}; PROPSINPUT* pPropsInput = NULL; if( NULL == pfnAddPage ) { return E_INVALIDARG; } // // Allocate the PROPSINPUT struct // pPropsInput = new (std::nothrow) PROPSINPUT; if( NULL == pPropsInput ) { hr = E_OUTOFMEMORY; } if( S_OK == hr ) { // // Fill out the PROPSHEETPAGE structure // psp.dwSize = sizeof(PROPSHEETPAGE); psp.dwFlags = PSP_USECALLBACK; psp.hInstance = g_hInstance; psp.pszTemplate = MAKEINTRESOURCE(IDD_PROPPAGE_DEVICE); psp.pfnDlgProc = PropPageDlgProc; psp.lParam = reinterpret_cast<LPARAM>( pPropsInput ); psp.pfnCallback = PropPageDlgCleanup; // // Give a reference to the shell item to the callback data // hr = m_pShellItem->QueryInterface( &pPropsInput->pShellItem ); } // // Grab the icon from the shell item // if( S_OK == hr ) { hr = GetIconFromItem( m_pShellItem, SHIL_LARGE, &pPropsInput->hIcon ); } // // Create the page // hPage = CreatePropertySheetPage( &psp ); if( NULL == hPage ) { hr = E_OUTOFMEMORY; } // // Give the shell the page // if( S_OK == hr && !pfnAddPage( hPage, lParam ) ) { hr = E_FAIL; } // // As the documentation for AddPages describes, you can "request" that your // page is the one visibile when the property sheet is loaded. You can do // this by giving the index of the page you added (1 based). In this sample // we just added one page, so we can return 1 instead of the HR (assuming // we didn't fail) to request our page to be the one visible on launch. // Keep in mind it is a "request" and is not guaranteed. // if( S_OK == hr ) { hr = static_cast<HRESULT>(1); } else { if( NULL != hPage ) { DestroyPropertySheetPage( hPage ); } if( NULL != pPropsInput->pShellItem ) { pPropsInput->pShellItem->Release(); } if( NULL != pPropsInput->hIcon ) { DestroyIcon( pPropsInput->hIcon ); } } return hr; }// CDevicePropertyPage::AddPages
STDMETHODIMP CShellExt::XPropertySheetExt::AddPages(LPFNADDPROPSHEETPAGE lpfnAddPage, LPARAM lParam) { METHOD_PROLOGUE(CShellExt, PropertySheetExt); if(pThis->m_bIsPathInAFS) { // add the property page for files/folder/mount points/symlinks PROPSHEETPAGE psp; SecureZeroMemory(&psp, sizeof(PROPSHEETPAGE)); HPROPSHEETPAGE hPage; CPropFile *filesheet = NULL; CPropVolume *volsheet = NULL; CPropACL * aclsheet = NULL; filesheet = new CPropFile(pThis->m_astrFileNames); if (filesheet == NULL) return E_OUTOFMEMORY; HINSTANCE hInst = 0; TaLocale_GetResource(RT_DIALOG, MAKEINTRESOURCE(IDD_PROPPAGE_FILE), LANG_USER_DEFAULT, &hInst); filesheet->m_hInst = hInst; filesheet->m_bIsMountpoint = pThis->m_bIsMountpoint; filesheet->m_bIsSymlink = pThis->m_bIsSymlink; filesheet->m_bIsDir = pThis->m_bDirSelected; psp.dwSize = sizeof (psp); psp.dwFlags = PSP_USEREFPARENT | PSP_USETITLE | PSP_USECALLBACK | PSP_USETITLE; psp.hInstance = hInst; psp.pszTemplate = MAKEINTRESOURCE(IDD_PROPPAGE_FILE); psp.pszIcon = NULL; psp.pszTitle = _T("AFS"); psp.pfnDlgProc = (DLGPROC) PageProc; psp.lParam = (LPARAM) filesheet; psp.pfnCallback = PropPageCallbackProc; psp.pcRefParent = (UINT*) &nPSRefCount; hPage = CreatePropertySheetPage (&psp); if (hPage != NULL) { if (!lpfnAddPage (hPage, lParam)) { delete filesheet; DestroyPropertySheetPage (hPage); } } // add the property page for Volume Data SecureZeroMemory(&psp, sizeof(PROPSHEETPAGE)); volsheet = new CPropVolume(pThis->m_astrFileNames); if (volsheet == NULL) return E_OUTOFMEMORY; hInst = 0; TaLocale_GetResource(RT_DIALOG, MAKEINTRESOURCE(IDD_PROPPAGE_VOLUME), LANG_USER_DEFAULT, &hInst); volsheet->m_hInst = hInst; volsheet->m_bIsMountpoint = pThis->m_bIsMountpoint; volsheet->m_bIsSymlink = pThis->m_bIsSymlink; volsheet->m_bIsDir = pThis->m_bDirSelected; psp.dwSize = sizeof (psp); psp.dwFlags = PSP_USEREFPARENT | PSP_USETITLE | PSP_USECALLBACK | PSP_USETITLE; psp.hInstance = hInst; psp.pszTemplate = MAKEINTRESOURCE(IDD_PROPPAGE_VOLUME); psp.pszIcon = NULL; psp.pszTitle = _T("AFS Volume"); psp.pfnDlgProc = (DLGPROC) PageProc; psp.lParam = (LPARAM) volsheet; psp.pfnCallback = PropPageCallbackProc; psp.pcRefParent = (UINT*) &nPSRefCount; hPage = CreatePropertySheetPage (&psp); if (hPage != NULL) { if (!lpfnAddPage (hPage, lParam)) { delete volsheet; DestroyPropertySheetPage (hPage); } } if(pThis->m_bDirSelected) { // add the property page for ACLs SecureZeroMemory(&psp, sizeof(PROPSHEETPAGE)); aclsheet = new CPropACL(pThis->m_astrFileNames); if (aclsheet == NULL) return E_OUTOFMEMORY; hInst = 0; TaLocale_GetResource(RT_DIALOG, MAKEINTRESOURCE(IDD_PROPPAGE_ACL), LANG_USER_DEFAULT, &hInst); aclsheet->m_hInst = hInst; aclsheet->m_bIsMountpoint = pThis->m_bIsMountpoint; aclsheet->m_bIsSymlink = pThis->m_bIsSymlink; aclsheet->m_bIsDir = pThis->m_bDirSelected; psp.dwSize = sizeof (psp); psp.dwFlags = PSP_USEREFPARENT | PSP_USETITLE | PSP_USECALLBACK | PSP_USETITLE; psp.hInstance = hInst; psp.pszTemplate = MAKEINTRESOURCE(IDD_PROPPAGE_ACL); psp.pszIcon = NULL; psp.pszTitle = _T("AFS ACL"); psp.pfnDlgProc = (DLGPROC) PageProc; psp.lParam = (LPARAM) aclsheet; psp.pfnCallback = PropPageCallbackProc; psp.pcRefParent = (UINT*) &nPSRefCount; hPage = CreatePropertySheetPage (&psp); if (hPage != NULL) { if (!lpfnAddPage (hPage, lParam)) { delete aclsheet; DestroyPropertySheetPage (hPage); } } } } return S_OK; }
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR, int nCmdShow) { UNREFERENCED_PARAMETER(nCmdShow); UNREFERENCED_PARAMETER(hPrevInstance); PROPSHEETPAGE psp; //defines the property sheet pages HPROPSHEETPAGE rhpsp[MAXPAGES]; //an array to hold the page's HPROPSHEETPAGE handles SHAREDWIZDATA wizdata; //the shared data structure UINT cPages = 0; //number of pages being added BOOL fPagesCreated = FALSE;//were all of the pages created successfully? ZeroMemory(&psp, sizeof(psp)); ZeroMemory(&wizdata, sizeof(wizdata)); ZeroMemory(&rhpsp, sizeof(HPROPSHEETPAGE)*MAXPAGES); // // Create the Wizard pages // // First interior page psp.dwSize = sizeof(psp); psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE; psp.hInstance = hInstance; psp.lParam = (LPARAM) &wizdata; //The shared data structure psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_TITLE1); psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_SUBTITLE1); psp.pszTemplate = MAKEINTRESOURCE(IDD_INTERIOR1); psp.pfnDlgProc = (DLGPROC)IntPage1DlgProc; rhpsp[cPages] = CreatePropertySheetPage(&psp); if (rhpsp[cPages]) { ++cPages; // Second interior page psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE; psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_TITLE2); psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_SUBTITLE2); psp.pszTemplate = MAKEINTRESOURCE(IDD_INTERIOR2); psp.pfnDlgProc = (DLGPROC)IntPage2DlgProc; rhpsp[cPages] = CreatePropertySheetPage(&psp); if (rhpsp[cPages]) { ++cPages; //Third interior page psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE; psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_TITLE3); psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_SUBTITLE3); psp.pszTemplate = MAKEINTRESOURCE(IDD_INTERIOR3); psp.pfnDlgProc = (DLGPROC)IntPage3DlgProc; rhpsp[cPages] = CreatePropertySheetPage(&psp); if (rhpsp[cPages]) { ++cPages; fPagesCreated = TRUE; } } } if (fPagesCreated) { // Create the property sheet PROPSHEETHEADER psh; //defines the property sheet ZeroMemory(&psh, sizeof(psh)); psh.dwSize = sizeof(psh); psh.hInstance = hInstance; psh.hwndParent = NULL; psh.phpage = rhpsp; psh.dwFlags = PSH_AEROWIZARD | PSH_USEICONID; psh.pszCaption = MAKEINTRESOURCE(IDS_WIZTITLE); psh.pszIcon = MAKEINTRESOURCE(IDI_WIZICON); psh.nStartPage = 0; psh.nPages = cPages; //Display the wizard if (PropertySheet(&psh) == -1) { // an error occurred, call GetLastError() to retrieve it here. } } else { // error creating pages -- clean up any we did create for (UINT iPage = 0; iPage < cPages; ++iPage) { DestroyPropertySheetPage(rhpsp[iPage]); } } return 0; }