#include "shellprv.h" #include "duiview.h" #include "duilist.h" #include "duisec.h" #include "duitask.h" #include "duiinfo.h" #include "duihost.h" #include "duidrag.h" #include "defviewp.h" #include "ids.h" #include "dvtasks.h" #include #include #include UsingDUIClass(DUIListView); UsingDUIClass(DUIAxHost); UsingDUIClass(Expando); UsingDUIClass(ActionTask); UsingDUIClass(DestinationTask); // // These are private window messages posted to the host window // so they will be processed async. There are issues with // trying to destroy a handler while inside of the handler // #define WM_NAVIGATETOPIDL (WM_USER + 42) #define WM_REFRESHVIEW (WM_USER + 43) #define DUI_HOST_WINDOW_CLASS_NAME TEXT("DUIViewWndClassName") // // Default attributes associated with our DUI sections. // struct DUISEC_ATTRIBUTES { DUISEC _eDUISecID; BOOL _bExpandedDefault; LPCWSTR _pszExpandedPropName; } const c_DUISectionAttributes[] = { DUISEC_SPECIALTASKS, TRUE, L"ExpandSpecialTasks", DUISEC_FILETASKS, TRUE, L"ExpandFileTasks", DUISEC_OTHERPLACESTASKS, TRUE, L"ExpandOtherPlacesTasks", DUISEC_DETAILSTASKS, FALSE, L"ExpandDetailsTasks" }; // pDefView - pointer to the defview class CDUIView* Create_CDUIView(CDefView * pDefView) { CDUIView* p = new CDUIView(pDefView); if (p) { if (FAILED(p->Initialize())) { delete p; p = NULL; } } return p; } CDUIView::CDUIView(CDefView * pDefView) { // We have a zero-init constructor. Be paranoid and check a couple: ASSERT(NULL ==_hWnd); ASSERT(NULL == _pshlItems); ASSERT(NULL == _ppbShellFolders); _cRef = 1; _pDefView = pDefView; _pDefView->AddRef(); } HRESULT CDUIView::Initialize() { // Initialize DirectUI process (InitProcess) and register classes _hrInit = InitializeDirectUI(); if (FAILED(_hrInit)) goto Failure; // Initialize DirectUI thread _hrInit = InitThread(); if (FAILED(_hrInit)) goto Failure; ManageAnimations(FALSE); _pDT = new CDUIDropTarget (); Failure: return _hrInit; } CDUIView::~CDUIView() { IUnknown_SetSite(_spThumbnailExtractor2, NULL); if (_hwndMsgThumbExtract) // May have been (likely) created by CMiniPreviewer { DestroyWindow(_hwndMsgThumbExtract); } if (_hwndMsgInfoExtract) // May have been (likely) created by CNameSpaceItemInfoList { DestroyWindow(_hwndMsgInfoExtract); } ATOMICRELEASE(_pshlItems); if (_bstrIntroText) { SysFreeString(_bstrIntroText); } if (_hinstTheme) { FreeLibrary(_hinstTheme); _hinstTheme = NULL; _fLoadedTheme = FALSE; } if (_hinstScrollbarTheme) { CloseThemeData(_hinstScrollbarTheme); _hinstScrollbarTheme = NULL; } UnInitializeDirectUI(); if (_ppbShellFolders) _ppbShellFolders->Release(); _pDefView->Release(); } // // This DUI uninitialization code was broken out from the destructor // because we need to call it from defview in response to WM_NCDESTROY // before the CDUIView object is destroyed. This is required to properly // initiate the shutdown of DUser on the thread. Since we don't own the // browser thread message pump we must ensure all DUser processing is // complete before our defview instance goes away. // Therefore, since it can be called twice, once from defview and once // from CDUIView::~CDUIView, all processing must tolerate multiple calls // for the same instance. // void CDUIView::UnInitializeDirectUI(void) { ATOMICRELEASE(_pvSpecialTaskSheet); ATOMICRELEASE(_pvFolderTaskSheet); ATOMICRELEASE(_pvDetailsSheet); _ClearNonStdTaskSections(); if (_pDT) { _pDT->Release(); _pDT = NULL; } ManageAnimations(TRUE); if (SUCCEEDED(_hrInit)) { UnInitThread(); _hrInit = E_FAIL; // UnInit thread only once. } } // Right now our themeing information is hard-coded due to limitations of DirectUI (only one resource) // so we'll ask the namespace for a hardcoded name that we can look up in the below table. Add new // names/entries to this list as we add theme parts to our shellstyle.dll. // // These theme elements come from shellstyle.dll. const WVTHEME c_wvTheme[] = { { L"music", IDB_MUSIC_ICON_BMP, IDB_MUSIC_TASKS_BMP, IDB_MUSIC_LISTVIEW_BMP }, { L"picture", IDB_PICTURES_ICON_BMP, IDB_PICTURES_TASKS_BMP, IDB_PICTURES_LISTVIEW_BMP }, { L"video", IDB_VIDEO_ICON_BMP, IDB_VIDEO_TASKS_BMP, IDB_VIDEO_LISTVIEW_BMP }, { L"search", IDB_SEARCH_ICON_BMP, IDB_SEARCH_TASKS_BMP, IDB_SEARCH_LISTVIEW_BMP }, }; const WVTHEME* CDUIView::GetThemeInfo() { for (UINT i = 0 ; i < ARRAYSIZE(c_wvTheme) ; i++) { if (0 == lstrcmp(_pDefView->_wvTheme.pszThemeID, c_wvTheme[i].pszThemeName)) return &(c_wvTheme[i]); } return NULL; } // Main intialization point for DUI view // // bDisplayBarrier - Display soft barrier over top of listview HRESULT CDUIView::Initialize(BOOL bDisplayBarrier, IUnknown * punkPreview) { DisableAnimations(); Element::StartDefer(); // Create the host window for the DUI elements HRESULT hr = _CreateHostWindow(); if (SUCCEEDED(hr)) { // Dynamically build the .ui file for this view int iCharCount; char *pUIFile = NULL; hr = _BuildUIFile(&pUIFile, &iCharCount); if (SUCCEEDED(hr)) { // Parse the .ui file and initialize the elements hr = _InitializeElements(pUIFile, iCharCount, bDisplayBarrier, punkPreview); if (SUCCEEDED(hr)) { BuildDropTarget(_phe->GetDisplayNode(), _phe->GetHWND()); // Set visible for host element _phe->SetVisible(true); } LocalFree(pUIFile); } } // Note: // EndDefer() here so layout coordinates are calculated before executing // the next snippit of code which depends on them being set properly. // The one thing to be aware of in future is that if this isn't the // outermost BeginDefer()/EndDefer() pair in the codepath, we're in // trouble because then DUI won't calculate its layout coordinates. Element::EndDefer(); if (SUCCEEDED(hr)) { Value* pv; if (_peTaskPane->GetExtent(&pv)) { const SIZE * pSize = pv->GetSize(); _iOriginalTaskPaneWidth = pSize->cx; _iTaskPaneWidth = pSize->cx; pv->Release(); // REVIEW: Why are we doing this based on a resource string, instead // of simply having the localizers localize the size in the theme??? // It kind of sucks because we're forcing two layouts all the time. _iTaskPaneWidth = ScaleSizeBasedUponLocalization(_iOriginalTaskPaneWidth); if (_iTaskPaneWidth != _iOriginalTaskPaneWidth) { Element::StartDefer(); // Increase the width of the scroller if the localizers have // bumped up the size defined in the resources _peTaskPane->SetWidth(_iTaskPaneWidth); Element::EndDefer(); } } if (_fHideTasklist || (_phe->GetWidth() / 2) < _iTaskPaneWidth) { Element::StartDefer(); _peTaskPane->SetWidth(0); Element::EndDefer(); } _bInitialized = true; } else { if (_hWnd) { DestroyWindow (_hWnd); _hWnd = NULL; } } // Note: // We don't re-enable animations until after we're completely finished // with all our crazy resizing and stuff. This prevents some nasty // issues with DUI panes only partly painting (i.e. RAID 422057). EnableAnimations(); return hr; } void CDUIView::DetachListview() { if (_peListView) _peListView->DetachListview(); if (_hWnd) { DestroyWindow(_hWnd); _hWnd = NULL; } } // Creates the host window for the DUI elements to // be associated with. This child window // will also be passed back to defview to be used // as the result pane host. HRESULT CDUIView::_CreateHostWindow (void) { WNDCLASS wc = {0}; wc.style = CS_HREDRAW | CS_VREDRAW; wc.lpfnWndProc = _DUIHostWndProc; wc.hInstance = HINST_THISDLL; wc.hCursor = LoadCursor(NULL, IDC_ARROW); wc.hbrBackground = (HBRUSH)GetStockObject(HOLLOW_BRUSH); wc.lpszClassName = DUI_HOST_WINDOW_CLASS_NAME; RegisterClass(&wc); // Query for the size of defview's client window so we can size this window // to match RECT rc; GetClientRect(_pDefView->_hwndView, &rc); _hWnd = CreateWindowEx(0, DUI_HOST_WINDOW_CLASS_NAME, NULL, WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN, rc.left, rc.top, rc.right, rc.bottom, _pDefView->_hwndView, NULL, HINST_THISDLL, (void *)this); if (!_hWnd) { TraceMsg(TF_ERROR, "CDUIView::_CreateHostWindow: CreateWindowEx failed with %d", GetLastError()); return HRESULT_FROM_WIN32(GetLastError()); } // Temporary work-around for DUI mirroring bug 259158 SHSetWindowBits(_hWnd, GWL_EXSTYLE, WS_EX_LAYOUTRTL, 0); return S_OK; } void CDUIView::ManageAnimations(BOOL bExiting) { if (bExiting) { if (_bAnimationsDisabled) { DirectUI::EnableAnimations(); _bAnimationsDisabled = FALSE; } } else { BOOL bAnimate = TRUE; SystemParametersInfo(SPI_GETMENUANIMATION, 0, &bAnimate, 0); if (bAnimate) { if (_bAnimationsDisabled) { DirectUI::EnableAnimations(); _bAnimationsDisabled = FALSE; } } else { if (!_bAnimationsDisabled) { DirectUI::DisableAnimations(); _bAnimationsDisabled = TRUE; } } } } HINSTANCE CDUIView::_GetThemeHinst() { if (!_fLoadedTheme) { _fLoadedTheme = TRUE; if (_hinstTheme) { FreeLibrary(_hinstTheme); } _hinstTheme = SHGetShellStyleHInstance(); if (_hinstScrollbarTheme) { CloseThemeData (_hinstScrollbarTheme); } _hinstScrollbarTheme = OpenThemeData(_hWnd, L"Scrollbar"); } return _hinstTheme ? _hinstTheme : HINST_THISDLL; } // Loads the requested UI file from shell32's resources // // iID - UI file id // pUIFile - receives a pointer to the UI file HRESULT CDUIView::_LoadUIFileFromResources(HINSTANCE hinst, int iID, char **pUIFile) { HRESULT hr; HRSRC hFile = FindResource(hinst, MAKEINTRESOURCE(iID), TEXT("UIFILE")); if (hFile) { HGLOBAL hFileHandle = LoadResource(hinst, hFile); if (hFileHandle) { char *pFile = (char *)LockResource(hFileHandle); if (pFile) { DWORD dwSize = SizeofResource(hinst, hFile); *pUIFile = (char *)LocalAlloc(LPTR, dwSize + 1); if (*pUIFile) { CopyMemory(*pUIFile, pFile, dwSize); hr = S_OK; } else { hr = E_OUTOFMEMORY; } } else { hr = HRESULT_FROM_WIN32(GetLastError()); } } else { hr = HRESULT_FROM_WIN32(GetLastError()); } } else { hr = HRESULT_FROM_WIN32(GetLastError()); } return hr; } // Builds the UI file for this view from the // appropriate base template + style sheet // // pUIFile receives a pointer to the ui file in memory // piCharCount receives the size of the file HRESULT CDUIView::_BuildUIFile(char **pUIFile, int *piCharCount) { // Load the base UI file char * pBase; HRESULT hr = _LoadUIFileFromResources(HINST_THISDLL, IDR_DUI_FOLDER, &pBase); if (SUCCEEDED(hr)) { // Load the style sheet. First, check if the current theme has a style sheet, // if not, use the default style sheet in the resources. char *pStyle; hr = _LoadUIFileFromResources(_GetThemeHinst(), IDR_DUI_STYLESHEET, &pStyle); if (SUCCEEDED(hr)) { char *pResult = (char *)LocalAlloc(LPTR, lstrlenA(pBase) + lstrlenA(pStyle) + 1); if (pResult) { // Put the files together lstrcpyA(pResult, pStyle); lstrcatA(pResult, pBase); // Store the final results *pUIFile = pResult; *piCharCount = lstrlenA(pResult); } else { hr = E_OUTOFMEMORY; } LocalFree(pStyle); } LocalFree(pBase); } return hr; } // Callback function used by the ui file parser // // pszError - Error text // pszToken - Token text // iLine - Line number void CALLBACK UIFileParseError(LPCWSTR pszError, LPCWSTR pszToken, int iLine) { TraceMsg (TF_ERROR, "UIFileParseError: %s '%s' at line %d", pszError, pszToken, iLine); } // Builds a section which holds tasks // // peSectionList - parent of the section // bMain - Main section or normal section // pTitleUI - interface describing the title, may be NULL if pTitleDesc provided // pBitmapDesc - Description of the bitmap // pWatermarkDesc - Description of the watermark // pvSectionSheet - Style sheet to be used // pParser - Parser instance pointer // fExpanded - Expanded or closed // ppeExpando - [out,optional] Receives the section just created // pTaskList - [out] Receives the task list area element pointer within the pExpando HRESULT CDUIView::_BuildSection(Element* peSectionList, BOOL bMain, IUIElement* pTitleUI, int idBitmapDesc, int idWatermarkDesc, Value* pvSectionSheet, Parser* pParser, DUISEC eDUISecID, Expando** ppeExpando, Element ** pTaskList) { Expando* peSection = NULL; Value* pv = NULL; Element* pe = NULL; HBITMAP hBitmap; // Create a section using the definition in the ui file HRESULT hr = pParser->CreateElement (bMain ? L"mainsection" : L"section", NULL, &pe); if (FAILED(hr)) { TraceMsg (TF_ERROR, "CDUIView::_BuildSection: CreateElement failed with 0x%x", hr); return hr; } ASSERTMSG(pe->GetClassInfo() == Expando::Class, "CDUIView::_BuildSection: didn't get an Expando::Class object (%s)", pe->GetClassInfo()->GetName()); peSection = (Expando*)pe; pe->SetWidth(ScaleSizeBasedUponLocalization(pe->GetWidth())); peSection->Initialize(eDUISecID, pTitleUI, this, _pDefView); if (ppeExpando) *ppeExpando = peSection; // Add the section to the list peSectionList->Add (peSection); // Set the title peSection->UpdateTitleUI(NULL); // nothing is selected when the folder starts up // Set the bitmap on the left side if (idBitmapDesc) { pe = peSection->FindDescendent (Expando::idIcon); if (pe) { hBitmap = DUILoadBitmap(_GetThemeHinst(), idBitmapDesc, LR_CREATEDIBSECTION); if (hBitmap) { pv = Value::CreateGraphic(hBitmap, GRAPHIC_AlphaConstPerPix); if (pv) { pe->SetValue (Element::ContentProp, PI_Local, pv); pv->Release (); } else { DeleteObject(hBitmap); TraceMsg (TF_ERROR, "CDUIView::_BuildSection: CreateGraphic for the bitmap failed."); } } else { TraceMsg (TF_ERROR, "CDUIView::_BuildSection: DUILoadBitmap failed."); } } else { TraceMsg (TF_ERROR, "CDUIView::_BuildSection: FindDescendent for the bitmap failed."); } } if (idWatermarkDesc) { HINSTANCE hinstTheme = _GetThemeHinst(); pe = peSection->FindDescendent (Expando::idWatermark); if (pe) { // Note: in Classic mode, we don't want the watermarks, so this function // will return NULL hBitmap = DUILoadBitmap(hinstTheme, idWatermarkDesc, LR_CREATEDIBSECTION); if (hBitmap) { pv = Value::CreateGraphic(hBitmap, GRAPHIC_NoBlend); if (pv) { pe->SetValue (Element::ContentProp, PI_Local, pv); pv->Release (); } else { DeleteObject(hBitmap); TraceMsg (TF_ERROR, "CDUIView::_BuildSection: CreateGraphic for the watermark failed."); } } } else { TraceMsg (TF_ERROR, "CDUIView::_BuildSection: FindDescendent for the watermark failed."); } } // Set the style sheet if specified if (pvSectionSheet) { peSection->SetValue (Element::SheetProp, PI_Local, pvSectionSheet); } // Set the expanded state. By default, it is expanded. if (!_ShowSectionExpanded(eDUISecID)) { peSection->SetSelected(FALSE); } // Add padding for the icon if appropriate. Note, this has to happen // after the style sheet is applied if (idBitmapDesc) { Element* pe = peSection->FindDescendent(StrToID(L"header")); if (pe) { Value* pvValue; const RECT * prect; prect = pe->GetPadding (&pvValue); if (prect) { pe->SetPadding ((prect->left + 20), prect->top, prect->right, prect->bottom); pvValue->Release(); } } } // Return the task list element pointer *pTaskList = peSection->FindDescendent (Expando::idTaskList); if (*pTaskList) { hr = S_OK; } else { TraceMsg (TF_ERROR, "CDUIView::_BuildSection: Failed to find task list element"); hr = E_FAIL; } return hr; } // Adds the action tasks to the task list // // peTaskList - Parent element // penum - enumeration interface // pvTaskSheet - Style sheet HRESULT CDUIView::_AddActionTasks(Expando* peExpando, Element* peTaskList, IEnumUICommand* penum, Value* pvTaskSheet, BOOL bIntroAdded) { IUICommand* puiCommand; BOOL fShow = bIntroAdded; while (S_OK==penum->Next(1, &puiCommand, NULL)) { UISTATE uis; HRESULT hr = puiCommand->get_State(_pshlItems, FALSE, &uis); // Don't do it if it's going to take long, instead, returns E_PENDING if (SUCCEEDED(hr) && (uis==UIS_ENABLED)) { Element *pe; HRESULT hr = ActionTask::Create(0, puiCommand, _pshlItems, this, _pDefView, &pe); if (SUCCEEDED(hr)) { if (pvTaskSheet) { pe->SetValue(Element::SheetProp, PI_Local, pvTaskSheet); } peTaskList->Add(pe); fShow = TRUE; } } else if (hr == E_PENDING) { IRunnableTask *pTask; if (SUCCEEDED(CGetCommandStateTask_Create(_pDefView, puiCommand, _pshlItems, &pTask))) { _pDefView->_AddTask(pTask, TOID_DVGetCommandState, 0, TASK_PRIORITY_GETSTATE, ADDTASK_ATEND); pTask->Release(); } } puiCommand->Release(); } penum->Reset(); peExpando->ShowExpando(fShow); return S_OK; } // Adds the destination tasks to the task list // // peTaskList - Parent element // penum - enumerator of pidls to display // pvTaskSheet - Style sheet HRESULT CDUIView::_AddDestinationTasks(Element* peTaskList, IEnumIDList* penum, Value* pvTaskSheet) { HRESULT hr = S_OK; LPITEMIDLIST pidl; while (S_OK==penum->Next(1, &pidl, NULL)) { Element *pe; hr = DestinationTask::Create (0, pidl, this, _pDefView, &pe); if (SUCCEEDED(hr)) { if (pvTaskSheet) { pe->SetValue(Element::SheetProp, PI_Local, pvTaskSheet); } peTaskList->Add(pe); } ILFree(pidl); } penum->Reset(); return hr; } // // Purpose: Adds the DetailsSectionInfo // HRESULT CDUIView::_AddDetailsSectionInfo() { IShellItemArray *psiShellItems = _pshlItems; if (!psiShellItems && _pDefView) { psiShellItems = _pDefView->_GetFolderAsShellItemArray(); } //TODO: background thread! Element* pElement; HRESULT hr = CNameSpaceItemInfoList::Create(this, _pvDetailsSheet,psiShellItems, &pElement); if (pElement) { hr = _peDetailsInfoArea->Add(pElement); } return hr; } // Navigates to the destination pidl // // pidl - destination HRESULT CDUIView::NavigateToDestination(LPCITEMIDLIST pidl) { LPITEMIDLIST pidlClone = ILClone(pidl); if (pidlClone) { UINT wFlags = (SBSP_DEFBROWSER | SBSP_ABSOLUTE); // mimic "new window" behavior if (0 > GetKeyState(VK_SHIFT)) { wFlags |= SBSP_NEWBROWSER; } PostMessage(_hWnd, WM_NAVIGATETOPIDL, (WPARAM)wFlags, (LPARAM)pidlClone); } return S_OK; } // Sends a delay navigation command to the view window. This delay allows // double-clicks to be interpretted as a single click. This prevents // double navigations usually causing the user to end up with two "things" // instead of just one. // // Also by doing this, the issue of the 2nd click causing the old window to // get activation is handled. The user is expecting the new window to pop // up in front of the old window. But, because the user double-clicked, // the old window would get reactivated and the new window would end up // behind the current window. See WM_USER_DELAY_NAVIGATION in HWNDView (below) // for more details. // // psiItemArray - the shell item to navigate. Can be NULL. // puiCommand - the command object to send the navigation to. HRESULT CDUIView::DelayedNavigation(IShellItemArray *psiItemArray, IUICommand *puiCommand) { SendMessage(_phe->GetHWND(), WM_USER_DELAY_NAVIGATION, (WPARAM) psiItemArray, (LPARAM) puiCommand); return S_OK; } // Builds the task list area // // pParser - Parsing instance HRESULT CDUIView::_BuildTaskList(Parser* pParser) { HRESULT hr = S_OK; // Locate section list element Element* peSectionList = _phe->FindDescendent (StrToID(L"sectionlist")); if (!peSectionList) { TraceMsg (TF_ERROR, "CDUIView::_BuildTaskList: Failed to find section list element"); return E_FAIL; } if (SFVMWVF_ENUMTASKS & _pDefView->_wvContent.dwFlags) { if (_bInitialized) { // // The 'non-standard' task list is the type who's contents // are dynamically enumerated by the folder view. // In the case of Control Panel, items in this content appear // conditionally based upon many factors, one being the categorization // of applets. In order for the content to be correct, categorization // must be correct which means that all folder items are known. // To avoid multiple repaints of the task lists, we defer creation // of the task lists until AFTER the initial creation of the view. // Once all folder items have been enumerated, the webview content // is refreshed in response to a 'contents changed' notification from // defview. It is during this update that we pass through this code // section and build the task list. // _ClearNonStdTaskSections(); hr = _GetNonStdTaskSectionsFromViewCB(); if (SUCCEEDED(hr) && NULL != _hdsaNonStdTaskSections) { hr = _BuildNonStandardTaskList(pParser, peSectionList, _hdsaNonStdTaskSections); } } } else { hr = _BuildStandardTaskList(pParser, peSectionList); } return THR(hr); } // // Builds the task list by requesting task section information // from the view callback using an enumeration mechanism. // // // ISSUE-2001/01/03-BrianAu Review // // Review this with MikeSh and EricFlo. // I think we should build this generic mechanism then implement the // 'standard' webview code in terms of this generic mechanism. // Would be best to replace the SFVM_ENUMWEBVIEWTASKS callback message // with a message that receives a COM enumerator. // // I like the idea. We replace SFVMWVF_SPECIALTASK with an LPCSTR to the theme identifier. // We can put a SFVM_GETWEBVIEWTASKS to SFVM_ENUMWEBVIEWTASKS layer in for us too. // HRESULT CDUIView::_BuildNonStandardTaskList(Parser *pParser, Element *peSectionList, HDSA hdsaSections) { Value* pvMainSectionSheet = NULL; Value *pvMainTaskSheet = NULL; Value* pvStdSectionSheet = NULL; Value* pvStdTaskSheet = NULL; HRESULT hr = S_OK; ASSERT(NULL != hdsaSections); ASSERT(NULL != pParser); ASSERT(NULL != peSectionList); const int cSections = DSA_GetItemCount(hdsaSections); for (int i = 0; i < cSections; i++) { SFVM_WEBVIEW_ENUMTASKSECTION_DATA *pSection = (SFVM_WEBVIEW_ENUMTASKSECTION_DATA *)DSA_GetItemPtr(hdsaSections, i); ASSERT(NULL != pSection); const BOOL bMainSection = (0 != (SFVMWVF_SPECIALTASK & pSection->dwFlags)); Value *pvSectionSheet = NULL; Value *pvTaskSheet = NULL; DUISEC eDUISecID; if (bMainSection) { if (NULL == pvMainSectionSheet) { pvMainSectionSheet = pParser->GetSheet(L"mainsectionss"); } if (NULL == pvMainTaskSheet) { pvMainTaskSheet = pParser->GetSheet(L"mainsectiontaskss"); } pvSectionSheet = pvMainSectionSheet; pvTaskSheet = pvMainTaskSheet; eDUISecID = DUISEC_SPECIALTASKS; } else { if (NULL == pvStdSectionSheet) { pvStdSectionSheet = pParser->GetSheet(L"sectionss"); } if (NULL == pvStdTaskSheet) { pvStdTaskSheet = pParser->GetSheet(L"sectiontaskss"); } pvSectionSheet = pvStdSectionSheet; pvTaskSheet = pvStdTaskSheet; eDUISecID = DUISEC_FILETASKS; } ASSERT(NULL != pvSectionSheet); Expando *peSection; Element *peTaskList; hr = _BuildSection(peSectionList, bMainSection, pSection->pHeader, pSection->idBitmap, pSection->idWatermark, pvSectionSheet, pParser, eDUISecID, &peSection, &peTaskList); if (SUCCEEDED(hr)) { hr = _AddActionTasks(peSection, peTaskList, pSection->penumTasks, pvTaskSheet, FALSE); } } if (pvMainSectionSheet) { pvMainSectionSheet->Release(); } if (pvMainTaskSheet) { pvMainTaskSheet->Release(); } if (pvStdSectionSheet) { pvStdSectionSheet->Release(); } if (pvStdTaskSheet) { pvStdTaskSheet->Release(); } return THR(hr); } HRESULT CDUIView::_GetIntroTextElement(Element** ppeIntroText) { if (SHRegGetBoolUSValue(REGSTR_PATH_EXPLORER, TEXT("ShowWebViewIntroText"), FALSE, FALSE)) { if (!_bstrIntroText) { WCHAR wszIntroText[INFOTIPSIZE]; if (_bBarrierShown) { LoadString(HINST_THISDLL, IDS_INTRO_BARRICADED, wszIntroText, ARRAYSIZE(wszIntroText)); } else if (!_pDefView->_pshf2Parent || FAILED(GetStringProperty(_pDefView->_pshf2Parent, _pDefView->_pidlRelative, &SCID_FolderIntroText, wszIntroText, ARRAYSIZE(wszIntroText)))) { wszIntroText[0] = L'\0'; } _bstrIntroText = SysAllocString(wszIntroText); } } HRESULT hr = E_FAIL; if (_bstrIntroText && _bstrIntroText[0]) { hr = CNameSpaceItemInfo::Create(_bstrIntroText, ppeIntroText); if (SUCCEEDED(hr)) { if (_pvDetailsSheet) { (*ppeIntroText)->SetValue(Element::SheetProp, PI_Local, _pvDetailsSheet); } } } return hr; } HRESULT CDUIView::_BuildStandardTaskList(Parser *pParser, Element *peSectionList) { Element* peTaskList; Value* pvSectionSheet = NULL; Value* pvTaskSheet = NULL; Value* pvDetailsSheet = NULL; HRESULT hr = S_OK; Element* peIntroText; if (FAILED(_GetIntroTextElement(&peIntroText))) { peIntroText = NULL; } // // Special Tasks section is optional (main section) // if (_pDefView->_wvContent.pSpecialTaskHeader) { pvSectionSheet = pParser->GetSheet(L"mainsectionss"); int idBitmap = 0; int idWatermark = 0; const WVTHEME* pThemeInfo = GetThemeInfo(); if (pThemeInfo) { idBitmap = pThemeInfo->idSpecialSectionIcon; idWatermark = pThemeInfo->idSpecialSectionWatermark; } // TODO: get special section open/closed state from the per-user-per-pidl property bag hr = _BuildSection( peSectionList, TRUE, _pDefView->_wvContent.pSpecialTaskHeader, idBitmap, idWatermark, pvSectionSheet, pParser, DUISEC_SPECIALTASKS, &_peSpecialSection, &peTaskList); if (SUCCEEDED(hr)) { BOOL bIntroTextAdded = FALSE; _peSpecialTaskList = peTaskList; // Add the tasks + style sheet _pvSpecialTaskSheet = pParser->GetSheet(L"mainsectiontaskss"); if (peIntroText) { if (SUCCEEDED(_peSpecialTaskList->Add(peIntroText))) { bIntroTextAdded = TRUE; peIntroText = NULL; } } _AddActionTasks(_peSpecialSection, _peSpecialTaskList, _pDefView->_wvTasks.penumSpecialTasks, _pvSpecialTaskSheet, bIntroTextAdded); } if (pvSectionSheet) pvSectionSheet->Release(); } // Get the style sheets for remaining standard sections pvSectionSheet = pParser->GetSheet (L"sectionss"); pvTaskSheet = pParser->GetSheet (L"sectiontaskss"); // File tasks section (standard section) Not shown if the barricade is shown. if (!_bBarrierShown) { if (_pDefView->_wvContent.pFolderTaskHeader) { // TODO: get folder section open/closed state from the per-user-per-pidl property bag hr = _BuildSection( peSectionList, FALSE, _pDefView->_wvContent.pFolderTaskHeader, 0, 0, pvSectionSheet, pParser, DUISEC_FILETASKS, &_peFolderSection, &peTaskList); if (SUCCEEDED(hr)) { BOOL bIntroTextAdded = FALSE; _peFolderTaskList = peTaskList; _pvFolderTaskSheet = pvTaskSheet; if (_pvFolderTaskSheet) _pvFolderTaskSheet->AddRef(); if (peIntroText) { if (SUCCEEDED(_peFolderTaskList->Add(peIntroText))) { bIntroTextAdded = TRUE; peIntroText = NULL; } } _AddActionTasks(_peFolderSection, _peFolderTaskList, _pDefView->_wvTasks.penumFolderTasks, _pvFolderTaskSheet, bIntroTextAdded); } } } // Other places tasks section (standard section) if (_pDefView->_pOtherPlacesHeader) { // TODO: get OtherPlaces section open/closed state from the per-user-per-pidl property bag hr = _BuildSection( peSectionList, FALSE, _pDefView->_pOtherPlacesHeader, 0, 0, pvSectionSheet, pParser, DUISEC_OTHERPLACESTASKS, NULL, &peTaskList); if (SUCCEEDED(hr)) { _AddDestinationTasks(peTaskList, _pDefView->_wvContent.penumOtherPlaces, pvTaskSheet); } } // Details tasks section (standard section) if (_pDefView->_pDetailsHeader) { // TODO: get Details section open/closed state from the per-user-per-pidl property bag hr = _BuildSection( peSectionList, FALSE, _pDefView->_pDetailsHeader, 0, 0, pvSectionSheet, pParser, DUISEC_DETAILSTASKS, &_peDetailsSection, &_peDetailsInfoArea); if (SUCCEEDED(hr)) { _AddDetailsSectionInfo(); } } if (peIntroText) { peIntroText->Destroy(); } if (pvTaskSheet) { pvTaskSheet->Release(); } if (pvSectionSheet) { pvSectionSheet->Release(); } return hr; } BOOL CDUIView::_ShowSectionExpanded(DUISEC eDUISecID) { const struct DUISEC_ATTRIBUTES *pAttrib = _GetSectionAttributes(eDUISecID); BOOL bDefault; BOOL bShow; if (eDUISecID == DUISEC_DETAILSTASKS) bDefault = ((_pDefView->_wvLayout.dwLayout & SFVMWVL_ORDINAL_MASK) == SFVMWVL_DETAILS); else bDefault = pAttrib->_bExpandedDefault; if (_ppbShellFolders) bShow = SHPropertyBag_ReadBOOLDefRet(_ppbShellFolders, pAttrib->_pszExpandedPropName, bDefault); else bShow = bDefault; return bShow; } const struct DUISEC_ATTRIBUTES *CDUIView::_GetSectionAttributes(DUISEC eDUISecID) { static const size_t nSections = ARRAYSIZE(c_DUISectionAttributes); size_t iSection; // Determine attributes of DUISEC we're interested in. for (iSection = 0; iSection < nSections; iSection++) if (c_DUISectionAttributes[iSection]._eDUISecID == eDUISecID) return &c_DUISectionAttributes[iSection]; ASSERT(FALSE); // Game over -- insert quarters! return NULL; // AV! } HRESULT SetDescendentString(Element* pe, LPWSTR pszID, UINT idString) { HRESULT hr; Element* peChild = pe->FindDescendent(StrToID(pszID)); if (peChild) { TCHAR szString [INFOTIPSIZE]; LoadString(HINST_THISDLL, idString, szString, ARRAYSIZE(szString)); hr = peChild->SetContentString(szString); } else { hr = E_FAIL; } return hr; } // Parses the .ui file and initializes the DUI elements // // pUIFile - Pointer to the UI file in memory // iCharCount - Number of characters in the ui file // bDisplayBarrier - Display soft barrier over listview // punkPreview - IUnknown interface for the preview control HRESULT CDUIView::_InitializeElements (char * pUIFile, int iCharCount, BOOL bDisplayBarrier, IUnknown * punkPreview) { Parser* pParser; Element* pe; RECT rc; HANDLE arH[2]; // Parse the UI file arH[0] = _GetThemeHinst(); arH[1] = _hinstScrollbarTheme; HRESULT hr = Parser::Create(pUIFile, iCharCount, arH, UIFileParseError, &pParser); if (FAILED(hr)) { TraceMsg (TF_ERROR, "CDUIView::_InitializeElements: Parser::Create failed with 0x%x", hr); return hr; } if (pParser->WasParseError()) { TraceMsg (TF_ERROR, "CDUIView::_InitializeElements: WasParseError is TRUE"); pParser->Destroy(); return E_FAIL; } // Create the host element hr = HWNDView::Create(_hWnd, false, 0, this, _pDefView, (Element**)&_phe); // _phe is owned by _hWnd if (FAILED(hr)) { TraceMsg (TF_ERROR, "CDUIView::_InitializeElements: HWNDElement::Create failed with 0x%x", hr); pParser->Destroy(); return hr; } // We need to ensure that the root item will not paint on WM_ERASEBCKGRND, so here we remove the default brush // - Turn off the (default) background fill HGADGET hgadRoot = _phe->GetDisplayNode(); ASSERTMSG(hgadRoot != NULL, "Must have a peer Gadget"); SetGadgetFillI(hgadRoot, NULL, BLEND_OPAQUE, 0, 0); // We need to ensure that the root item will not paint on WM_ERASEBCKGRND, so make it transparent _phe->SetBackgroundColor(ARGB(0, 0, 0, 0)); // Size the host element to match the size of the host window GetClientRect (_hWnd, &rc); _phe->SetWidth(rc.right - rc.left); _phe->SetHeight(rc.bottom - rc.top); // Create the main element in the ui file hr = pParser->CreateElement(L"main", _phe, &pe); if (FAILED(hr)) { TraceMsg (TF_ERROR, "CDUIView::_InitializeElements: pParser->CreateElement failed with 0x%x", hr); pParser->Destroy(); return hr; } // Cache the element pointers to the 3 main areas: taskpane, clientviewhost, blockade _peTaskPane = _phe->FindDescendent(StrToID(L"scroller")); _peClientViewHost = _phe->FindDescendent(StrToID(L"clientviewhost")); _peBarrier = _phe->FindDescendent(StrToID(L"blockade")); // Cache style sheets for the items we create directly (that don't inherit from their immediate parents) _pvDetailsSheet = pParser->GetSheet(L"NameSpaceItemInfoList"); if (_peTaskPane && _peClientViewHost && _peBarrier && _pvDetailsSheet) { // Double buffered items need to be opaque _peTaskPane->SetBackgroundColor(ARGB(255, 0, 0, 0)); _peTaskPane->DoubleBuffered(true); // Create the real listview element hr = DUIListView::Create(AE_MouseAndKeyboard, _pDefView->_hwndListview, (Element **)&_peListView); if (SUCCEEDED(hr)) { _peListView->SetLayoutPos(BLP_Client); _peListView->SetID(L"listview"); hr = _peClientViewHost->Add(_peListView); if (SUCCEEDED(hr)) { _pDefView->_AutoAutoArrange(0); } else { TraceMsg(TF_ERROR, "CDUIView::_InitializeElements: DUIListView::Could not add listview with 0x%x", hr); _peListView->Destroy(); _peListView = NULL; } } else { TraceMsg(TF_ERROR, "CDUIView::_InitializeElements: Could not create listview element"); } } else { TraceMsg(TF_ERROR, "CDUIView::_InitializeElements: Could not find main element"); hr = E_FAIL; } if (FAILED(hr)) { // we gotta have the listview or you get no webview... pParser->Destroy(); return hr; } // Build the preview control if appropriate _ManagePreview(punkPreview); _BuildSoftBarrier(); _SwitchToBarrier(bDisplayBarrier); // Create an interface to the property bag for this class of IShellFolder. _InitializeShellFolderPropertyBag(); // Build the task list area hr = _BuildTaskList (pParser); _fHideTasklist = (S_OK == IUnknown_Exec(_pDefView->_psb, &CGID_ShellDocView, SHDVID_ISEXPLORERBARVISIBLE, 0, NULL, NULL)); pParser->Destroy(); return hr; } void CDUIView::_InitializeShellFolderPropertyBag() { CLSID clsid; if (SUCCEEDED(IUnknown_GetClassID(_pDefView->_pshf, &clsid))) { WCHAR szSubKey[] = L"DUIBags\\ShellFolders\\{00000000-0000-0000-0000-000000000000}"; if (SHStringFromGUID(clsid, &szSubKey[lstrlen(szSubKey) + 1 - GUIDSTR_MAX], GUIDSTR_MAX) == GUIDSTR_MAX) { HKEY hk = SHGetShellKey(SKPATH_SHELLNOROAM, szSubKey, TRUE); if (hk) { SHCreatePropertyBagOnRegKey(hk, NULL, STGM_READWRITE | STGM_SHARE_DENY_NONE, IID_PPV_ARG(IPropertyBag, &_ppbShellFolders)); RegCloseKey(hk); } } } } HRESULT CDUIView::_BuildSoftBarrier(void) { HRESULT hr = S_OK; // Build the soft barrier if the view wants one if (_pDefView->_wvContent.dwFlags & SFVMWVF_BARRICADE) { // Allow the view to give us a barrier implementation Element* peBarricade = NULL; _pDefView->CallCB(SFVM_GETWEBVIEWBARRICADE, 0, (LPARAM)&peBarricade); if (peBarricade) { Element *pe = _peBarrier->GetParent(); hr = pe->Add(peBarricade); if (SUCCEEDED(hr)) { _peBarrier->Destroy(); _peBarrier = peBarricade; } else { peBarricade->Destroy(); } } else { // Load the bitmap Element *peClient = _peBarrier->FindDescendent(StrToID(L"blockadeclient")); if (peClient) { HBITMAP hBitmap = DUILoadBitmap(_GetThemeHinst(), IDB_BLOCKADE_WATERMARK, LR_CREATEDIBSECTION); if (hBitmap) { BITMAP bmp; if (GetObject (hBitmap, sizeof(bmp), &bmp)) { BYTE dBlendMode = GRAPHIC_TransColor; if (bmp.bmBitsPixel == 32) { dBlendMode = GRAPHIC_AlphaConstPerPix; } Value *pVal = Value::CreateGraphic(hBitmap, dBlendMode, 255); if (pVal) { peClient->SetValue(Element::ContentProp, PI_Local, pVal); pVal->Release(); } } } } // Give the view the standard barrier hr = SetDescendentString(_peBarrier, L"blockadetitle", IDS_BLOCKADETITLE); if (SUCCEEDED(hr)) { hr = SetDescendentString(_peBarrier, L"blockademessage", IDS_BLOCKADEMESSAGE); // "clear barrier" button (failure of "clear barrier" button setup is not fatal) Element *peButton = _peBarrier->FindDescendent(StrToID(L"blockadeclearbutton")); if (peButton) { Element *peButtonText = peButton->FindDescendent(StrToID(L"blockadecleartext")); if (peButtonText) { WCHAR wsz[INFOTIPSIZE]; if (LoadString(HINST_THISDLL, IDS_TASK_DEFVIEW_VIEWCONTENTS_FOLDER, wsz, ARRAYSIZE(wsz))) { Value *pv = Value::CreateString(wsz, NULL); if (pv) { if (SUCCEEDED(peButtonText->SetValue(Element::ContentProp, PI_Local, pv))) { peButton->SetAccessible(true); peButton->SetAccName(wsz); peButton->SetAccRole(ROLE_SYSTEM_PUSHBUTTON); if (LoadString(HINST_THISDLL, IDS_LINKWINDOW_DEFAULTACTION, wsz, ARRAYSIZE(wsz))) { peButton->SetAccDefAction(wsz); } } pv->Release(); } } } } } } // Double buffered items need to be opaque _phe->SetBackgroundColor(ARGB(255, 0, 0, 0)); _phe->DoubleBuffered(true); // We couldn't create the barrier? don't use it then... if (FAILED(hr)) { _peBarrier->Destroy(); _peBarrier = NULL; } } return hr; } // Switches to / from the soft barrier and the listview HRESULT CDUIView::_SwitchToBarrier (BOOL bDisplayBarrier) { if (bDisplayBarrier && !_peBarrier) bDisplayBarrier = FALSE; Element *peClearButton = _peBarrier ? _peBarrier->FindDescendent(StrToID(L"blockadeclearbutton")) : NULL; if (peClearButton) { // Note: // This is required to prevent the "clear barrier" button from being // accessed via our accessibility interface when the barrier is hidden. peClearButton->SetAccessible(bDisplayBarrier == TRUE); } if (bDisplayBarrier) { _peClientViewHost->SetVisible(FALSE); _peBarrier->SetVisible(TRUE); } else { if (_peBarrier) { _peBarrier->SetVisible(FALSE); } _peClientViewHost->SetVisible(TRUE); _pDefView->_AutoAutoArrange(0); } _bBarrierShown = bDisplayBarrier; return S_OK; } // Controls the display of the soft barrier HRESULT CDUIView::EnableBarrier (BOOL bDisplayBarrier) { if (_bBarrierShown != bDisplayBarrier) { DisableAnimations(); Element::StartDefer (); _SwitchToBarrier (bDisplayBarrier); PostMessage (_hWnd, WM_REFRESHVIEW, 0, 0); Element::EndDefer (); EnableAnimations(); } return S_OK; } // Creates / destroys the preview control HRESULT CDUIView::_ManagePreview (IUnknown * punkPreview) { HRESULT hr = S_OK; if ((_pePreview && punkPreview) || (!_pePreview && !punkPreview)) { return S_OK; } if (punkPreview) { // Create the DUI element that can host an active x control hr = DUIAxHost::Create (&_pePreview); if (SUCCEEDED(hr)) { _pePreview->SetLayoutPos (BLP_Top); _pePreview->SetID (L"preview"); _pePreview->SetHeight(_phe->GetHeight()); _pePreview->SetAccessible(TRUE); // The order of the next 4 calls is very important! // // Initialize atl so the window class is registered. // Then call the Add method. This will cause CreateHWND to be // called. Then site it so when we call AttachControl to // put the preview control in (this requires the hwnd to exist already) // it will be parented properly AtlAxWinInit(); hr = _peClientViewHost->Add (_pePreview); if (SUCCEEDED(hr)) { _pePreview->SetSite(SAFECAST(_pDefView, IShellView2*)); hr = _pePreview->AttachControl(punkPreview); if (SUCCEEDED(hr)) { // Double buffered items need to be opaque _phe->SetBackgroundColor(ARGB(255, 0, 0, 0)); _phe->DoubleBuffered(true); if (_peListView) { // Since the preview control is displayed, the listview // will be sized to 1 row in height. Determine the height // of the listview now so we can size the preview control // appropriate plus take care of the sizing in the SetSize // method later DWORD dwItemSpace = ListView_GetItemSpacing (_peListView->GetHWND(), FALSE); _iListViewHeight = (int)HIWORD(dwItemSpace) + GetSystemMetrics (SM_CYHSCROLL) + 4; if (_phe->GetHeight() > _iListViewHeight) { _pePreview->SetHeight(_phe->GetHeight() - _iListViewHeight); } else { _pePreview->SetHeight(0); } } } } if (FAILED(hr)) { _pePreview->Destroy(); _pePreview = NULL; } } else { TraceMsg (TF_ERROR, "CDUIView::_ManagePreview: DUIAxHost::Create failed with 0x%x", hr); } } else { _pePreview->Destroy(); _pePreview = NULL; } return S_OK; } // Controls the display of the preview control HRESULT CDUIView::EnablePreview(IUnknown * punkPreview) { DisableAnimations(); Element::StartDefer (); _ManagePreview (punkPreview); Element::EndDefer (); EnableAnimations(); return S_OK; } // Refreshes the view HRESULT CDUIView::Refresh(void) { Element *pe; Parser* pParser = NULL; Value* pvSheet = NULL; HANDLE arH[2]; ManageAnimations(FALSE); DisableAnimations(); Element::StartDefer(); _fLoadedTheme = FALSE; // try to re-load the theme file _iTaskPaneWidth = ScaleSizeBasedUponLocalization(_iOriginalTaskPaneWidth); // Setting the task pane visibility to the current state will // cause it to re-initialize the task pane width appropriately SetTaskPaneVisibility(!_bHideTaskPaneAlways); // Dynamically build the .ui file for this view int iCharCount; char *pUIFile = NULL; HRESULT hr = _BuildUIFile(&pUIFile, &iCharCount); if (FAILED(hr)) { TraceMsg (TF_ERROR, "CDUIView::Refresh: _BuildUIFile failed with 0x%x", hr); goto Exit; } // Parse the UI file arH[0] = _GetThemeHinst(); arH[1] = _hinstScrollbarTheme; hr = Parser::Create(pUIFile, iCharCount, arH, UIFileParseError, &pParser); if (FAILED(hr)) { TraceMsg (TF_ERROR, "CDUIView::Refresh: Parser::Create failed with 0x%x", hr); goto Exit; } if (pParser->WasParseError()) { TraceMsg (TF_ERROR, "CDUIView::Refresh: WasParseError is TRUE"); hr = E_FAIL; goto Exit; } // Find the section list element pe = _phe->FindDescendent (StrToID(L"sectionlist")); if (!pe) { TraceMsg (TF_ERROR, "CDUIView::Refresh: Failed to find section list element"); hr = E_FAIL; goto Exit; } // Free all the pointers we have to elements inside of the sectionlist ATOMICRELEASE(_pshlItems); ATOMICRELEASE(_pvSpecialTaskSheet); ATOMICRELEASE(_pvFolderTaskSheet); ATOMICRELEASE(_peDetailsInfoArea); ATOMICRELEASE(_pvDetailsSheet); _peSpecialSection = NULL; _peSpecialTaskList = NULL; _peFolderSection = NULL; _peFolderTaskList = NULL; _peDetailsSection = NULL; // Destroy the section list pe->DestroyAll(); // Take the style sheets from the new .UI file and put them on the running objects... // pe = _phe->FindDescendent (StrToID(L"main")); if (pe) { // Query for the main style sheet and set it pvSheet = pParser->GetSheet (L"main"); if (pvSheet) { pe->SetValue(Element::SheetProp, PI_Local, pvSheet); pvSheet->Release(); pvSheet = NULL; } } pe = _phe->FindDescendent (StrToID(L"scroller")); if (pe) { // Query for the taskpane style sheet and set it pvSheet = pParser->GetSheet (L"taskpane"); if (pvSheet) { pe->SetValue(Element::SheetProp, PI_Local, pvSheet); pvSheet->Release(); pvSheet = NULL; } } _pvDetailsSheet = pParser->GetSheet(L"NameSpaceItemInfoList"); // Rebuild the soft barrier if one exists. _BuildSoftBarrier(); // Build the task list area again _BuildTaskList (pParser); Exit: Element::EndDefer(); EnableAnimations(); // When turning off the barricade the icons in listview // are arranged as if duiview isn't present. Call _AutoAutoArrange // to reposition the icons correctly. _pDefView->_AutoAutoArrange(0); if (pParser) { pParser->Destroy(); } if (pUIFile) { LocalFree(pUIFile); } return hr; } // Resizes the host element when the frame size changes // // rc - size of frame // HRESULT CDUIView::SetSize(RECT * rc) { _fHideTasklist = (S_OK == IUnknown_Exec(_pDefView->_psb, &CGID_ShellDocView, SHDVID_ISEXPLORERBARVISIBLE, 0, NULL, NULL)); SetWindowPos(_hWnd, NULL, rc->left, rc->top, rc->right - rc->left, rc->bottom - rc->top, SWP_NOZORDER | SWP_NOACTIVATE); return S_OK; } HRESULT CDUIView::_OnResize(long lWidth, long lHeight) { DisableAnimations(); Element::StartDefer(); _phe->SetWidth(lWidth); _phe->SetHeight(lHeight); if (_pePreview) { if (_phe->GetHeight() > _iListViewHeight) { _pePreview->SetHeight(_phe->GetHeight() - _iListViewHeight); } else { _pePreview->SetHeight(0); } } // Hide task pane if task area is greater than 50% of the window size // The show/hide state of the tasklist pane can change for: // 1) we're told to always hide // 2) an explorer bar is showing // 3) the window is too narrow. // if (_peTaskPane) { if (_bHideTaskPaneAlways || _fHideTasklist || ((lWidth / 2) < _iTaskPaneWidth)) { _peTaskPane->SetWidth(0); } else if (_peTaskPane->GetWidth() == 0) { _peTaskPane->SetWidth(_iTaskPaneWidth); } } Element::EndDefer(); EnableAnimations(); return S_OK; } HRESULT CDUIView::SetTaskPaneVisibility(BOOL bShow) { _bHideTaskPaneAlways = !bShow; return _OnResize(_phe->GetWidth(), _phe->GetHeight()); } // Description: // Calculates the bounding rectangle of the infotip hotspot for // the specified element. The bounding rectangle's coordinates // are relative to the specified element's root element. // void CDUIView::CalculateInfotipRect(Element *pe, RECT *pRect) { ASSERT(pe); ASSERT(pRect); // Calculate location. const POINT ptLocation = { 0, 0 }; POINT ptLocationRelativeToRoot; pe->GetRoot()->MapElementPoint(pe, &ptLocation, &ptLocationRelativeToRoot); pRect->left = ptLocationRelativeToRoot.x; pRect->top = ptLocationRelativeToRoot.y; // Calculate size. Value *pvExtent; const SIZE *psizeExtent = pe->GetExtent(&pvExtent); pRect->right = pRect->left + psizeExtent->cx; pRect->bottom = pRect->top + psizeExtent->cy; pvExtent->Release(); // Sanity check. ASSERT(pRect->right > pRect->left); ASSERT(pRect->bottom > pRect->top); } HRESULT CDUIView::InitializeThumbnail(WNDPROC pfnWndProc) { HRESULT hr = E_FAIL; if (!_spThumbnailExtractor2) { if (SUCCEEDED(CoCreateInstance(CLSID_Thumbnail, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IThumbnail2, &_spThumbnailExtractor2)))) { _hwndMsgThumbExtract = SHCreateWorkerWindowW(pfnWndProc, NULL, 0, WS_POPUP, NULL, this); if (_hwndMsgThumbExtract) { // Set defview as the site for the thumbnail extractor so that // it can QueryService defview for IShellTaskScheduler IUnknown_SetSite(_spThumbnailExtractor2, SAFECAST(_pDefView, IShellView2*)); // Tell the image extractor to post WM_HTML_BITMAP to _hwndMsgThumbExtract // The lParam will be the HBITMAP of the extracted image. _spThumbnailExtractor2->Init(_hwndMsgThumbExtract, WM_HTML_BITMAP); } } } return (_spThumbnailExtractor2 && _hwndMsgThumbExtract) ? S_OK : E_FAIL; } // if pCheck != NULL, check if the current window ptr == pCheck before setting it to p HRESULT CDUIView::SetThumbnailMsgWindowPtr(void* p, void* pCheck) { if (_hwndMsgThumbExtract) { if (pCheck) { void* pCurrent = GetWindowPtr(_hwndMsgThumbExtract, 0); if (pCurrent == pCheck) { SetWindowPtr(_hwndMsgThumbExtract, 0, p); } } else { SetWindowPtr(_hwndMsgThumbExtract, 0, p); } } return S_OK; } HRESULT CDUIView::StartBitmapExtraction(LPCITEMIDLIST pidl) { _dwThumbnailID++; // We are looking for a new thumbnail return _spThumbnailExtractor2 ? _spThumbnailExtractor2->GetBitmapFromIDList(pidl, _dwThumbnailID, 150, 100) : E_FAIL; } HRESULT CDUIView::InitializeDetailsInfo(WNDPROC pfnWndProc) { if (!_hwndMsgInfoExtract) { _hwndMsgInfoExtract = SHCreateWorkerWindowW(pfnWndProc, NULL, 0, WS_POPUP, NULL, this); } return _hwndMsgInfoExtract ? S_OK : E_FAIL; } // if pCheck != NULL, check if the current window ptr == pCheck before setting it to p HRESULT CDUIView::SetDetailsInfoMsgWindowPtr(void* p, void* pCheck) { if (_hwndMsgInfoExtract) { if (pCheck) { void* pCurrent = GetWindowPtr(_hwndMsgInfoExtract, 0); if (pCurrent == pCheck) { SetWindowPtr(_hwndMsgInfoExtract, 0, p); } } else { SetWindowPtr(_hwndMsgInfoExtract, 0, p); } } return S_OK; } HRESULT CDUIView::StartInfoExtraction(LPCITEMIDLIST pidl) { _dwDetailsInfoID++; // We are looking for a new Details section info CDetailsSectionInfoTask *pTask; HRESULT hr = CDetailsSectionInfoTask_CreateInstance( _pDefView->_pshf, pidl, _hwndMsgInfoExtract, WM_DETAILS_INFO, _dwDetailsInfoID, &pTask); if (SUCCEEDED(hr)) { if (_pDefView->_pScheduler) { // Make sure there are no other background DetailsSectionInfo // extraction going on... _pDefView->_pScheduler->RemoveTasks(TOID_DVBackgroundDetailsSectionInfo, ITSAT_DEFAULT_LPARAM, FALSE); } hr = _pDefView->_AddTask(pTask, TOID_DVBackgroundDetailsSectionInfo, 0, TASK_PRIORITY_INFOTIP, ADDTASK_ATEND); pTask->Release(); } return hr; } VOID CDUIView::ShowDetails (BOOL fShow) { if (_peDetailsSection) { _peDetailsSection->ShowExpando (fShow); } } BOOL CDUIView::ShouldShowMiniPreview() { return !_pDefView->_IsImageMode(); } // Window procedure for host window LRESULT CALLBACK CDUIView::_DUIHostWndProc(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam) { CDUIView *pThis = (CDUIView*)GetWindowLongPtr(hWnd, GWLP_USERDATA); switch (uMessage) { case WM_NCCREATE: { LPCREATESTRUCT lpcs = (LPCREATESTRUCT)lParam; pThis = (CDUIView*)(lpcs->lpCreateParams); SetWindowLongPtr(hWnd, GWLP_USERDATA, (LONG_PTR)pThis); } break; case WM_SIZE: if (pThis && pThis->_phe) { pThis->_OnResize(LOWORD(lParam), HIWORD(lParam)); } break; case WM_SETFOCUS: // Push focus to HWNDElement (won't set gadget focus to the HWNDElement, but // will push focus to the previous gadget with focus) if (pThis) { if (pThis->_phe && pThis->_phe->GetHWND()) SetFocus(pThis->_phe->GetHWND()); } break; case WM_PALETTECHANGED: case WM_QUERYNEWPALETTE: case WM_DISPLAYCHANGE: if (pThis && pThis->_phe) { return SendMessageW(pThis->_phe->GetHWND(), uMessage, wParam, lParam); } break; case WM_DESTROY: // clear posted messages MSG msg; while (PeekMessage(&msg, hWnd, WM_NAVIGATETOPIDL, WM_NAVIGATETOPIDL, PM_REMOVE)) { // PeekMessage(hwnd) can return messages posted to CHILDREN of this hwnd... // Verify that the message was really for us. if (msg.hwnd == hWnd) { LPITEMIDLIST pidl = (LPITEMIDLIST)msg.lParam; ILFree(pidl); } } break; case WM_NAVIGATETOPIDL: { LPITEMIDLIST pidl = (LPITEMIDLIST)lParam; UINT wFlags = (UINT)wParam; pThis->_pDefView->_psb->BrowseObject(pidl, wFlags); ILFree(pidl); } break; case WM_REFRESHVIEW: { pThis->Refresh(); } break; case WM_MOUSEACTIVATE: if (pThis->_bBarrierShown) { return MA_ACTIVATE; } break; default: break; } return DefWindowProc(hWnd, uMessage, wParam, lParam); } // Updates all selection-parameterized UI // // pdo - data object representing the selection void CDUIView::_Refresh(IShellItemArray *psiItemArray, DWORD dwRefreshFlags) { //DirectUI::DisableAnimations(); Element::StartDefer(); IUnknown_Set((IUnknown **)&_pshlItems,psiItemArray); if (SFVMWVF_ENUMTASKS & _pDefView->_wvContent.dwFlags) { if (0 == (REFRESH_SELCHG & dwRefreshFlags)) { // // Only refresh if it's not a selection change. // If we refresh here, Control Panel's left-pane menus // are constantly rebuilt as the folder items selection // changes. That's really ugly. // Will this affect other folders? No, Control Panel // is currently the only folder that sets this SFVMWVF_ENUMTASKS // flag. Post WinXP if we decide to keep this webview // content in the left pane, we need to re-think how better // to handle Control Panel's special needs. // Refresh(); } } else { if (REFRESH_CONTENT & dwRefreshFlags) { _BuildSoftBarrier(); } if (REFRESH_TASKS & dwRefreshFlags) { Element* peIntroText; if (FAILED(_GetIntroTextElement(&peIntroText))) { peIntroText = NULL; } if (_peSpecialSection) { BOOL bIntroTextAdded = FALSE; _peSpecialSection->UpdateTitleUI(_pshlItems); _peSpecialTaskList->DestroyAll(); if (peIntroText) { if (SUCCEEDED(_peSpecialTaskList->Add(peIntroText))) { bIntroTextAdded = TRUE; peIntroText = NULL; } } _AddActionTasks(_peSpecialSection, _peSpecialTaskList, _pDefView->_wvTasks.penumSpecialTasks, _pvSpecialTaskSheet, bIntroTextAdded); } if (_peFolderSection) { BOOL bIntroTextAdded = FALSE; _peFolderSection->UpdateTitleUI(_pshlItems); _peFolderTaskList->DestroyAll(); if (peIntroText) { if (SUCCEEDED(_peFolderTaskList->Add(peIntroText))) { bIntroTextAdded = TRUE; peIntroText = NULL; } } _AddActionTasks(_peFolderSection, _peFolderTaskList, _pDefView->_wvTasks.penumFolderTasks, _pvFolderTaskSheet, bIntroTextAdded); } if (_peDetailsInfoArea) { const SIZE *pSize; LONG lHeight = 0; Value * pv; pSize = _peDetailsInfoArea->GetExtent(&pv); if (pSize) { _peDetailsInfoArea->SetHeight(pSize->cy); pv->Release(); } _peDetailsInfoArea->DestroyAll(); _AddDetailsSectionInfo(); } if (peIntroText) { peIntroText->Destroy(); } } } Element::EndDefer(); //DirectUI::EnableAnimations(); } void CDUIView::OnSelectionChange(IShellItemArray *psiItemArray) { _Refresh(psiItemArray, REFRESH_ALL | REFRESH_SELCHG); } void CDUIView::OnContentsChange(IShellItemArray *psiItemArray) { DWORD dwRefreshFlags = 0; if (_pDefView->_wvTasks.dwUpdateFlags & SFVMWVTSDF_CONTENTSCHANGE) { dwRefreshFlags |= REFRESH_TASKS; } if (_pDefView->_wvContent.dwFlags & SFVMWVF_CONTENTSCHANGE) { dwRefreshFlags |= REFRESH_CONTENT; } if (0 != dwRefreshFlags) { _Refresh(psiItemArray, dwRefreshFlags); } } void CDUIView::OnExpandSection(DUISEC eDUISecID, BOOL bExpanded) { if (_ppbShellFolders) { SHPropertyBag_WriteDWORD(_ppbShellFolders, _GetSectionAttributes(eDUISecID)->_pszExpandedPropName, bExpanded); } } // // ISSUE-2001/01/02-BrianAu Review // // This webview task section code may be reworked soon. // I created it to address the webview needs of Control Panel. // Following this first checkin, the webview guys (EricFlo // and MikeSh) and I will look at consolidating the generic // needs of Control Panel with the existing webview code. // // // Add a WebView task section to the list of task sections. // HRESULT CDUIView::_AddNonStdTaskSection(const SFVM_WEBVIEW_ENUMTASKSECTION_DATA *pData) { ASSERT(NULL != pData); ASSERT(!IsBadReadPtr(pData, sizeof(*pData))); HRESULT hr = E_OUTOFMEMORY; if (NULL == _hdsaNonStdTaskSections) { _hdsaNonStdTaskSections = DSA_Create(sizeof(*pData), 5); } if (NULL != _hdsaNonStdTaskSections) { if (-1 != DSA_AppendItem(_hdsaNonStdTaskSections, (void *)pData)) { ASSERT(NULL != pData->pHeader); ASSERT(NULL != pData->penumTasks); // // The list now owns a ref count on the referenced objects. // pData->pHeader->AddRef(); pData->penumTasks->AddRef(); hr = S_OK; } } return THR(hr); } void CDUIView::_ClearNonStdTaskSections(void) { if (NULL != _hdsaNonStdTaskSections) { HDSA hdsa = _hdsaNonStdTaskSections; _hdsaNonStdTaskSections = NULL; const int cItems = DSA_GetItemCount(hdsa); for (int i = 0; i < cItems; i++) { SFVM_WEBVIEW_ENUMTASKSECTION_DATA *pData = (SFVM_WEBVIEW_ENUMTASKSECTION_DATA *)DSA_GetItemPtr(hdsa, i); if (NULL != pData) { ATOMICRELEASE(pData->pHeader); ATOMICRELEASE(pData->penumTasks); } } DSA_Destroy(hdsa); } } // // Enumerate the non-standard webview task sections // from the view callback. // // ISSUE-2001/01/03-BrianAu Review // // This SFVM_ENUMWEBVIEWTASKS mechanism may be replaced // with a COM enumerator. I'll be revisiting this with // the webview guys soon. // HRESULT CDUIView::_GetNonStdTaskSectionsFromViewCB(void) { SFVM_WEBVIEW_ENUMTASKSECTION_DATA data; HRESULT hr = S_OK; do { // // Continue requesting task section information from // the callback until it sets the SFVMWVF_NOMORETASKS // flag in the data. The record with this flag set // should not contain any valid data. // ZeroMemory(&data, sizeof(data)); hr = _pDefView->CallCB(SFVM_ENUMWEBVIEWTASKS, 0, (LPARAM)&data); if (SUCCEEDED(hr)) { if (0 == (SFVMWVF_NOMORETASKS & data.dwFlags)) { hr = _AddNonStdTaskSection(&data); ASSERT(S_FALSE != hr); data.pHeader->Release(); data.penumTasks->Release(); } else { ASSERT(NULL == data.pHeader); ASSERT(NULL == data.penumTasks); hr = S_FALSE; } } } while(S_OK == hr); return THR(hr); } // Loads a bitmap based upon: // // lpBitmapID - contains the bitmap description // hInstTheme - instance handle of theme dll HBITMAP DUILoadBitmap(HINSTANCE hInstTheme, int idBitmapID, UINT uiLoadFlags) { return (HBITMAP)LoadImage(hInstTheme, MAKEINTRESOURCE(idBitmapID), IMAGE_BITMAP, 0, 0, uiLoadFlags); } // Loads an icon based upon the description. // Example: shell32,-42 // // pszIconDesc - contains the icon description // bSmall - small icon vs large icon HICON DUILoadIcon(LPCWSTR pszIconDesc, BOOL bSmall) { HICON hIcon = NULL; TCHAR szFile[MAX_PATH]; StrCpyN(szFile, pszIconDesc, ARRAYSIZE(szFile)); // the below writes this buffer int iIconID = PathParseIconLocation(szFile); if (bSmall) { PrivateExtractIcons(szFile, iIconID, 16, 16, &hIcon, NULL, 1, 0); } else { PrivateExtractIcons(szFile, iIconID, 32, 32, &hIcon, NULL, 1, 0); } return hIcon; } BOOL CDUIView::Navigate(BOOL fForward) { if (!_phe) return FALSE; return _phe->Navigate(fForward); } HRESULT CDUIView::InitializeDropTarget (LPITEMIDLIST pidl, HWND hWnd, IDropTarget **pdt) { HRESULT hr = E_FAIL; if (_pDT) { hr = _pDT->Initialize(pidl, hWnd, pdt); } return hr; } //////////////////////////////////////////////////////// // HWNDView class //////////////////////////////////////////////////////// HWNDView::HWNDView(void) : _fFocus(TRUE), _fDelayedNavigation(false), _puiDelayNavCmd(NULL), _psiDelayNavArray(NULL), _pDefView(NULL), _pDUIView(NULL) { } HWNDView::~HWNDView(void) { ATOMICRELEASE(_puiDelayNavCmd); ATOMICRELEASE(_psiDelayNavArray); ATOMICRELEASE(_pDefView); ATOMICRELEASE(_pDUIView); } HRESULT HWNDView::Create(OUT Element** ppElement) { UNREFERENCED_PARAMETER(ppElement); DUIAssertForce("Cannot instantiate an HWND host derived Element via parser. Must use substitution."); return E_NOTIMPL; } HRESULT HWNDView::Create(HWND hParent, bool fDblBuffer, UINT nCreate, CDUIView * pDUIView, CDefView *pDefView, OUT Element** ppElement) { *ppElement = NULL; HWNDView* phv = HNewAndZero(); if (!phv) return E_OUTOFMEMORY; HRESULT hr = phv->Initialize(hParent, fDblBuffer, nCreate); if (FAILED(hr)) { phv->Destroy(); return hr; } phv->SetWrapKeyboardNavigate(false); phv->SetAccessible(true); phv->SetAccRole(ROLE_SYSTEM_PANE); phv->SetAccName(L"WebView Pane"); phv->SetViewPtrs(pDUIView, pDefView); *ppElement = phv; return S_OK; } void HWNDView::SetViewPtrs (CDUIView * pDUIView, CDefView *pDefView) { pDUIView->AddRef(); _pDUIView = pDUIView; pDefView->AddRef(); _pDefView = pDefView; } #define DELAYED_NAVIGATION_TIMER_ID 1236 // random - can be moved LRESULT HWNDView::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { switch ( uMsg ) { case WM_TIMER: if (wParam == DELAYED_NAVIGATION_TIMER_ID) { KillTimer(hWnd, DELAYED_NAVIGATION_TIMER_ID); // // We have encountered some rare scenarios where _puiDelayNavCmd // can be NULL. // if (_puiDelayNavCmd) { HRESULT hr = _puiDelayNavCmd->Invoke(_psiDelayNavArray, NULL); if (FAILED(hr)) { MessageBeep(0); } } ATOMICRELEASE(_puiDelayNavCmd); ATOMICRELEASE(_psiDelayNavArray); _fDelayedNavigation = false; } break; case WM_USER_DELAY_NAVIGATION: ATOMICRELEASE(_puiDelayNavCmd); ATOMICRELEASE(_psiDelayNavArray); _puiDelayNavCmd = (IUICommand *) lParam; _puiDelayNavCmd->AddRef(); _psiDelayNavArray = (IShellItemArray *) wParam; if (NULL != _psiDelayNavArray) { _psiDelayNavArray->AddRef(); } _fDelayedNavigation = true; ::SetTimer(hWnd, DELAYED_NAVIGATION_TIMER_ID, GetDoubleClickTime(), NULL); break; case WM_MOUSEACTIVATE: if ( _fDelayedNavigation ) { // // KB: gpease 05-APR-2001 Fix for WinBug #338552 // // This prevents the re-activation of the view window after // the user clicks on a link that launches another application, // window, or CPL Applet. // return MA_NOACTIVATE; } break; // do the default wndproc case WM_MOUSEMOVE: case WM_LBUTTONDOWN: case WM_LBUTTONUP: case WM_MBUTTONDOWN: case WM_MBUTTONUP: case WM_RBUTTONDOWN: case WM_RBUTTONUP: if (_pDefView) { // Relay relevant messages to CDefView's infotip control so any // infotip tools created in the DUI view will appear/function. _pDefView->RelayInfotipMessage(hWnd, uMsg, wParam, lParam); } break; } return HWNDElement::WndProc(hWnd, uMsg, wParam, lParam); } BOOL HWNDView::Navigate(BOOL fForward) { KeyboardNavigateEvent kne; kne.uidType = Element::KeyboardNavigate; kne.iNavDir = fForward ? NAV_NEXT : NAV_PREV; if (_fFocus) // remove this check after SetGadgetFocus(NULL) is fixed. { kne.peTarget = GetKeyFocusedElement(); } else { kne.peTarget = NULL; } if (kne.peTarget) { kne.peTarget->FireEvent(&kne); _fFocus = !kne.peTarget->GetKeyFocused(); // If this is the last element in the duiview focus cycle clear focus so if // no one else grabs focus and we come back to duiview we'll restart at the // first element. // // //if (!fFocus) //{ // SetGadgetFocus(NULL); Doesn't like NULL!!! //} } else { bool fWrap; if(!fForward) { fWrap = GetWrapKeyboardNavigate(); SetWrapKeyboardNavigate(true); } FireEvent(&kne); _fFocus = (GetKeyFocusedElement() != NULL); if(!fForward) { SetWrapKeyboardNavigate(fWrap); } } return _fFocus; } UINT HWNDView::MessageCallback(GMSG* pGMsg) { EventMsg * pmsg = static_cast(pGMsg); switch (GET_EVENT_DEST(pmsg)) { case GMF_DIRECT: case GMF_BUBBLED: if (pGMsg->nMsg == GM_QUERY) { GMSG_QUERYDROPTARGET * pTemp = (GMSG_QUERYDROPTARGET *)pGMsg; if (pTemp->nCode == GQUERY_DROPTARGET) { if (SUCCEEDED(_pDUIView->InitializeDropTarget(NULL, NULL, &pTemp->pdt))) { pTemp->hgadDrop = pTemp->hgadMsg; return DU_S_COMPLETE; } } } break; } return Element::MessageCallback(pGMsg); } void HWNDView::OnEvent(Event* pev) { if (pev->uidType == Button::Click) { if (pev->peTarget == FindDescendent(StrToID(L"blockadeclearbutton"))) { if (NULL != _pDefView) { _pDefView->RemoveBarricade(); } pev->fHandled = true; } } HWNDElement::OnEvent(pev); } //////////////////////////////////////////////////////// // ClassInfo (must appear after property definitions) // Define class info with type and base type, set static class pointer IClassInfo* HWNDView::Class = NULL; HRESULT HWNDView::Register() { return ClassInfo::Register(L"HWNDView", NULL, 0); } HRESULT InitializeDUIViewClasses(void) { HRESULT hr; hr = DUIAxHost::Register(); if (FAILED(hr)) goto Failure; hr = CNameSpaceItemInfoList::Register(); if (FAILED(hr)) goto Failure; hr = CNameSpaceItemInfo::Register(); if (FAILED(hr)) goto Failure; hr = CMiniPreviewer::Register(); if (FAILED(hr)) goto Failure; hr = CBitmapElement::Register(); if (FAILED(hr)) goto Failure; hr = DUIListView::Register(); if (FAILED(hr)) goto Failure; hr = Expando::Register(); if (FAILED(hr)) goto Failure; hr = Clipper::Register(); if (FAILED(hr)) goto Failure; hr = TaskList::Register(); if (FAILED(hr)) goto Failure; hr = ActionTask::Register(); if (FAILED(hr)) goto Failure; hr = DestinationTask::Register(); if (FAILED(hr)) goto Failure; hr = HWNDView::Register(); if (FAILED(hr)) goto Failure; return S_OK; Failure: return hr; }