ReactOS 0.4.16-dev-980-g00983aa
CDefView.cpp
Go to the documentation of this file.
1/*
2 * ShellView
3 *
4 * Copyright 1998,1999 <juergen.schmied@debitel.net>
5 * Copyright 2022 Russell Johnson <russell.johnson@superdark.net>
6 *
7 * This is the view visualizing the data provided by the shellfolder.
8 * No direct access to data from pidls should be done from here.
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 *
24 * FIXME: CheckToolbar: handle the "new folder" and "folder up" button
25 */
26
27/*
28TODO:
29- When editing starts on item, set edit text to for editing value.
30- Fix shell view to handle view mode popup exec.
31- The background context menu should have a pidl just like foreground menus. This
32 causes crashes when dynamic handlers try to use the NULL pidl.
33- Reorder of columns doesn't work - might be bug in comctl32
34*/
35
36#include "precomp.h"
37
38#include <atlwin.h>
39#include <ui/rosctrls.h>
40
42
43// It would be easier to allocate these from 1 and up but the original code used the entire
44// FCIDM_SHVIEWFIRST..FCIDM_SHVIEWLAST range when dealing with IContextMenu and to avoid
45// breaking anything relying on this we will allocate our ranges from the end instead.
46enum {
47 DEFVIEW_ARRANGESORT_MAXENUM = 9, // Limit the number of the visible columns we will display in the submenu
48 DEFVIEW_ARRANGESORT_MAX = DEFVIEW_ARRANGESORT_MAXENUM + 1, // Reserve one extra for the current sort-by column
52
54 // FIXME: FCIDM_SHVIEWFIRST is 0 and using that with QueryContextMenu is a
55 // bad idea because it hides bugs related to the ids in ici.lpVerb.
56 // CONTEXT_MENU_BASE_ID acknowledges this but failed to apply the fix everywhere.
58};
59#undef FCIDM_SHVIEWLAST // Don't use this constant, change DVIDM_CONTEXTMENU_LAST if you need a new id.
60
62{
66 UINT8 Reserved; // Unused
68
69 enum { UNSPECIFIEDCOLUMN = -1 };
70 void Reset()
71 {
72 *(UINT*)this = 0;
74 }
75};
76
77#define SHV_CHANGE_NOTIFY (WM_USER + 0x1111)
78#define SHV_UPDATESTATUSBAR (WM_USER + 0x1112)
79
80// For the context menu of the def view, the id of the items are based on 1 because we need
81// to call TrackPopupMenu and let it use the 0 value as an indication that the menu was canceled
82#define CONTEXT_MENU_BASE_ID 1
83
85{
86 enum { MAXCOUNT = 100 };
87 static const UINT SIG = ('R' << 0) | ('O' << 8) | ('S' << 16) | (('c') << 24);
91};
92
94{
95 static const UINT SIG = ('R' << 0) | ('O' << 8) | ('S' << 16) | (('c' ^ 'v' ^ 's') << 24);
99 static const UINT VALIDFWF = FWF_AUTOARRANGE | FWF_SNAPTOGRID | FWF_NOGROUPING; // Note: The desktop applies FWF_NOICONS when appropriate
101};
102
103static UINT
105{
106 UINT cmf = CMF_NORMAL;
107 if (GetKeyState(VK_SHIFT) < 0)
108 cmf |= CMF_EXTENDEDVERBS;
109 if (sfgao & SFGAO_CANRENAME)
110 cmf |= CMF_CANRENAME;
111 HWND hwnd = NULL;
112 if (pSB && SUCCEEDED(pSB->GetControlWindow(FCW_TREE, &hwnd)) && hwnd)
113 cmf |= CMF_EXPLORE;
114 return cmf;
115}
116
117// Convert client coordinates to listview coordinates
118static void
120{
121 POINT Origin = {};
122
123 // FIXME: LVM_GETORIGIN is broken. See CORE-17266
124 if (!ListView_GetOrigin(hwndLV, &Origin))
125 return;
126
127 ppt->x += Origin.x;
128 ppt->y += Origin.y;
129}
130
131// Helper struct to automatically cleanup the IContextMenu
132// We want to explicitly reset the Site, so there are no circular references
134{
137
139 : m_pCM(pCM), m_hMenu(menu)
140 {
141 }
143 {
144 if (m_hMenu)
145 {
147 m_hMenu = NULL;
148 }
149 if (m_pCM)
150 {
152 m_pCM.Release();
153 }
154 }
155};
156
158{
159 MENUITEMINFOW mii;
160 mii.cbSize = sizeof(mii);
162 mii.fState = MF & (MFS_CHECKED | MFS_DISABLED);
163 mii.fType = MF & ~mii.fState;
164 mii.wID = Id;
165 mii.dwTypeData = const_cast<LPWSTR>(String);
166 mii.dwItemData = Data;
167 return InsertMenuItemW(hMenu, -1, TRUE, &mii);
168}
169
171{
172 MENUITEMINFOW mii;
173 mii.cbSize = FIELD_OFFSET(MENUITEMINFOW, hbmpItem);
174 mii.fMask = MIIM_DATA;
175 if (GetMenuItemInfoW(hMenu, Id, FALSE, &mii))
176 return mii.dwItemData;
177 else
178 return 0;
179}
180
182{
183 MENUITEMINFOW mii = {sizeof(mii), MIIM_SUBMENU};
184 if (::GetMenuItemInfoW(hmenu, id, FALSE, &mii))
185 return mii.hSubMenu;
186
187 return NULL;
188}
189
190/* ReallyGetMenuItemID returns the id of an item even if it opens a submenu,
191 GetMenuItemID returns -1 if the specified item opens a submenu */
193{
194 MENUITEMINFOW mii = {sizeof(mii), MIIM_ID};
195 if (::GetMenuItemInfoW(hmenu, i, TRUE, &mii))
196 return mii.wID;
197
198 return UINT_MAX;
199}
200
202{
203 UINT ret = 0;
204 HDC hDC = GetDC(hwnd);
205 if (hDC)
206 {
209 SelectObject(hDC, hOrg);
211 }
212 return ret;
213}
214
215static inline COLORREF GetViewColor(COLORREF Clr, UINT SysFallback)
216{
217 return Clr != CLR_INVALID ? Clr : GetSysColor(SysFallback);
218}
219
220class CDefView :
221 public CWindowImpl<CDefView, CWindow, CControlWinTraits>,
222 public CComObjectRootEx<CComMultiThreadModelNoCS>,
223 public IShellView3,
224 public IFolderView,
225 public IShellFolderView,
226 public IOleCommandTarget,
227 public IDropTarget,
228 public IDropSource,
229 public IViewObject,
230 public IServiceProvider
231{
232private:
241 ClipboardViewerChain m_ClipboardChain;
245 HMENU m_hMenu; // Handle to the menu bar of the browser
246 HMENU m_hMenuArrangeModes; // Handle to the popup menu with the arrange modes
247 HMENU m_hMenuViewModes; // Handle to the popup menu with the view modes
248 HMENU m_hContextMenu; // Handle to the open context menu
257 ULONG m_hNotify; // Change notification handle
258 HACCEL m_hAccel;
262 // for drag and drop
264 CComPtr<IDropTarget> m_pCurDropTarget; // The sub-item, which is currently dragged over
265 CComPtr<IDataObject> m_pCurDataObject; // The dragged data-object
266 LONG m_iDragOverItem; // Dragged over item's index, if m_pCurDropTarget != NULL
267 UINT m_cScrollDelay; // Send a WM_*SCROLL msg every 250 ms during drag-scroll
268 POINT m_ptLastMousePos; // Mouse position at last DragOver call
269 POINT m_ptFirstMousePos; // Mouse position when the drag operation started
271 //
274
276 signed char m_SpecialFolder;
280
284
286
288 BOOL _Sort(int Col = -1);
295 void _DoCopyToMoveToFolder(BOOL bCopy);
297
298 inline BOOL IsSpecialFolder(int &csidl) const
299 {
300 csidl = m_SpecialFolder;
301 return m_SpecialFolder >= 0;
302 }
303
304public:
305 CDefView();
306 ~CDefView();
311 void UpdateStatusbar();
313 void CheckToolbar();
315 void UpdateListColors();
316 BOOL InitList();
317 static INT CALLBACK ListViewCompareItems(LPARAM lParam1, LPARAM lParam2, LPARAM lpData);
318
323 HRESULT LoadColumn(UINT FoldCol, UINT ListCol, BOOL Insert, UINT ForceWidth = 0);
324 HRESULT LoadColumns(SIZE_T *pColList = NULL, UINT ColListCount = 0);
325 void ColumnListChanged();
328 void RefreshGhostedState();
332 int LV_AddItem(PCUITEMID_CHILD pidl);
337 void LV_RefreshIcon(INT iItem);
338 void LV_RefreshIcons();
340 HRESULT FillList(BOOL IsRefreshCommand = TRUE);
344 HRESULT FillArrangeAsMenu(HMENU hmenuArrange);
345 HRESULT CheckViewMode(HMENU hmenuView);
350 void OnDeactivate();
351 void DoActivate(UINT uState);
352 HRESULT drag_notify_subitem(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect);
354 LRESULT OnExplorerCommand(UINT uCommand, BOOL bUseSelection);
356 HRESULT GetDefaultViewStream(DWORD Stgm, IStream **ppStream);
358 HRESULT SaveViewState(IStream *pStream);
360
362 {
365 {
366 DWORD flags;
367 if (SUCCEEDED(pcdb2->GetViewFlags(&flags)))
368 return flags;
369 }
370 return 0;
371 }
372
373 // *** IOleWindow methods ***
374 STDMETHOD(GetWindow)(HWND *lphwnd) override;
375 STDMETHOD(ContextSensitiveHelp)(BOOL fEnterMode) override;
376
377 // *** IShellView methods ***
378 STDMETHOD(TranslateAccelerator)(MSG *pmsg) override;
379 STDMETHOD(EnableModeless)(BOOL fEnable) override;
380 STDMETHOD(UIActivate)(UINT uState) override;
381 STDMETHOD(Refresh)() override;
382 STDMETHOD(CreateViewWindow)(IShellView *psvPrevious, LPCFOLDERSETTINGS pfs, IShellBrowser *psb, RECT *prcView, HWND *phWnd) override;
383 STDMETHOD(DestroyViewWindow)() override;
386 STDMETHOD(SaveViewState)() override;
387 STDMETHOD(SelectItem)(PCUITEMID_CHILD pidlItem, SVSIF uFlags) override;
388 STDMETHOD(GetItemObject)(UINT uItem, REFIID riid, void **ppv) override;
389
390 // *** IShellView2 methods ***
391 STDMETHOD(GetView)(SHELLVIEWID *view_guid, ULONG view_type) override;
392 STDMETHOD(CreateViewWindow2)(LPSV2CVW2_PARAMS view_params) override;
393 STDMETHOD(HandleRename)(LPCITEMIDLIST new_pidl) override;
395
396 // *** IShellView3 methods ***
398 IShellBrowser *psb,
399 IShellView *psvPrevious,
400 SV3CVW3_FLAGS view_flags,
404 const SHELLVIEWID *view_id,
405 const RECT *prcView,
406 HWND *hwnd) override;
407
408 // *** IFolderView methods ***
409 STDMETHOD(GetCurrentViewMode)(UINT *pViewMode) override;
410 STDMETHOD(SetCurrentViewMode)(UINT ViewMode) override;
411 STDMETHOD(GetFolder)(REFIID riid, void **ppv) override;
412 STDMETHOD(Item)(int iItemIndex, PITEMID_CHILD *ppidl) override;
413 STDMETHOD(ItemCount)(UINT uFlags, int *pcItems) override;
414 STDMETHOD(Items)(UINT uFlags, REFIID riid, void **ppv) override;
415 STDMETHOD(GetSelectionMarkedItem)(int *piItem) override;
416 STDMETHOD(GetFocusedItem)(int *piItem) override;
417 STDMETHOD(GetItemPosition)(PCUITEMID_CHILD pidl, POINT *ppt) override;
418 STDMETHOD(GetSpacing)(POINT *ppt) override;
419 STDMETHOD(GetDefaultSpacing)(POINT *ppt) override;
420 STDMETHOD(GetAutoArrange)() override;
421 STDMETHOD(SelectItem)(int iItem, DWORD dwFlags) override;
423
424 // *** IShellFolderView methods ***
425 STDMETHOD(Rearrange)(LPARAM sort) override;
427 STDMETHOD(ArrangeGrid)() override;
428 STDMETHOD(AutoArrange)() override;
429 STDMETHOD(AddObject)(PITEMID_CHILD pidl, UINT *item) override;
430 STDMETHOD(GetObject)(PITEMID_CHILD *pidl, UINT item) override;
431 STDMETHOD(RemoveObject)(PITEMID_CHILD pidl, UINT *item) override;
434 STDMETHOD(UpdateObject)(PITEMID_CHILD pidl_old, PITEMID_CHILD pidl_new, UINT *item) override;
436 STDMETHOD(SetRedraw)(BOOL redraw) override;
439 STDMETHOD(IsDropOnSource)(IDropTarget *drop_target) override;
440 STDMETHOD(GetDragPoint)(POINT *pt) override;
441 STDMETHOD(GetDropPoint)(POINT *pt) override;
443 STDMETHOD(SetItemPos)(PCUITEMID_CHILD pidl, POINT *pt) override;
444 STDMETHOD(IsBkDropTarget)(IDropTarget *drop_target) override;
445 STDMETHOD(SetClipboard)(BOOL move) override;
447 STDMETHOD(GetItemSpacing)(ITEMSPACING *spacing) override;
448 STDMETHOD(SetCallback)(IShellFolderViewCB *new_cb, IShellFolderViewCB **old_cb) override;
449 STDMETHOD(Select)(UINT flags) override;
450 STDMETHOD(QuerySupport)(UINT *support) override;
451 STDMETHOD(SetAutomationObject)(IDispatch *disp) override;
452
453 // *** IOleCommandTarget methods ***
454 STDMETHOD(QueryStatus)(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT *pCmdText) override;
455 STDMETHOD(Exec)(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut) override;
456
457 // *** IDropTarget methods ***
458 STDMETHOD(DragEnter)(IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect) override;
459 STDMETHOD(DragOver)(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect) override;
460 STDMETHOD(DragLeave)() override;
461 STDMETHOD(Drop)(IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect) override;
462
463 // *** IDropSource methods ***
464 STDMETHOD(QueryContinueDrag)(BOOL fEscapePressed, DWORD grfKeyState) override;
465 STDMETHOD(GiveFeedback)(DWORD dwEffect) override;
466
467 // *** IViewObject methods ***
468 STDMETHOD(Draw)(DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd,
469 HDC hdcTargetDev, HDC hdcDraw, LPCRECTL lprcBounds, LPCRECTL lprcWBounds,
470 BOOL (STDMETHODCALLTYPE *pfnContinue)(ULONG_PTR dwContinue), ULONG_PTR dwContinue) override;
471 STDMETHOD(GetColorSet)(DWORD dwDrawAspect, LONG lindex, void *pvAspect,
472 DVTARGETDEVICE *ptd, HDC hicTargetDev, LOGPALETTE **ppColorSet) override;
473 STDMETHOD(Freeze)(DWORD dwDrawAspect, LONG lindex, void *pvAspect, DWORD *pdwFreeze) override;
474 STDMETHOD(Unfreeze)(DWORD dwFreeze) override;
475 STDMETHOD(SetAdvise)(DWORD aspects, DWORD advf, IAdviseSink *pAdvSink) override;
476 STDMETHOD(GetAdvise)(DWORD *pAspects, DWORD *pAdvf, IAdviseSink **ppAdvSink) override;
477
478 // *** IServiceProvider methods ***
479 STDMETHOD(QueryService)(REFGUID guidService, REFIID riid, void **ppvObject) override;
480
481 // Message handlers
484 LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
490 LRESULT OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
492 LRESULT OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
496 LRESULT OnCommand(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
497 LRESULT OnNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
505
506 virtual VOID OnFinalMessage(HWND) override;
507
509 {
510 static ATL::CWndClassInfo wc =
511 {
513 0, 0, NULL, NULL,
514 LoadCursor(NULL, IDC_ARROW), NULL, NULL, L"SHELLDLL_DefView", NULL
515 },
516 NULL, NULL, IDC_ARROW, TRUE, 0, _T("")
517 };
518 return wc;
519 }
520
521 virtual WNDPROC GetWindowProc() override
522 {
523 return WindowProc;
524 }
525
527 {
528 CDefView *pThis;
530
531 // Must hold a reference during message handling
532 pThis = reinterpret_cast<CDefView *>(hWnd);
533 pThis->AddRef();
535 pThis->Release();
536 return result;
537 }
538
565
567 // Windows returns E_NOINTERFACE for IOleWindow
568 // COM_INTERFACE_ENTRY_IID(IID_IOleWindow, IOleWindow)
569 COM_INTERFACE_ENTRY_IID(IID_IShellView, IShellView)
571 COM_INTERFACE_ENTRY_IID(IID_IShellView2, IShellView2)
572 COM_INTERFACE_ENTRY_IID(IID_IShellView3, IShellView3)
573 COM_INTERFACE_ENTRY_IID(IID_IFolderView, IFolderView)
574 COM_INTERFACE_ENTRY_IID(IID_IShellFolderView, IShellFolderView)
575 COM_INTERFACE_ENTRY_IID(IID_IOleCommandTarget, IOleCommandTarget)
576 COM_INTERFACE_ENTRY_IID(IID_IDropTarget, IDropTarget)
577 COM_INTERFACE_ENTRY_IID(IID_IDropSource, IDropSource)
579 COM_INTERFACE_ENTRY_IID(IID_IServiceProvider, IServiceProvider)
581};
582
583#define ID_LISTVIEW 1
584
585// windowsx.h
586#define GET_WM_COMMAND_ID(wp, lp) LOWORD(wp)
587#define GET_WM_COMMAND_HWND(wp, lp) (HWND)(lp)
588#define GET_WM_COMMAND_CMD(wp, lp) HIWORD(wp)
589
591
593 m_ListView(),
595 m_hMenu(NULL),
600 m_uState(0),
601 m_cidl(0),
602 m_apidl(NULL),
605 m_hNotify(0),
606 m_hAccel(NULL),
607 m_dwAspects(0),
608 m_dwAdvf(0),
612 m_SpecialFolder(-1),
617{
624
628}
629
631{
632 TRACE(" destroying IShellView(%p)\n", this);
633
635
637 {
640 }
641
642 if (m_hWnd)
643 {
645 }
646
650}
651
653{
654 m_pSFParent = shellFolder;
656 shellFolder->QueryInterface(IID_PPV_ARG(IShellDetails, &m_pSDParent));
657
658 return S_OK;
659}
660
661// ##### helperfunctions for communication with ICommDlgBrowser #####
662
664{
665 HRESULT ret = S_OK;
666 if (m_pCommDlgBrowser && !(GetCommDlgViewFlags() & CDB2GVF_NOINCLUDEITEM))
667 {
668 TRACE("ICommDlgBrowser::IncludeObject pidl=%p\n", pidl);
669 ret = m_pCommDlgBrowser->IncludeObject(this, pidl);
670 TRACE("-- returns 0x%08x\n", ret);
671 }
672 else if (m_pFolderFilter)
673 {
674 ret = m_pFolderFilter->ShouldShow(m_pSFParent, m_pidlParent, pidl);
675 }
676 return ret;
677}
678
680{
682
683 if (m_pCommDlgBrowser.p != NULL)
684 {
685 TRACE("ICommDlgBrowser::OnDefaultCommand\n");
686 ret = m_pCommDlgBrowser->OnDefaultCommand(this);
687 TRACE("-- returns 0x%08x\n", ret);
688 }
689
690 return ret;
691}
692
694{
696
697 if (m_pCommDlgBrowser.p != NULL)
698 {
699 TRACE("ICommDlgBrowser::OnStateChange flags=%x\n", uFlags);
700 ret = m_pCommDlgBrowser->OnStateChange(this, uFlags);
701 TRACE("--\n");
702 }
703
704 return ret;
705}
706/**********************************************************
707 * set the toolbar of the filedialog buttons
708 *
709 * - activates the buttons from the shellbrowser according to
710 * the view state
711 */
713{
715
716 TRACE("\n");
717
718 if (m_pCommDlgBrowser != NULL)
719 {
720 m_pShellBrowser->SendControlMsg(FCW_TOOLBAR, TB_CHECKBUTTON,
722 m_pShellBrowser->SendControlMsg(FCW_TOOLBAR, TB_CHECKBUTTON,
724 m_pShellBrowser->SendControlMsg(FCW_TOOLBAR, TB_ENABLEBUTTON,
726 m_pShellBrowser->SendControlMsg(FCW_TOOLBAR, TB_ENABLEBUTTON,
728 }
729}
730
732{
733 WCHAR szFormat[MAX_PATH];
734 WCHAR szPartText[MAX_PATH];
735 UINT cSelectedItems;
736
737 if (!m_ListView)
738 return;
739
740 cSelectedItems = m_ListView.GetSelectedCount();
741 if (cSelectedItems)
742 {
744 StringCchPrintfW(szPartText, _countof(szPartText), szFormat, cSelectedItems);
745 }
746 else
747 {
748 LoadStringW(shell32_hInstance, IDS_OBJECTS, szFormat, _countof(szFormat));
749 StringCchPrintfW(szPartText, _countof(szPartText), szFormat, m_ListView.GetItemCount());
750 }
751
752 LRESULT lResult;
753 m_pShellBrowser->SendControlMsg(FCW_STATUS, SB_SETTEXT, 0, (LPARAM)szPartText, &lResult);
754
755 // Don't bother with the extra processing if we only have one StatusBar part
757 {
758 UINT64 uTotalFileSize = 0;
759 WORD uFileFlags = LVNI_ALL;
760 INT nItem = -1;
761 bool bIsOnlyFoldersSelected = true;
762
763 // If we have something selected then only count selected file sizes
764 if (cSelectedItems)
765 {
766 uFileFlags = LVNI_SELECTED;
767 }
768
769 while ((nItem = m_ListView.GetNextItem(nItem, uFileFlags)) >= 0)
770 {
771 PCUITEMID_CHILD pidl = _PidlByItem(nItem);
772
773 uTotalFileSize += _ILGetFileSize(pidl, NULL, 0);
774
775 if (!_ILIsFolder(pidl))
776 {
777 bIsOnlyFoldersSelected = false;
778 }
779 }
780
781 // Don't show the file size text if there is 0 bytes in the folder
782 // OR we only have folders selected
783 if ((cSelectedItems && !bIsOnlyFoldersSelected) || uTotalFileSize)
784 StrFormatByteSizeW(uTotalFileSize, szPartText, _countof(szPartText));
785 else
786 *szPartText = 0;
787
788 m_pShellBrowser->SendControlMsg(FCW_STATUS, SB_SETTEXT, 1, (LPARAM)szPartText, &lResult);
789 }
790
791 SFGAOF att = 0;
792 if (cSelectedItems > 0)
793 {
794 UINT maxquery = 42; // Checking the attributes can be slow, only check small selections (_DoCopyToMoveToFolder will verify the full array)
795 att = SFGAO_CANCOPY | SFGAO_CANMOVE;
796 if (cSelectedItems <= maxquery && (!GetSelections() || FAILED(m_pSFParent->GetAttributesOf(m_cidl, m_apidl, &att))))
797 att = 0;
798 }
799 m_pShellBrowser->SendControlMsg(FCW_TOOLBAR, TB_ENABLEBUTTON, FCIDM_SHVIEW_COPYTO, (att & SFGAO_CANCOPY) != 0, &lResult);
800 m_pShellBrowser->SendControlMsg(FCW_TOOLBAR, TB_ENABLEBUTTON, FCIDM_SHVIEW_MOVETO, (att & SFGAO_CANMOVE) != 0, &lResult);
801}
802
804{
805 LRESULT lResult;
806 LPARAM pIcon = NULL;
807 WCHAR szPartText[MAX_PATH];
808 *szPartText = 0;
810 {
811 // If we are in a Recycle Bin then show no text for the location part
812 int csidl;
813 if (!IsSpecialFolder(csidl) || (csidl != CSIDL_NETWORK && csidl != CSIDL_BITBUCKET))
814 {
815 LoadStringW(shell32_hInstance, IDS_MYCOMPUTER, szPartText, _countof(szPartText));
816 pIcon = (LPARAM)m_hMyComputerIcon;
817 }
818 /*else if (csidl == CSIDL_NETWORK) // TODO: Figure out the type of share (My Computer/Local Intranet/Internet?)
819 {
820 ImageList_GetIconSize(ListView_GetImageList(m_ListView, LVSIL_SMALL), &x, &y);
821 pIcon = (LPARAM)LoadImage(shell32_hInstance, MAKEINTRESOURCEW(IDI_SHELL_MY_NETWORK_PLACES),
822 IMAGE_ICON, x, y, LR_SHARED);
823 }*/
824 }
825 m_pShellBrowser->SendControlMsg(FCW_STATUS, SB_SETICON, 2, pIcon, &lResult);
826 m_pShellBrowser->SendControlMsg(FCW_STATUS, SB_SETTEXT, 2, (LPARAM)szPartText, &lResult);
827}
828
830{
833 return 0;
834}
835
836
837// ##### helperfunctions for initializing the view #####
838
839// creates the list view window
841{
842 HRESULT hr;
843 DWORD dwStyle, dwExStyle, ListExStyle;
844 UINT ViewMode;
845
846 TRACE("%p\n", this);
847
849 LVS_SHAREIMAGELISTS | LVS_EDITLABELS | LVS_AUTOARRANGE; // FIXME: Remove LVS_AUTOARRANGE when the view is able to save ItemPos
851 ListExStyle = LVS_EX_INFOTIP | LVS_EX_LABELTIP;
852
854 {
856 dwStyle |= LVS_ALIGNLEFT;
857 // LVS_EX_REGIONAL?
858 }
859 else
860 {
861 dwStyle |= LVS_SHOWSELALWAYS; // MSDN says FWF_SHOWSELALWAYS is deprecated, always turn on for folders
863#if 0 // FIXME: Temporarily disabled until ListView is fixed (CORE-19624, CORE-19818)
864 ListExStyle |= LVS_EX_DOUBLEBUFFER;
865#endif
866 }
867
868 ViewMode = m_FolderSettings.ViewMode;
869 hr = _DoFolderViewCB(SFVM_DEFVIEWMODE, 0, (LPARAM)&ViewMode);
870 if (SUCCEEDED(hr))
871 {
872 if (ViewMode >= FVM_FIRST && ViewMode <= FVM_LAST)
873 m_FolderSettings.ViewMode = ViewMode;
874 else
875 ERR("Ignoring invalid ViewMode from SFVM_DEFVIEWMODE: %u (was: %u)\n", ViewMode, m_FolderSettings.ViewMode);
876 }
877
879 {
880 case FVM_ICON:
881 dwStyle |= LVS_ICON;
882 break;
883 case FVM_DETAILS:
884 dwStyle |= LVS_REPORT;
885 break;
886 case FVM_SMALLICON:
887 dwStyle |= LVS_SMALLICON;
888 break;
889 case FVM_LIST:
890 dwStyle |= LVS_LIST;
891 break;
892 default:
893 dwStyle |= LVS_LIST;
894 break;
895 }
896
898 dwStyle |= LVS_AUTOARRANGE;
899
901 ListExStyle |= LVS_EX_SNAPTOGRID;
902
904 dwStyle |= LVS_SINGLESEL;
905
907 ListExStyle |= LVS_EX_FULLROWSELECT;
908
910 (!SHELL_GetSetting(SSF_DOUBLECLICKINWEBVIEW, fDoubleClickInWebView) && !SHELL_GetSetting(SSF_WIN95CLASSIC, fWin95Classic)))
912
914 dwStyle |= LVS_NOCOLUMNHEADER;
915
916#if 0
917 // FIXME: Because this is a negative, everyone gets the new flag by default unless they
918 // opt out. This code should be enabled when shell looks like Vista instead of 2003
920 ListExStyle |= LVS_EX_HEADERINALLVIEWS;
921#endif
922
924 dwExStyle &= ~WS_EX_CLIENTEDGE;
925
926 RECT rcListView = {0,0,0,0};
927 m_ListView.Create(m_hWnd, rcListView, L"FolderView", dwStyle, dwExStyle, ID_LISTVIEW);
928
929 if (!m_ListView)
930 return FALSE;
931
933
934 /* UpdateShellSettings(); */
935 return TRUE;
936}
937
939{
941 {
942 /* Check if drop shadows option is enabled */
943 BOOL bDropShadow = FALSE;
944 DWORD cbDropShadow = sizeof(bDropShadow);
945
946 /*
947 * The desktop ListView always take the default desktop colours, by
948 * remaining transparent and letting user32/win32k paint itself the
949 * desktop background color, if any.
950 */
952
953 SHGetValueW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced",
954 L"ListviewShadow", NULL, &bDropShadow, &cbDropShadow);
955 if (bDropShadow)
956 {
957 /* Set the icon background transparent */
959 m_ListView.SetTextColor(RGB(255, 255, 255));
960 m_ListView.SetExtendedListViewStyle(LVS_EX_TRANSPARENTSHADOWTEXT, LVS_EX_TRANSPARENTSHADOWTEXT);
961 }
962 else
963 {
964 /* Set the icon background as the same colour as the desktop */
966 m_ListView.SetTextBkColor(crDesktop);
967 if (GetRValue(crDesktop) + GetGValue(crDesktop) + GetBValue(crDesktop) > 128 * 3)
968 m_ListView.SetTextColor(RGB(0, 0, 0));
969 else
970 m_ListView.SetTextColor(RGB(255, 255, 255));
971 m_ListView.SetExtendedListViewStyle(0, LVS_EX_TRANSPARENTSHADOWTEXT);
972 }
973 }
974 else
975 {
978
979 // Background is painted by the parent via WM_PRINTCLIENT
980 m_ListView.SetExtendedListViewStyle(LVS_EX_TRANSPARENTBKGND, LVS_EX_TRANSPARENTBKGND);
981 }
982}
983
984// adds all needed columns to the shellview
986{
987 HIMAGELIST big_icons, small_icons;
988
989 TRACE("%p\n", this);
990
992
993 Shell_GetImageLists(&big_icons, &small_icons);
995 m_ListView.SetImageList(small_icons, LVSIL_SMALL);
996
998
1000 UINT ColumnCount = pColumns ? DPA_GetPtrCount(m_LoadColumnsList) : 0;
1001 LoadColumns(pColumns, ColumnCount);
1003 {
1007 }
1008 return TRUE;
1009}
1010
1011/**********************************************************
1012* Column handling
1013*/
1015{
1016 LVCOLUMN lvc;
1017 lvc.mask = LVCF_SUBITEM;
1018 if (!ListView_GetColumn(List, Col, &lvc))
1019 return E_FAIL;
1020 else
1021 return lvc.iSubItem;
1022}
1023
1025{
1026 // This function is only called during column management, performance is not critical.
1027 for (UINT i = 0;; ++i)
1028 {
1030 if ((UINT)r == FoldCol)
1031 return i;
1032 else if (FAILED(r))
1033 return r;
1034 }
1035}
1036
1038{
1039 // This function is called every time a LVITEM::iSubItem is mapped to
1040 // a folder column (calls to GetDetailsOf etc.) and should be fast.
1042 {
1044 if (ListCol < count)
1045 {
1047 assert(col >= 0 && col == SHGetLVColumnSubItem(m_ListView.m_hWnd, ListCol));
1048 return col;
1049 }
1050 else if (count)
1051 {
1052 TRACE("m_ListToFolderColMap cache miss while mapping %d\n", ListCol);
1053 }
1054 }
1055 return SHGetLVColumnSubItem(m_ListView.m_hWnd, ListCol);
1056}
1057
1059{
1060 // According to learn.microsoft.com/en-us/windows/win32/shell/sfvm-getdetailsof
1061 // the query order is IShellFolder2, IShellDetails, SFVM_GETDETAILSOF.
1062 HRESULT hr = E_FAIL;
1063 if (m_pSF2Parent)
1064 {
1065 hr = m_pSF2Parent->GetDetailsOf(pidl, FoldCol, &sd);
1066 }
1067 if (FAILED(hr) && m_pSDParent)
1068 {
1069 hr = m_pSDParent->GetDetailsOf(pidl, FoldCol, &sd);
1070 }
1071#if 0 // TODO
1072 if (FAILED(hr))
1073 {
1074 FIXME("Try SFVM_GETDETAILSOF\n");
1075 }
1076#endif
1077 return hr;
1078}
1079
1081{
1083 if (SUCCEEDED(hr))
1084 return GetDetailsByFolderColumn(pidl, hr, sd);
1085 ERR("Unable to determine folder column from list column %d\n", (int) ListCol);
1086 return hr;
1087}
1088
1089HRESULT CDefView::LoadColumn(UINT FoldCol, UINT ListCol, BOOL Insert, UINT ForceWidth)
1090{
1093 HRESULT hr;
1094
1095 sd.str.uType = !STRRET_WSTR; // Make sure "uninitialized" uType is not WSTR
1096 hr = GetDetailsByFolderColumn(NULL, FoldCol, sd);
1097 if (FAILED(hr))
1098 return hr;
1099 hr = StrRetToStrNW(buf, _countof(buf), &sd.str, NULL);
1100 if (FAILED(hr))
1101 return hr;
1102
1103 UINT chavewidth = CalculateCharWidth(m_ListView.m_hWnd);
1104 if (!chavewidth)
1105 chavewidth = 6; // 6 is a reasonable default fallback
1106
1107 LVCOLUMN lvc;
1108 lvc.mask = LVCF_TEXT | LVCF_FMT | LVCF_WIDTH | LVCF_SUBITEM;
1109 lvc.pszText = buf;
1110 lvc.fmt = sd.fmt;
1111 lvc.cx = ForceWidth ? ForceWidth : (sd.cxChar * chavewidth); // FIXME: DPI?
1112 lvc.iSubItem = FoldCol; // Used by MapFolderColumnToListColumn & MapListColumnToFolderColumn
1113 if ((int)ListCol == -1)
1114 {
1115 assert(Insert); // You can insert at the end but you can't change something that is not there
1116 if (Insert)
1117 ListCol = 0x7fffffff;
1118 }
1119 if (Insert)
1120 ListView_InsertColumn(m_ListView.m_hWnd, ListCol, &lvc);
1121 else
1122 ListView_SetColumn(m_ListView.m_hWnd, ListCol, &lvc);
1123 return S_OK;
1124}
1125
1127{
1128 HWND hWndHdr = ListView_GetHeader(m_ListView.m_hWnd);
1129 UINT newColCount = 0, oldColCount = Header_GetItemCount(hWndHdr);
1130 UINT width = 0, foldCol, i;
1131 HRESULT hr = S_FALSE;
1132
1134 for (i = 0, foldCol = 0;; ++foldCol)
1135 {
1136 if (newColCount >= 0xffff)
1137 break; // CompareIDs limit reached
1138
1139 if (pColList)
1140 {
1141 if (i >= ColListCount)
1142 break;
1143 width = HIWORD(pColList[i]);
1144 foldCol = LOWORD(pColList[i++]);
1145 }
1146
1147 SHCOLSTATEF state = 0;
1148 if (!m_pSF2Parent || FAILED(m_pSF2Parent->GetDefaultColumnState(foldCol, &state)))
1150
1151 if (foldCol == 0)
1152 {
1153 // Force the first column
1154 }
1155 else if (state & SHCOLSTATE_HIDDEN)
1156 {
1157 continue;
1158 }
1159 else if (!pColList && !(state & SHCOLSTATE_ONBYDEFAULT))
1160 {
1161 continue;
1162 }
1163
1164 bool insert = newColCount >= oldColCount;
1165 UINT listCol = insert ? -1 : newColCount;
1166 hr = LoadColumn(foldCol, listCol, insert, width);
1167 if (FAILED(hr))
1168 {
1169 if (!pColList)
1170 hr = S_OK; // No more items, we are done
1171 break;
1172 }
1173 ++newColCount;
1174 }
1175 for (i = newColCount; i < oldColCount; ++i)
1176 {
1178 }
1179
1182 assert(SUCCEEDED(MapFolderColumnToListColumn(0))); // We don't allow turning off the Name column
1184 {
1187 }
1188 return hr;
1189}
1190
1192{
1194 m_ListToFolderColMap = NULL; // No cache while we are building the cache
1196 for (UINT i = 0;; ++i)
1197 {
1199 if (FAILED(hr))
1200 break; // No more columns
1201 if (!DPA_SetPtr(cache, i, (void*)(INT_PTR) hr))
1202 break; // Cannot allow holes in the cache, must stop now.
1203 }
1205
1206 for (;;)
1207 {
1209 break;
1210 }
1212 if (hMenu)
1213 {
1214 hMenu = GetSubmenuByID(hMenu, FCIDM_SHVIEW_ARRANGE);
1215 for (UINT i = DVIDM_ARRANGESORT_FIRST; i <= DVIDM_ARRANGESORT_LAST && hMenu; ++i)
1216 {
1217 RemoveMenu(hMenu, i, MF_BYCOMMAND);
1218 }
1219 if ((int) GetMenuItemID(hMenu, 0) <= 0)
1220 RemoveMenu(hMenu, 0, MF_BYPOSITION); // Separator
1221 }
1223 LVCOLUMN lvc;
1224 lvc.mask = LVCF_TEXT;
1225 lvc.pszText = buf;
1226 lvc.cchTextMax = _countof(buf);
1227 for (UINT listCol = 0; listCol < DEFVIEW_ARRANGESORT_MAXENUM; ++listCol)
1228 {
1229 if (!ListView_GetColumn(m_ListView.m_hWnd, listCol, &lvc))
1230 break;
1231 HRESULT foldCol = MapListColumnToFolderColumn(listCol);
1232 assert(SUCCEEDED(foldCol));
1235 DVIDM_ARRANGESORT_FIRST + listCol, lvc.pszText, listCol);
1236 }
1237
1238 ListView_RedrawItems(m_ListView.m_hWnd, 0, 0x7fffffff);
1239 m_ListView.InvalidateRect(NULL, TRUE);
1240}
1241
1242/*************************************************************************
1243 * ShellView_ListViewCompareItems
1244 *
1245 * Compare Function for the Listview (FileOpen Dialog)
1246 *
1247 * PARAMS
1248 * lParam1 [I] the first ItemIdList to compare with
1249 * lParam2 [I] the second ItemIdList to compare with
1250 * lpData [I] The column ID for the header Ctrl to process
1251 *
1252 * RETURNS
1253 * A negative value if the first item should precede the second,
1254 * a positive value if the first item should follow the second,
1255 * or zero if the two items are equivalent
1256 */
1258{
1259 PCUIDLIST_RELATIVE pidl1 = reinterpret_cast<PCUIDLIST_RELATIVE>(lParam1);
1260 PCUIDLIST_RELATIVE pidl2 = reinterpret_cast<PCUIDLIST_RELATIVE>(lParam2);
1261 CDefView *pThis = reinterpret_cast<CDefView*>(lpData);
1262
1263 HRESULT hres = pThis->m_pSFParent->CompareIDs(pThis->m_sortInfo.ListColumn, pidl1, pidl2);
1265 return 0;
1266
1267 SHORT nDiff = HRESULT_CODE(hres);
1268 return nDiff * pThis->m_sortInfo.Direction;
1269}
1270
1272{
1273 HWND hHeader;
1274 HDITEM hColumn;
1275 int prevCol = m_sortInfo.ListColumn;
1277
1278 // FIXME: Is this correct? Who sets this style?
1279 // And if it is set, should it also block sorting using the menu?
1280 // Any why should it block sorting when the view is loaded initially?
1281 if (m_ListView.GetWindowLongPtr(GWL_STYLE) & LVS_NOSORTHEADER)
1282 return TRUE;
1283
1284 hHeader = ListView_GetHeader(m_ListView.m_hWnd);
1285 if (Col != -1)
1286 {
1287 if (Col >= Header_GetItemCount(hHeader))
1288 {
1289 ERR("Sort column out of range\n");
1290 return FALSE;
1291 }
1292
1293 if (prevCol == Col)
1294 m_sortInfo.Direction *= -1;
1295 else
1297 m_sortInfo.ListColumn = Col;
1298 }
1299 if (!m_sortInfo.Direction)
1300 m_sortInfo.Direction += 1;
1301
1302 /* If the sorting column changed, remove the sorting style from the old column */
1303 if (prevCol != -1 && prevCol != m_sortInfo.ListColumn)
1304 {
1305 hColumn.mask = HDI_FORMAT;
1306 Header_GetItem(hHeader, prevCol, &hColumn);
1307 hColumn.fmt &= ~(HDF_SORTUP | HDF_SORTDOWN);
1308 Header_SetItem(hHeader, prevCol, &hColumn);
1309 }
1310
1311 /* Set the sorting style on the new column */
1312 hColumn.mask = HDI_FORMAT;
1313 Header_GetItem(hHeader, m_sortInfo.ListColumn, &hColumn);
1314 hColumn.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
1315 hColumn.fmt |= (m_sortInfo.Direction > 0 ? HDF_SORTUP : HDF_SORTDOWN);
1316 Header_SetItem(hHeader, m_sortInfo.ListColumn, &hColumn);
1317
1318 /* Sort the list, using the current values of ListColumn and bIsAscending */
1321}
1322
1324{
1325 SFGAOF Attr = (SFGAOF)Query;
1326 return SUCCEEDED(m_pSFParent->GetAttributesOf(1, &pidl, &Attr)) ? (Attr & Query) : 0;
1327}
1328
1330{
1331 PCUITEMID_CHILD pItem = _PidlByItem(i);
1332 return pItem ? GetItemAttributes(pItem, Query) : 0;
1333}
1334
1336{
1337 if (!m_ListView)
1338 return nullptr;
1339 return reinterpret_cast<PCUITEMID_CHILD>(m_ListView.GetItemData(i));
1340}
1341
1343{
1344 if (!m_ListView)
1345 return nullptr;
1346 return reinterpret_cast<PCUITEMID_CHILD>(lvItem.lParam);
1347}
1348
1350{
1352
1353 int cItems = m_ListView.GetItemCount();
1355 for (int i = 0; i < cItems; i++)
1356 {
1357 PCUITEMID_CHILD currentpidl = _PidlByItem(i);
1358 HRESULT hr = m_pSFParent->CompareIDs(lParam, pidl, currentpidl);
1359 if (SUCCEEDED(hr))
1360 {
1361 if (hr == S_EQUAL)
1362 return i;
1363 }
1364 else
1365 {
1366 for (i = 0; i < cItems; i++)
1367 {
1368 //FIXME: ILIsEqual needs absolute pidls!
1369 currentpidl = _PidlByItem(i);
1370 if (ILIsEqual(pidl, currentpidl))
1371 return i;
1372 }
1373 break;
1374 }
1375 }
1376 return -1;
1377}
1378
1380{
1381 LVITEMW lvItem;
1382
1383 TRACE("(%p)(pidl=%p)\n", this, pidl);
1384
1386
1388 return -1;
1389
1391 lvItem.iItem = m_ListView.GetItemCount(); // add item to lists end
1392 lvItem.iSubItem = 0;
1393 lvItem.lParam = reinterpret_cast<LPARAM>(ILClone(pidl)); // set item's data
1394 lvItem.pszText = LPSTR_TEXTCALLBACKW; // get text on a callback basis
1395 lvItem.iImage = I_IMAGECALLBACK; // get image on a callback basis
1396 lvItem.stateMask = LVIS_CUT;
1397 if (m_HasCutItems)
1398 lvItem.state = GetItemAttributes(pidl, SFGAO_HIDDEN | SFGAO_GHOSTED) ? LVIS_CUT : 0;
1399
1400 return m_ListView.InsertItem(&lvItem);
1401}
1402
1404{
1405 int nIndex;
1406
1407 TRACE("(%p)(pidl=%p)\n", this, pidl);
1408
1410
1411 nIndex = LV_FindItemByPidl(pidl);
1412 if (nIndex < 0)
1413 return FALSE;
1414
1416
1417 return m_ListView.DeleteItem(nIndex);
1418}
1419
1421{
1422 int nItem;
1423 LVITEMW lvItem;
1424
1425 TRACE("(%p)(pidlold=%p pidlnew=%p)\n", this, pidlOld, pidlNew);
1426
1428
1429 nItem = LV_FindItemByPidl(pidlOld);
1430
1431 if (-1 != nItem)
1432 {
1433 lvItem.mask = LVIF_PARAM; // only the pidl
1434 lvItem.iItem = nItem;
1435 lvItem.iSubItem = 0;
1436 m_ListView.GetItem(&lvItem);
1437
1438 // Store old pidl until new item is replaced
1439 LPVOID oldPidl = reinterpret_cast<LPVOID>(lvItem.lParam);
1440
1441 lvItem.mask = LVIF_PARAM | LVIF_IMAGE | LVIF_TEXT;
1442 lvItem.iItem = nItem;
1443 lvItem.iSubItem = 0;
1444 lvItem.lParam = reinterpret_cast<LPARAM>(ILClone(pidlNew)); // set item's data
1447 m_ListView.SetItem(&lvItem);
1448 m_ListView.Update(nItem);
1449
1450 // Now that the new item is in place, we can safely release the old pidl
1451 SHFree(oldPidl);
1452
1453 return TRUE; // FIXME: better handling
1454 }
1455
1456 return FALSE;
1457}
1458
1460{
1461 BOOL bResult = FALSE;
1462 LVITEMW lvItem;
1463 if (nItem >= 0)
1464 {
1466
1467 lvItem.mask = LVIF_IMAGE | LVIF_STATE;
1468 lvItem.iItem = nItem;
1469 lvItem.iSubItem = 0;
1471 lvItem.stateMask = LVIS_CUT;
1472 if (m_HasCutItems)
1473 lvItem.state = GetItemAttributes(pidl, SFGAO_HIDDEN | SFGAO_GHOSTED) ? LVIS_CUT : 0;
1474 PCUITEMID_CHILD pidlOld = _PidlByItem(nItem);
1475 if (pidlOld && (lvItem.lParam = reinterpret_cast<LPARAM>(ILClone(pidl))) != NULL)
1476 lvItem.mask |= LVIF_PARAM;
1477 bResult = m_ListView.SetItem(&lvItem);
1478 if (bResult && lvItem.lParam && pidlOld)
1479 ILFree(const_cast<PUITEMID_CHILD>(pidlOld));
1480 for (UINT i = 0; m_ListView.SetItemText(nItem, i, LPSTR_TEXTCALLBACK); ++i) {} // Update all columns
1481 }
1482 return bResult;
1483}
1484
1486{
1487 TRACE("(%p)(pidl=%p)\n", this, pidl);
1489 INT nItem = LV_FindItemByPidl(pidl);
1490 return nItem >= 0 ? LV_UpdateItem(nItem, pidl) : FALSE;
1491}
1492
1494{
1496
1497 LVITEMW lvItem = { LVIF_IMAGE };
1498 lvItem.iItem = iItem;
1499 lvItem.iImage = I_IMAGECALLBACK;
1500 m_ListView.SetItem(&lvItem);
1501 m_ListView.Update(iItem);
1502}
1503
1505{
1507
1508 for (INT iItem = -1;;)
1509 {
1510 iItem = ListView_GetNextItem(m_ListView, iItem, LVNI_ALL);
1511 if (iItem == -1)
1512 break;
1513
1514 LV_RefreshIcon(iItem);
1515 }
1516}
1517
1519{
1520 PITEMID_CHILD pidl = static_cast<PITEMID_CHILD>(ptr);
1521 CDefView *pThis = static_cast<CDefView *>(arg);
1522
1523 // in a commdlg this works as a filemask
1524 if (pThis->IncludeObject(pidl) == S_OK && pThis->m_ListView)
1525 pThis->LV_AddItem(pidl);
1526
1527 SHFree(pidl);
1528 return TRUE;
1529}
1530
1532// - gets the objectlist from the shellfolder
1533// - sorts the list
1534// - fills the list into the view
1536{
1537 CComPtr<IEnumIDList> pEnumIDList;
1538 PITEMID_CHILD pidl;
1539 DWORD dwFetched;
1540 HRESULT hRes;
1541 HDPA hdpa;
1542 DWORD dFlags = SHCONTF_NONFOLDERS | ((m_FolderSettings.fFlags & FWF_NOSUBFOLDERS) ? 0 : SHCONTF_FOLDERS);
1543
1544 TRACE("%p\n", this);
1545
1546 SHELLSTATE shellstate;
1548 if (GetCommDlgViewFlags() & CDB2GVF_SHOWALLFILES)
1549 shellstate.fShowAllObjects = shellstate.fShowSuperHidden = TRUE;
1550
1551 if (shellstate.fShowAllObjects)
1552 {
1553 dFlags |= SHCONTF_INCLUDEHIDDEN;
1554 m_ListView.SendMessageW(LVM_SETCALLBACKMASK, LVIS_CUT, 0);
1555 }
1556 if (shellstate.fShowSuperHidden)
1557 {
1558 dFlags |= SHCONTF_INCLUDESUPERHIDDEN;
1559 m_ListView.SendMessageW(LVM_SETCALLBACKMASK, LVIS_CUT, 0);
1560 }
1561
1562 // get the itemlist from the shfolder
1563 hRes = m_pSFParent->EnumObjects(m_hWnd, dFlags, &pEnumIDList);
1564 if (hRes != S_OK)
1565 {
1566 if (hRes == S_FALSE)
1567 return(NOERROR);
1568 return(hRes);
1569 }
1570
1571 // create a pointer array
1572 hdpa = DPA_Create(16);
1573 if (!hdpa)
1574 return(E_OUTOFMEMORY);
1575
1576 // copy the items into the array
1577 while((S_OK == pEnumIDList->Next(1, &pidl, &dwFetched)) && dwFetched)
1578 {
1579 if (DPA_AppendPtr(hdpa, pidl) == -1)
1580 {
1581 SHFree(pidl);
1582 }
1583 }
1584
1585 // turn listview's redrawing off
1587
1588 DPA_DestroyCallback( hdpa, fill_list, this);
1589
1590 /* sort the array */
1591 int sortCol = -1;
1592 if (!IsRefreshCommand && !m_sortInfo.bLoadedFromViewState) // Are we loading for the first time?
1593 {
1595 sortCol = 0; // In case the folder does not know/care
1596 if (m_pSF2Parent)
1597 {
1598 ULONG folderSortCol = sortCol, dummy;
1599 HRESULT hr = m_pSF2Parent->GetDefaultColumn(NULL, &folderSortCol, &dummy);
1600 if (SUCCEEDED(hr))
1601 hr = MapFolderColumnToListColumn(folderSortCol);
1602 if (SUCCEEDED(hr))
1603 sortCol = (int) hr;
1604 }
1605 }
1606 _Sort(sortCol);
1607
1609 {
1612 }
1613
1614 // load custom background image and custom text color
1617
1618 // turn listview's redrawing back on and force it to draw
1620
1622
1624 {
1625 // redraw now
1626 m_ListView.InvalidateRect(NULL, TRUE);
1627 }
1628
1629 if (IsRefreshCommand)
1631
1633
1634 return S_OK;
1635}
1636
1638{
1639 if (m_ListView.IsWindow())
1640 m_ListView.UpdateWindow();
1641 bHandled = FALSE;
1642 return 0;
1643}
1644
1646{
1647 return m_ListView.SendMessageW(uMsg, 0, 0);
1648}
1649
1651{
1652 if (!m_Destroyed)
1653 {
1654 m_Destroyed = TRUE;
1657 m_hNotify = NULL;
1658 m_ClipboardChain.Unhook(m_hWnd);
1659 if (m_pFileMenu)
1660 {
1662 m_pFileMenu = NULL;
1663 }
1664 if (m_hMenu)
1665 {
1667 m_hMenu = NULL;
1668 }
1671 }
1672 bHandled = FALSE;
1673 return 0;
1674}
1675
1677{
1678 /* redirect to parent */
1681
1682 bHandled = FALSE;
1683 return 0;
1684}
1685
1686static VOID
1688{
1689 INT x0 = prc->left, y0 = prc->top, x1 = prc->right, y1 = prc->bottom;
1690 x0 += dx;
1691 y0 += dy;
1692
1693 HDC hMemDC = CreateCompatibleDC(hDC);
1694 HGDIOBJ hbmOld = SelectObject(hMemDC, hbm);
1695
1696 for (INT y = y0; y < y1; y += nHeight)
1697 {
1698 for (INT x = x0; x < x1; x += nWidth)
1699 {
1700 BitBlt(hDC, x, y, nWidth, nHeight, hMemDC, 0, 0, SRCCOPY);
1701 }
1702 }
1703
1704 SelectObject(hMemDC, hbmOld);
1705 DeleteDC(hMemDC);
1706}
1707
1709{
1710 HDC hDC = (HDC)wParam;
1711
1712 RECT rc;
1714
1716 {
1717 BITMAP bm;
1718 if (::GetObject(m_viewinfo_data.hbmBack, sizeof(BITMAP), &bm))
1719 {
1720 INT dx = -(::GetScrollPos(m_ListView, SB_HORZ) % bm.bmWidth);
1721 INT dy = -(::GetScrollPos(m_ListView, SB_VERT) % bm.bmHeight);
1722 DrawTileBitmap(hDC, &rc, m_viewinfo_data.hbmBack, bm.bmWidth, bm.bmHeight, dx, dy);
1723 }
1724 }
1725 else
1726 {
1728 }
1729
1730 bHandled = TRUE;
1731
1732 return TRUE;
1733}
1734
1736{
1737 /* Update desktop labels color */
1739
1740 /* Forward WM_SYSCOLORCHANGE to common controls */
1741 return m_ListView.SendMessageW(uMsg, 0, 0);
1742}
1743
1745{
1746 return reinterpret_cast<LRESULT>(m_pShellBrowser.p);
1747}
1748
1750{
1751 this->AddRef();
1752 bHandled = FALSE;
1753 return 0;
1754}
1755
1757{
1758 this->Release();
1759}
1760
1762{
1765
1766 TRACE("%p\n", this);
1767
1769 {
1770 if (FAILED(RegisterDragDrop(m_hWnd, pdt)))
1771 ERR("Error Registering DragDrop\n");
1772 }
1773
1774 /* register for receiving notifications */
1775 m_pSFParent->QueryInterface(IID_PPV_ARG(IPersistFolder2, &ppf2));
1776 if (ppf2)
1777 {
1778 ppf2->GetCurFolder(&m_pidlParent);
1779 }
1780
1781 if (CreateList())
1782 {
1783 if (InitList())
1784 {
1785 FillList(FALSE);
1786 }
1787 }
1788
1790 {
1791 HWND hwndSB;
1792 m_pShellBrowser->GetWindow(&hwndSB);
1794 }
1795
1796 // Set up change notification
1797 LPITEMIDLIST pidlTarget = NULL;
1798 LONG fEvents = 0;
1799 HRESULT hr = _DoFolderViewCB(SFVM_GETNOTIFY, (WPARAM)&pidlTarget, (LPARAM)&fEvents);
1800 if (FAILED(hr) || (!pidlTarget && !fEvents)) // FIXME: MSDN says both zero means no notifications
1801 {
1802 pidlTarget = m_pidlParent;
1803 fEvents = SHCNE_ALLEVENTS;
1804 }
1805 SHChangeNotifyEntry ntreg = {};
1807 if (FAILED(hr))
1808 {
1809 ntreg.fRecursive = FALSE;
1810 ntreg.pidl = pidlTarget;
1811 }
1815 fEvents, SHV_CHANGE_NOTIFY,
1816 1, &ntreg);
1817
1819
1820 int bForceFullStatusBar = false;
1821 BOOL bIsFileSystem = SHGetAttributes(NULL, m_pidlParent, SFGAO_FILESYSTEM) & SFGAO_FILESYSTEM;
1822 m_SpecialFolder = bIsFileSystem ? -1 : 0x7f; // FS folder or "generic" CSIDL
1824 {
1826 }
1827 else if (IsEqualPersistClassID(ppf2, CLSID_RecycleBin))
1828 {
1829 m_SpecialFolder = bForceFullStatusBar = CSIDL_BITBUCKET;
1830 }
1831 else if (bIsFileSystem)
1832 {
1834 if (ILIsParent(pidlNet, m_pidlParent, FALSE) && ILGetSize(pidlNet) < ILGetSize(m_pidlParent))
1836 }
1837 m_isFullStatusBar = bIsFileSystem || bForceFullStatusBar;
1838 _ForceStatusBarResize(); // This handles changing StatusBar parts
1841
1842 return S_OK;
1843}
1844
1845// #### Handling of the menus ####
1846
1848{
1850 if (!hFileMenu)
1851 return E_FAIL;
1852
1853 /* Cleanup the items added previously */
1854 for (int i = GetMenuItemCount(hFileMenu) - 1; i >= 0; i--)
1855 {
1856 UINT id = GetMenuItemID(hFileMenu, i);
1857 if (id < FCIDM_BROWSERFIRST || id > FCIDM_BROWSERLAST)
1858 DeleteMenu(hFileMenu, i, MF_BYPOSITION);
1859 }
1860
1861 // In case we still have this left over, clean it up
1862 if (m_pFileMenu)
1863 {
1866 }
1867 UINT selcount = m_ListView.GetSelectedCount();
1868 // Store context menu in m_pFileMenu and keep it to invoke the selected command later on
1871 return hr;
1872
1874
1876 hr = m_pFileMenu->QueryContextMenu(hmenu, 0, DVIDM_CONTEXTMENU_FIRST, DVIDM_CONTEXTMENU_LAST, cmf);
1878 return hr;
1879
1880 // TODO: filter or something
1881 if (!selcount)
1882 {
1886 }
1887
1888 Shell_MergeMenus(hFileMenu, hmenu, 0, 0, 0xFFFF, MM_ADDSEPARATOR | MM_SUBMENUSHAVEIDS);
1890 return S_OK;
1891}
1892
1894{
1896 if (!hEditMenu)
1897 return E_FAIL;
1898
1899 HMENU hmenuContents = ::LoadMenuW(shell32_hInstance, L"MENU_003");
1900 if (!hmenuContents)
1901 return E_FAIL;
1902
1903 Shell_MergeMenus(hEditMenu, hmenuContents, 0, 0, 0xFFFF, 0);
1904
1905 ::DestroyMenu(hmenuContents);
1906
1907 return S_OK;
1908}
1909
1911{
1913 if (!hViewMenu)
1914 return E_FAIL;
1915
1917 if (!m_hMenuViewModes)
1918 return E_FAIL;
1919
1922
1923 return S_OK;
1924}
1925
1927{
1928 bool forceMerge = false;
1930
1931 // Make sure the column we currently sort by is in the menu
1934 {
1938 LVCOLUMN lvc;
1939 lvc.mask = LVCF_TEXT;
1940 lvc.pszText = buf;
1941 lvc.cchTextMax = _countof(buf);
1942 currentSortId = DVIDM_ARRANGESORT_LAST;
1943 forceMerge = true;
1945 AppendMenuItem(m_hMenuArrangeModes, MF_STRING, currentSortId, lvc.pszText, m_sortInfo.ListColumn);
1946 }
1947
1948 // Prepend the sort-by items unless they are aleady there
1949 if (GetMenuItemID(hmenuArrange, 0) == FCIDM_SHVIEW_AUTOARRANGE || forceMerge)
1950 {
1951 Shell_MergeMenus(hmenuArrange, m_hMenuArrangeModes, 0, 0, 0xFFFF, MM_ADDSEPARATOR);
1952 }
1953
1954 CheckMenuRadioItem(hmenuArrange,
1956 currentSortId, MF_BYCOMMAND);
1957
1959 {
1962 }
1963 else
1964 {
1967
1968 if (GetAutoArrange() == S_OK)
1970 else
1972
1973 if (_GetSnapToGrid() == S_OK)
1975 else
1977 }
1978
1979 return S_OK;
1980}
1981
1983{
1985 {
1986 UINT iItemFirst = FCIDM_SHVIEW_BIGICON;
1987 UINT iItemLast = iItemFirst + FVM_LAST - FVM_FIRST;
1988 UINT iItem = iItemFirst + m_FolderSettings.ViewMode - FVM_FIRST;
1989 CheckMenuRadioItem(hmenuView, iItemFirst, iItemLast, iItem, MF_BYCOMMAND);
1990 }
1991
1992 return S_OK;
1993}
1994
1996{
1997 const UINT maxItems = 15; // Feels about right
1998 const UINT idMore = 0x1337;
1999 UINT idFirst = idMore + 1, idLast = idFirst;
2000 UINT lastValidListCol = 0; // Keep track of where the new column should be inserted
2001 UINT showMore = GetKeyState(VK_SHIFT) < 0;
2003 HWND hWndHdr = ListView_GetHeader(m_ListView.m_hWnd);
2004
2005 if (lParam == ~0)
2006 {
2007 RECT r;
2008 ::GetWindowRect(hWndHdr, &r);
2009 pt.x = r.left + ((r.right - r.left) / 2);
2010 pt.y = r.top + ((r.bottom - r.top) / 2);
2011 }
2012
2013 HMENU hMenu = CreatePopupMenu();
2014 if (!hMenu)
2015 return 0;
2016
2017 for (UINT foldCol = 0;; ++foldCol)
2018 {
2021 sd.str.uType = !STRRET_WSTR;
2022 if (FAILED(GetDetailsByFolderColumn(NULL, foldCol, sd)))
2023 break;
2024 if (FAILED(StrRetToStrNW(buf, _countof(buf), &sd.str, NULL)))
2025 break;
2026
2027 SHCOLSTATEF state = 0;
2028 if (!m_pSF2Parent || FAILED(m_pSF2Parent->GetDefaultColumnState(foldCol, &state)))
2029 state = 0;
2030 showMore |= (state & (SHCOLSTATE_SECONDARYUI));
2031
2032 UINT mf = MF_STRING;
2033 HRESULT listCol = MapFolderColumnToListColumn(foldCol);
2034
2035 if (foldCol == 0)
2036 mf |= MF_CHECKED | MF_GRAYED | MF_DISABLED; // Force column 0
2038 continue;
2039 else if (SUCCEEDED(listCol))
2040 mf |= MF_CHECKED;
2041
2042 if (AppendMenuItem(hMenu, mf, idLast, buf, lastValidListCol + 1))
2043 {
2044 idLast++;
2045 if (SUCCEEDED(listCol))
2046 lastValidListCol = listCol;
2047 }
2048
2049 if (idLast - idFirst == maxItems)
2050 {
2051 showMore++;
2052 break;
2053 }
2054 }
2055
2056 if (showMore)
2057 {
2058#if 0 // TODO
2059 InsertMenuW(hMenu, -1, MF_SEPARATOR, 0, NULL);
2060 InsertMenuW(hMenu, -1, MF_STRING, idMore, L"More...");
2061#endif
2062 }
2063
2064 // A cludge to force the cursor to update so we are not stuck with "size left/right" if
2065 // the right-click was on a column divider.
2067
2068 // Note: Uses the header as the owner so CDefView::OnInitMenuPopup does not mess us up.
2070 pt.x, pt.y, 0, hWndHdr, NULL);
2071 if (idCmd == idMore)
2072 {
2073 FIXME("Open More dialog\n");
2074 }
2075 else if (idCmd)
2076 {
2077 UINT foldCol = idCmd - idFirst;
2078 HRESULT listCol = MapFolderColumnToListColumn(foldCol);
2079 if (SUCCEEDED(listCol))
2080 {
2081 ListView_DeleteColumn(m_ListView.m_hWnd, listCol);
2082 }
2083 else
2084 {
2085 listCol = (UINT) GetMenuItemDataById(hMenu, idCmd);
2086 LoadColumn(foldCol, listCol, TRUE);
2087 }
2089 }
2090 DestroyMenu(hMenu);
2091 return 0;
2092}
2093
2094/**********************************************************
2095* ShellView_GetSelections()
2096*
2097* - fills the m_apidl list with the selected objects
2098*
2099* RETURNS
2100* number of selected items
2101*/
2103{
2105 if (count > m_cidl || !count || !m_apidl) // !count to free possibly large cache, !m_apidl to make sure m_apidl is a valid pointer
2106 {
2107 SHFree(m_apidl);
2108 m_apidl = static_cast<PCUITEMID_CHILD*>(SHAlloc(count * sizeof(PCUITEMID_CHILD)));
2109 if (!m_apidl)
2110 {
2111 m_cidl = 0;
2112 return 0;
2113 }
2114 }
2115 m_cidl = count;
2116
2117 TRACE("-- Items selected =%u\n", m_cidl);
2118
2120
2121 UINT i = 0;
2122 int lvIndex = -1;
2123 while ((lvIndex = m_ListView.GetNextItem(lvIndex, LVNI_SELECTED)) > -1)
2124 {
2125 m_apidl[i] = _PidlByItem(lvIndex);
2126 i++;
2127 if (i == m_cidl)
2128 break;
2129 TRACE("-- selected Item found\n");
2130 }
2131
2132 return m_cidl;
2133}
2134
2136{
2137 if (!GetSelections())
2138 return 0;
2139 SFGAOF Attr = Query;
2140 return SUCCEEDED(m_pSFParent->GetAttributesOf(m_cidl, m_apidl, &Attr)) ? (Attr & Query) : 0;
2141}
2142
2144{
2145 CMINVOKECOMMANDINFOEX cmi;
2146
2147 ZeroMemory(&cmi, sizeof(cmi));
2148 cmi.cbSize = sizeof(cmi);
2149 cmi.hwnd = m_hWnd;
2150 cmi.lpVerb = lpVerb;
2151 cmi.nShow = SW_SHOW;
2152
2153 if (GetKeyState(VK_SHIFT) < 0)
2154 cmi.fMask |= CMIC_MASK_SHIFT_DOWN;
2155
2157 cmi.fMask |= CMIC_MASK_CONTROL_DOWN;
2158
2159 if (pt)
2160 {
2161 cmi.fMask |= CMIC_MASK_PTINVOKE;
2162 cmi.ptInvoke = *pt;
2163 }
2164
2165 WCHAR szDirW[MAX_PATH] = L"";
2166 CHAR szDirA[MAX_PATH];
2168 *szDirW != UNICODE_NULL)
2169 {
2170 SHUnicodeToAnsi(szDirW, szDirA, _countof(szDirA));
2171 cmi.fMask |= CMIC_MASK_UNICODE;
2172 cmi.lpDirectory = szDirA;
2173 cmi.lpDirectoryW = szDirW;
2174 }
2175
2176 HRESULT hr = pCM->InvokeCommand((LPCMINVOKECOMMANDINFO)&cmi);
2177 // Most of our callers will do this, but if they would forget (File menu!)
2178 IUnknown_SetSite(pCM, NULL);
2179 pCM.Release();
2180
2182 return hr;
2183
2184 return S_OK;
2185}
2186
2188{
2189 HMENU hMenu;
2190 UINT uCommand;
2191 HRESULT hResult;
2192
2193 if (m_ListView.GetSelectedCount() == 0)
2194 return S_OK;
2195
2196 hResult = OnDefaultCommand();
2197 if (hResult == S_OK)
2198 return hResult;
2199
2200 hMenu = CreatePopupMenu();
2201 if (!hMenu)
2202 return E_FAIL;
2203
2206 MenuCleanup _(pCM, hMenu);
2207 if (FAILED_UNEXPECTEDLY(hResult))
2208 return hResult;
2209
2210 UINT cmf = CMF_DEFAULTONLY | GetContextMenuFlags(m_pShellBrowser, 0);
2211 hResult = pCM->QueryContextMenu(hMenu, 0, DVIDM_CONTEXTMENU_FIRST, DVIDM_CONTEXTMENU_LAST, cmf);
2212 if (FAILED_UNEXPECTEDLY(hResult))
2213 return hResult;
2214
2215 uCommand = GetMenuDefaultItem(hMenu, FALSE, 0);
2216 if (uCommand == (UINT)-1)
2217 {
2218 ERR("GetMenuDefaultItem returned -1\n");
2219 return E_FAIL;
2220 }
2221
2223
2224 return hResult;
2225}
2226
2228{
2230 UINT uCommand;
2231 HRESULT hResult;
2232
2233 TRACE("(%p)\n", this);
2234
2235 if (m_hContextMenu != NULL)
2236 {
2237 ERR("HACK: Aborting context menu in nested call\n");
2238 return 0;
2239 }
2240
2241 HWND hWndHdr = ListView_GetHeader(m_ListView.m_hWnd);
2242 RECT r;
2243 if (::GetWindowRect(hWndHdr, &r) && PtInRect(&r, pt) && ::IsWindowVisible(hWndHdr))
2244 {
2246 }
2247
2249 if (!m_hContextMenu)
2250 return E_FAIL;
2251
2252 if (lParam != ~0) // unless app key (menu key) was pressed
2253 {
2254 LV_HITTESTINFO hittest = { pt };
2255 ScreenToClient(&hittest.pt);
2256 m_ListView.HitTest(&hittest);
2257
2258 // Right-Clicked item is selected? If selected, no selection change.
2259 // If not selected, then reset the selection and select the item.
2260 if ((hittest.flags & LVHT_ONITEM) &&
2262 {
2263 SelectItem(hittest.iItem, SVSI_SELECT | SVSI_DESELECTOTHERS | SVSI_ENSUREVISIBLE);
2264 }
2265 }
2266
2268 // In case we still have this left over, clean it up
2271 if (FAILED_UNEXPECTEDLY(hResult))
2272 return 0;
2273
2275 // Use 1 as the first id we want. 0 means that user canceled the menu
2276 hResult = m_pCM->QueryContextMenu(m_hContextMenu, 0, CONTEXT_MENU_BASE_ID, DVIDM_CONTEXTMENU_LAST, cmf);
2277 if (FAILED_UNEXPECTEDLY(hResult))
2278 return 0;
2279
2280 if (m_pCommDlgBrowser && !(GetCommDlgViewFlags() & CDB2GVF_NOSELECTVERB))
2281 {
2282 HMENU hMenuSource = LoadMenuW(_AtlBaseModule.GetResourceInstance(), MAKEINTRESOURCEW(IDM_DVSELECT));
2284 DestroyMenu(hMenuSource);
2286 // TODO: ICommDlgBrowser2::GetDefaultMenuText == S_OK
2287 }
2288
2289 // There is no position requested, so try to find one
2290 if (lParam == ~0)
2291 {
2292 HWND hFocus = ::GetFocus();
2293 int lvIndex = -1;
2294
2295 if (hFocus == m_ListView.m_hWnd || m_ListView.IsChild(hFocus))
2296 {
2297 // Is there an item focused and selected?
2299 // If not, find the first selected item
2300 if (lvIndex < 0)
2301 lvIndex = m_ListView.GetNextItem(-1, LVNI_SELECTED);
2302 }
2303
2304 // We got something
2305 if (lvIndex > -1)
2306 {
2307 // Find the center of the icon
2308 RECT rc = { LVIR_ICON };
2309 m_ListView.SendMessage(LVM_GETITEMRECT, lvIndex, (LPARAM)&rc);
2310 pt.x = (rc.right + rc.left) / 2;
2311 pt.y = (rc.bottom + rc.top) / 2;
2312 }
2313 else
2314 {
2315 // We have to drop it somewhere
2316 pt.x = pt.y = 0;
2317 }
2318
2319 m_ListView.ClientToScreen(&pt);
2320 }
2321
2324 pcdb2->Notify(static_cast<IShellView*>(this), CDB2N_CONTEXTMENU_START);
2325
2326 // This runs the message loop, calling back to us with f.e. WM_INITPOPUP (hence why m_hContextMenu and m_pCM exist)
2327 uCommand = TrackPopupMenu(m_hContextMenu,
2329 pt.x, pt.y, 0, m_hWnd, NULL);
2330 if (uCommand >= DVIDM_ARRANGESORT_FIRST && uCommand <= DVIDM_ARRANGESORT_LAST)
2331 {
2332 SendMessage(WM_COMMAND, uCommand, 0);
2333 }
2334 else if (uCommand != 0 && !(uCommand == DVIDM_COMMDLG_SELECT && OnDefaultCommand() == S_OK))
2335 {
2337 }
2338
2339 if (pcdb2)
2340 pcdb2->Notify(static_cast<IShellView*>(this), CDB2N_CONTEXTMENU_DONE);
2341 return 0;
2342}
2343
2345{
2346 HRESULT hResult;
2347 HMENU hMenu = NULL;
2348
2350 hResult = GetItemObject(bUseSelection ? SVGIO_SELECTION : SVGIO_BACKGROUND, IID_PPV_ARG(IContextMenu, &pCM));
2351 if (FAILED_UNEXPECTEDLY(hResult))
2352 return 0;
2353
2354 MenuCleanup _(pCM, hMenu);
2355
2356 if ((uCommand != FCIDM_SHVIEW_DELETE) && (uCommand != FCIDM_SHVIEW_RENAME))
2357 {
2358 hMenu = CreatePopupMenu();
2359 if (!hMenu)
2360 return 0;
2361
2362 hResult = pCM->QueryContextMenu(hMenu, 0, DVIDM_CONTEXTMENU_FIRST, DVIDM_CONTEXTMENU_LAST, CMF_NORMAL);
2363 if (FAILED_UNEXPECTEDLY(hResult))
2364 return 0;
2365 }
2366
2367 if (bUseSelection)
2368 {
2369 // FIXME: we should cache this
2370 SFGAOF rfg = SFGAO_BROWSABLE | SFGAO_CANCOPY | SFGAO_CANLINK | SFGAO_CANMOVE | SFGAO_CANDELETE | SFGAO_CANRENAME | SFGAO_HASPROPSHEET | SFGAO_FILESYSTEM | SFGAO_FOLDER;
2371 hResult = m_pSFParent->GetAttributesOf(m_cidl, m_apidl, &rfg);
2372 if (FAILED_UNEXPECTEDLY(hResult))
2373 return 0;
2374
2375 if (!(rfg & SFGAO_CANMOVE) && uCommand == FCIDM_SHVIEW_CUT)
2376 return 0;
2377 if (!(rfg & SFGAO_CANCOPY) && uCommand == FCIDM_SHVIEW_COPY)
2378 return 0;
2379 if (!(rfg & SFGAO_CANDELETE) && uCommand == FCIDM_SHVIEW_DELETE)
2380 return 0;
2381 if (!(rfg & SFGAO_CANRENAME) && uCommand == FCIDM_SHVIEW_RENAME)
2382 return 0;
2383 if (!(rfg & SFGAO_HASPROPSHEET) && uCommand == FCIDM_SHVIEW_PROPERTIES)
2384 return 0;
2385 }
2386
2387 // FIXME: We should probably use the objects position?
2389 return 0;
2390}
2391
2392// ##### message handling #####
2393
2395{
2396 WORD wWidth, wHeight;
2397
2398 wWidth = LOWORD(lParam);
2399 wHeight = HIWORD(lParam);
2400
2401 TRACE("%p width=%u height=%u\n", this, wWidth, wHeight);
2402
2403 // WM_SIZE can come before WM_CREATE
2404 if (!m_ListView)
2405 return 0;
2406
2407 /* Resize the ListView to fit our window */
2408 ::MoveWindow(m_ListView, 0, 0, wWidth, wHeight, TRUE);
2409
2411
2414
2415 return 0;
2416}
2417
2418// internal
2420{
2421 TRACE("%p\n", this);
2422
2424 {
2425 // TODO: cleanup menu after deactivation
2427 }
2428}
2429
2431{
2432 TRACE("%p uState=%x\n", this, uState);
2433
2434 // don't do anything if the state isn't really changing
2435 if (m_uState == uState)
2436 {
2437 return;
2438 }
2439
2440 if (uState == SVUIA_DEACTIVATE)
2441 {
2442 OnDeactivate();
2443 }
2444 else
2445 {
2447 {
2448 FillEditMenu();
2449 FillViewMenu();
2450 m_pShellBrowser->SetMenuSB(m_hMenu, 0, m_hWnd);
2452 }
2453
2454 if (SVUIA_ACTIVATE_FOCUS == uState)
2455 {
2456 m_ListView.SetFocus();
2457 }
2458 }
2459
2460 m_uState = uState;
2461 TRACE("--\n");
2462}
2463
2465{
2466 if (!GetSelections())
2467 return;
2468
2469 SFGAOF rfg = SFGAO_CANCOPY | SFGAO_CANMOVE | SFGAO_FILESYSTEM;
2470 HRESULT hr = m_pSFParent->GetAttributesOf(m_cidl, m_apidl, &rfg);
2472 return;
2473
2474 if (!bCopy && !(rfg & SFGAO_CANMOVE))
2475 return;
2476 if (bCopy && !(rfg & SFGAO_CANCOPY))
2477 return;
2478
2480 hr = m_pSFParent->GetUIObjectOf(m_hWnd, m_cidl, m_apidl, IID_IContextMenu, 0, (void **)&pCM);
2482 return;
2483
2484 InvokeContextMenuCommand(pCM, (bCopy ? "copyto" : "moveto"), NULL);
2485}
2486
2488{
2490 return 0;
2491}
2492
2494{
2495 TRACE("%p\n", this);
2496
2497 /* Tell the browser one of our windows has received the focus. This
2498 should always be done before merging menus (OnActivate merges the
2499 menus) if one of our windows has the focus.*/
2500
2501 m_pShellBrowser->OnViewWindowActive(this);
2503
2504 /* Set the focus to the listview */
2505 m_ListView.SetFocus();
2506
2507 /* Notify the ICommDlgBrowser interface */
2508 OnStateChange(CDBOSC_SETFOCUS);
2509
2510 return 0;
2511}
2512
2514{
2515 TRACE("(%p) stub\n", this);
2516
2518 /* Notify the ICommDlgBrowser */
2519 OnStateChange(CDBOSC_KILLFOCUS);
2520
2521 return 0;
2522}
2523
2524// the CmdID's are the ones from the context menu
2526{
2527 DWORD dwCmdID;
2528 DWORD dwCmd;
2529 HWND hwndCmd;
2530 int nCount;
2531
2532 dwCmdID = GET_WM_COMMAND_ID(wParam, lParam);
2534 hwndCmd = GET_WM_COMMAND_HWND(wParam, lParam);
2535
2536 TRACE("(%p)->(0x%08x 0x%08x %p) stub\n", this, dwCmdID, dwCmd, hwndCmd);
2537
2538 if (dwCmdID >= DVIDM_ARRANGESORT_FIRST && dwCmdID <= DVIDM_ARRANGESORT_LAST)
2539 {
2540 UINT listCol = (UINT)GetMenuItemDataById(m_hMenuArrangeModes, dwCmdID);
2541 _Sort(listCol);
2542 return 0;
2543 }
2544
2545 switch (dwCmdID)
2546 {
2550 CheckToolbar();
2551 break;
2554 m_ListView.ModifyStyle(LVS_TYPEMASK, LVS_ICON);
2555 CheckToolbar();
2556 break;
2559 m_ListView.ModifyStyle(LVS_TYPEMASK, LVS_LIST);
2560 CheckToolbar();
2561 break;
2564 m_ListView.ModifyStyle(LVS_TYPEMASK, LVS_REPORT);
2565 CheckToolbar();
2566 break;
2569 break;
2571 if (_GetSnapToGrid() == S_OK)
2573 else
2574 ArrangeGrid();
2575 break;
2577 if (GetAutoArrange() == S_OK)
2578 m_ListView.ModifyStyle(LVS_AUTOARRANGE, 0);
2579 else
2580 AutoArrange();
2581 break;
2585 break;
2587 nCount = m_ListView.GetItemCount();
2588 for (int i=0; i < nCount; i++)
2590 break;
2592 Refresh();
2593 break;
2595 case FCIDM_SHVIEW_CUT:
2596 case FCIDM_SHVIEW_COPY:
2600 return 0;
2601 return OnExplorerCommand(dwCmdID, TRUE);
2605 return 0;
2607 case FCIDM_SHVIEW_UNDO:
2610 return OnExplorerCommand(dwCmdID, FALSE);
2611 default:
2612 // WM_COMMAND messages from file menu are routed to CDefView to let m_pFileMenu handle them
2613 if (m_pFileMenu && dwCmd == 0)
2614 {
2615 HMENU Dummy = NULL;
2616 MenuCleanup _(m_pFileMenu, Dummy);
2618 }
2619 }
2620
2621 return 0;
2622}
2623
2624static BOOL
2626{
2627 HKEY hKey;
2628 LONG error;
2629 DWORD dwValue = FALSE, cbValue;
2630
2632 if (error)
2633 return dwValue;
2634
2635 cbValue = sizeof(dwValue);
2636 RegQueryValueExW(hKey, L"SelectExtOnRename", NULL, NULL, (LPBYTE)&dwValue, &cbValue);
2637
2639 return !!dwValue;
2640}
2641
2643{
2644 UINT CtlID;
2645 LPNMHDR lpnmh;
2646 LPNMLISTVIEW lpnmlv;
2647 NMLVDISPINFOW *lpdi;
2648 PCUITEMID_CHILD pidl;
2649 BOOL unused;
2650
2651 CtlID = wParam;
2652 lpnmh = (LPNMHDR)lParam;
2653 lpnmlv = (LPNMLISTVIEW)lpnmh;
2654 lpdi = (NMLVDISPINFOW *)lpnmh;
2655
2656 TRACE("%p CtlID=%u lpnmh->code=%x\n", this, CtlID, lpnmh->code);
2657
2658 switch (lpnmh->code)
2659 {
2660 case NM_SETFOCUS:
2661 TRACE("-- NM_SETFOCUS %p\n", this);
2662 OnSetFocus(0, 0, 0, unused);
2663 break;
2664 case NM_KILLFOCUS:
2665 TRACE("-- NM_KILLFOCUS %p\n", this);
2666 OnDeactivate();
2667 /* Notify the ICommDlgBrowser interface */
2668 OnStateChange(CDBOSC_KILLFOCUS);
2669 break;
2670 case NM_CUSTOMDRAW:
2671 TRACE("-- NM_CUSTOMDRAW %p\n", this);
2672 return CDRF_DODEFAULT;
2673 case NM_RELEASEDCAPTURE:
2674 TRACE("-- NM_RELEASEDCAPTURE %p\n", this);
2675 break;
2676 case NM_CLICK:
2677 TRACE("-- NM_CLICK %p\n", this);
2678 break;
2679 case NM_RCLICK:
2680 TRACE("-- NM_RCLICK %p\n", this);
2681 break;
2682 case NM_DBLCLK:
2683 TRACE("-- NM_DBLCLK %p\n", this);
2685 break;
2686 case NM_RETURN:
2687 TRACE("-- NM_RETURN %p\n", this);
2689 break;
2690 case HDN_ENDTRACKW:
2691 TRACE("-- HDN_ENDTRACKW %p\n", this);
2692 //nColumn1 = m_ListView.GetColumnWidth(0);
2693 //nColumn2 = m_ListView.GetColumnWidth(1);
2694 break;
2695 case LVN_DELETEITEM:
2696 TRACE("-- LVN_DELETEITEM %p\n", this);
2697 /*delete the pidl because we made a copy of it*/
2698 SHFree(reinterpret_cast<LPVOID>(lpnmlv->lParam));
2699 break;
2700 case LVN_DELETEALLITEMS:
2701 TRACE("-- LVN_DELETEALLITEMS %p\n", this);
2702 return FALSE;
2703 case LVN_INSERTITEM:
2704 TRACE("-- LVN_INSERTITEM (STUB)%p\n", this);
2705 break;
2706 case LVN_ITEMACTIVATE:
2707 TRACE("-- LVN_ITEMACTIVATE %p\n", this);
2708 OnStateChange(CDBOSC_SELCHANGE); // browser will get the IDataObject
2709 break;
2710 case LVN_COLUMNCLICK:
2711 {
2712 UINT foldercol = MapListColumnToFolderColumn(lpnmlv->iSubItem);
2713 HRESULT hr = S_FALSE;
2714 if (m_pSDParent)
2715 hr = m_pSDParent->ColumnClick(foldercol);
2716 if (hr != S_OK)
2717 hr = _DoFolderViewCB(SFVM_COLUMNCLICK, foldercol, 0);
2718 if (hr != S_OK)
2719 _Sort(lpnmlv->iSubItem);
2720 break;
2721 }
2722 case LVN_GETDISPINFOA:
2723 case LVN_GETDISPINFOW:
2724 TRACE("-- LVN_GETDISPINFO %p\n", this);
2725 pidl = _PidlByItem(lpdi->item);
2726
2727 if (lpdi->item.mask & LVIF_TEXT) /* text requested */
2728 {
2731 break;
2732
2733 if (lpnmh->code == LVN_GETDISPINFOA)
2734 {
2735 /* shouldn't happen */
2736 NMLVDISPINFOA *lpdiA = (NMLVDISPINFOA *)lpnmh;
2737 StrRetToStrNA( lpdiA->item.pszText, lpdiA->item.cchTextMax, &sd.str, NULL);
2738 TRACE("-- text=%s\n", lpdiA->item.pszText);
2739 }
2740 else /* LVN_GETDISPINFOW */
2741 {
2742 StrRetToStrNW( lpdi->item.pszText, lpdi->item.cchTextMax, &sd.str, NULL);
2743 TRACE("-- text=%s\n", debugstr_w(lpdi->item.pszText));
2744 }
2745 }
2746 if (lpdi->item.mask & LVIF_IMAGE)
2747 {
2749 }
2750 if (lpdi->item.mask & LVIF_STATE)
2751 {
2752 if ((lpdi->item.stateMask & LVIS_CUT) && GetItemAttributes(pidl, SFGAO_HIDDEN | SFGAO_GHOSTED))
2753 lpdi->item.state |= LVIS_CUT;
2754 }
2755 lpdi->item.mask |= LVIF_DI_SETITEM;
2756 break;
2757 case LVN_ITEMCHANGED:
2758 TRACE("-- LVN_ITEMCHANGED %p\n", this);
2759 if ((lpnmlv->uOldState ^ lpnmlv->uNewState) & (LVIS_SELECTED | LVIS_FOCUSED))
2760 {
2761 OnStateChange(CDBOSC_SELCHANGE); // browser will get the IDataObject
2762 // FIXME: Use LVIS_DROPHILITED instead in drag_notify_subitem
2764 {
2767 }
2768 _DoFolderViewCB(SFVM_SELECTIONCHANGED, NULL/* FIXME */, NULL/* FIXME */);
2769 }
2770 break;
2771 case LVN_BEGINDRAG:
2772 case LVN_BEGINRDRAG:
2773 TRACE("-- LVN_BEGINDRAG\n");
2774 if (GetSelections())
2775 {
2777 DWORD dwAttributes = SFGAO_CANCOPY | SFGAO_CANLINK;
2778 DWORD dwEffect = DROPEFFECT_MOVE;
2779
2780 if (SUCCEEDED(m_pSFParent->GetUIObjectOf(m_hWnd, m_cidl, m_apidl, IID_NULL_PPV_ARG(IDataObject, &pda))))
2781 {
2783
2784 if (SUCCEEDED(m_pSFParent->GetAttributesOf(m_cidl, m_apidl, &dwAttributes)))
2785 dwEffect |= dwAttributes & (SFGAO_CANCOPY | SFGAO_CANLINK);
2786
2788 if (SUCCEEDED(pda->QueryInterface(IID_PPV_ARG(IAsyncOperation, &piaso))))
2789 piaso->SetAsyncMode(TRUE);
2790
2791 DWORD dwEffect2;
2792
2793 m_pSourceDataObject = pda;
2794 m_ptFirstMousePos = params->ptAction;
2797
2798 HIMAGELIST big_icons, small_icons;
2799 Shell_GetImageLists(&big_icons, &small_icons);
2800 PCUITEMID_CHILD pidl = _PidlByItem(params->iItem);
2801 int iIcon = SHMapPIDLToSystemImageListIndex(m_pSFParent, pidl, 0);
2802 POINT ptItem;
2803 m_ListView.GetItemPosition(params->iItem, &ptItem);
2804
2805 ImageList_BeginDrag(big_icons, iIcon, params->ptAction.x - ptItem.x, params->ptAction.y - ptItem.y);
2806 DoDragDrop(pda, this, dwEffect, &dwEffect2);
2808 }
2809 }
2810 break;
2812 {
2813 TRACE("-- LVN_BEGINLABELEDITW %p\n", this);
2815 pidl = _PidlByItem(lpdi->item);
2816 DWORD fAttr = pidl ? GetItemAttributes(pidl, SFGAO_CANRENAME | SFGAO_FOLDER | SFGAO_FILESYSTEM) : 0;
2817 if (!hEdit || !(fAttr & SFGAO_CANRENAME))
2818 {
2819 MessageBeep(0xffffffff);
2820 return TRUE;
2821 }
2822
2823 WCHAR szName[MAX_PATH], *pszText = lpdi->item.pszText;
2824 if (SUCCEEDED(DisplayNameOfW(m_pSFParent, pidl, SHGDN_FOREDITING | SHGDN_INFOLDER,
2826 {
2827 pszText = szName;
2828 ::SetWindowText(hEdit, pszText);
2829 }
2830
2831 // smartass-renaming: See CORE-15242
2832 if (!(fAttr & SFGAO_FOLDER) && (fAttr & SFGAO_FILESYSTEM) &&
2833 (lpdi->item.mask & LVIF_TEXT) && !SelectExtOnRename())
2834 {
2836 WCHAR szFullPath[MAX_PATH];
2837 if (SHGetPathFromIDListW(pidlFull, szFullPath) && !SHELL_FS_HideExtension(szFullPath))
2838 {
2839 LPWSTR pchDotExt = PathFindExtensionW(pszText);
2840 ::PostMessageW(hEdit, EM_SETSEL, 0, pchDotExt - pszText);
2842 }
2843 }
2844
2845 INT cchLimit = 0;
2846 _DoFolderViewCB(SFVM_GETNAMELENGTH, (WPARAM)pidl, (LPARAM)&cchLimit);
2847 if (cchLimit)
2848 ::SendMessageW(hEdit, EM_SETLIMITTEXT, cchLimit, 0);
2850 m_isEditing = TRUE;
2851 return FALSE;
2852 }
2853 case LVN_ENDLABELEDITW:
2854 {
2855 TRACE("-- LVN_ENDLABELEDITW %p\n", this);
2857 if (!lpdi->item.pszText)
2858 return TRUE;
2859
2860 pidl = _PidlByItem(lpdi->item);
2861 // We have to copy the old PIDL because SetNameOf might generate a SHCNE_UPDATEITEM
2862 // and that notification can cause us to call LV_UpdateItem and free the old PIDL too soon.
2864 if (!pidlOld)
2865 {
2867 return FALSE;
2868 }
2869 PITEMID_CHILD pidlNew = NULL;
2870 HRESULT hr = m_pSFParent->SetNameOf(0, pidlOld, lpdi->item.pszText, SHGDN_INFOLDER, &pidlNew);
2871 if (SUCCEEDED(hr) && pidlNew)
2872 {
2873 int iNew = LV_FindItemByPidl(pidlNew);
2874 if (iNew != lpdi->item.iItem && iNew >= 0)
2875 ILFree(pidlNew);// A SHCNE has updated the item already
2876 else if (!LV_UpdateItem(lpdi->item.iItem, pidlNew))
2877 ILFree(pidlNew);
2878 OnStateChange(CDBOSC_RENAME);
2879 }
2880 else
2881 {
2882 ::PostMessageW(m_ListView, LVM_EDITLABEL, lpdi->item.iItem, 0); // Renaming failed, let the user try again
2883 }
2884 return FALSE;
2885 }
2886 default:
2887 TRACE("-- %p WM_COMMAND %x unhandled\n", this, lpnmh->code);
2888 break;
2889 }
2890
2891 return 0;
2892}
2893
2894// This is just a quick hack to make the desktop work correctly.
2895// ITranslateShellChangeNotify's IsChildID is undocumented, but most likely the
2896// way that a folder should know if it should update upon a change notification.
2897// It is exported by merged folders at a minimum.
2899{
2900 if (!pidl1 || !pidl2)
2901 return FALSE;
2902 if (ILIsParent(pidl1, pidl2, TRUE))
2903 return TRUE;
2904
2905 CComHeapPtr<ITEMIDLIST_ABSOLUTE> pidl2Clone(ILClone(pidl2));
2906 ILRemoveLastID(pidl2Clone);
2907 return ILIsEqual(pidl1, pidl2Clone);
2908}
2909
2911{
2912 // The change notify can come before WM_CREATE
2913 if (!m_ListView)
2914 return FALSE;
2915
2916 HANDLE hChange = (HANDLE)wParam;
2917 DWORD dwProcID = (DWORD)lParam;
2918 PIDLIST_ABSOLUTE *Pidls;
2919 LONG lEvent;
2920 HANDLE hLock = SHChangeNotification_Lock(hChange, dwProcID, &Pidls, &lEvent);
2921 if (hLock == NULL)
2922 {
2923 ERR("hLock == NULL\n");
2924 return FALSE;
2925 }
2926
2927 TRACE("(%p)(%p,%p,%p)\n", this, Pidls[0], Pidls[1], lParam);
2928
2930 {
2932 return FALSE;
2933 }
2934
2935 // Translate child IDLs.
2936 // SHSimpleIDListFromPathW creates fake PIDLs (lacking some attributes)
2937 lEvent &= ~SHCNE_INTERRUPT;
2938 HRESULT hr;
2939 PITEMID_CHILD child0 = NULL, child1 = NULL;
2940 CComHeapPtr<ITEMIDLIST_RELATIVE> pidl0Temp, pidl1Temp;
2942 {
2943 if (_ILIsSpecialFolder(Pidls[0]) || ILIsParentOrSpecialParent(m_pidlParent, Pidls[0]))
2944 {
2945 child0 = ILFindLastID(Pidls[0]);
2946 hr = SHGetRealIDL(m_pSFParent, child0, &pidl0Temp);
2947 if (SUCCEEDED(hr))
2948 child0 = pidl0Temp;
2949 }
2950 if (_ILIsSpecialFolder(Pidls[1]) || ILIsParentOrSpecialParent(m_pidlParent, Pidls[1]))
2951 {
2952 child1 = ILFindLastID(Pidls[1]);
2953 hr = SHGetRealIDL(m_pSFParent, child1, &pidl1Temp);
2954 if (SUCCEEDED(hr))
2955 child1 = pidl1Temp;
2956 }
2957 }
2958
2959 switch (lEvent)
2960 {
2961 case SHCNE_MKDIR:
2962 case SHCNE_CREATE:
2963 case SHCNE_DRIVEADD:
2964 if (!child0)
2965 break;
2966 if (LV_FindItemByPidl(child0) < 0)
2967 LV_AddItem(child0);
2968 else
2969 LV_UpdateItem(child0);
2970 break;
2971 case SHCNE_RMDIR:
2972 case SHCNE_DELETE:
2973 case SHCNE_DRIVEREMOVED:
2974 if (child0)
2975 LV_DeleteItem(child0);
2976 break;
2977 case SHCNE_RENAMEFOLDER:
2978 case SHCNE_RENAMEITEM:
2979 if (child0 && child1)
2980 LV_RenameItem(child0, child1);
2981 else if (child0)
2982 LV_DeleteItem(child0);
2983 else if (child1)
2984 LV_AddItem(child1);
2985 break;
2986 case SHCNE_UPDATEITEM:
2987 if (child0)
2988 LV_UpdateItem(child0);
2989 break;
2990 case SHCNE_UPDATEIMAGE:
2992 case SHCNE_MEDIAREMOVED:
2993 case SHCNE_ASSOCCHANGED:
2995 break;
2996 case SHCNE_UPDATEDIR:
2997 case SHCNE_ATTRIBUTES:
2998 if (child0)
2999 LV_UpdateItem(child0);
3000 else
3001 Refresh();
3003 break;
3004 case SHCNE_FREESPACE:
3006 break;
3007 }
3008
3010 return TRUE;
3011}
3012
3015
3017{
3018 if (!m_pCM)
3019 {
3020 /* no menu */
3021 ERR("no context menu\n");
3022 return FALSE;
3023 }
3024
3025 // lParam of WM_DRAWITEM WM_MEASUREITEM contains a menu id and
3026 // this also needs to be changed to a menu identifier offset
3027 UINT CmdID;
3028 HRESULT hres = SHGetMenuIdFromMenuMsg(uMsg, lParam, &CmdID);
3029 if (SUCCEEDED(hres))
3031
3032 /* Forward the message to the IContextMenu2 */
3035
3036 return (SUCCEEDED(hres));
3037}
3038
3040{
3041 /* Wallpaper setting affects drop shadows effect */
3042 if (wParam == SPI_SETDESKWALLPAPER || wParam == 0)
3044
3045 m_ListView.SendMessage(uMsg, wParam, lParam);
3046 return S_OK;
3047}
3048
3050{
3051 HMENU hmenu = (HMENU) wParam;
3052 int nPos = LOWORD(lParam);
3053 UINT menuItemId;
3054
3055 if (m_pCM)
3056 OnCustomItem(uMsg, wParam, lParam, bHandled);
3057
3059
3060 if (GetSelections() == 0)
3061 {
3068 }
3069 else
3070 {
3071 // FIXME: Check copyable
3078 }
3079
3080 /* Lets try to find out what the hell wParam is */
3081 if (hmenu == GetSubMenu(m_hMenu, nPos))
3082 menuItemId = ReallyGetMenuItemID(m_hMenu, nPos);
3083 else if (hViewMenu && hmenu == GetSubMenu(hViewMenu, nPos))
3084 menuItemId = ReallyGetMenuItemID(hViewMenu, nPos);
3085 else if (m_hContextMenu && hmenu == GetSubMenu(m_hContextMenu, nPos))
3086 menuItemId = ReallyGetMenuItemID(m_hContextMenu, nPos);
3087 else
3088 return FALSE;
3089
3090 switch (menuItemId)
3091 {
3092 case FCIDM_MENU_FILE:
3093 FillFileMenu();
3094 break;
3095 case FCIDM_MENU_VIEW:
3096 case FCIDM_SHVIEW_VIEW:
3098 break;
3101 break;
3102 }
3103
3104 return FALSE;
3105}
3106
3108{
3109 bHandled = TRUE;
3110 return m_ClipboardChain.HandleChangeCBChain(wParam, lParam);
3111}
3112
3114{
3115 bHandled = TRUE;
3116 const LRESULT res = m_ClipboardChain.HandleDrawClipboard(wParam, lParam);
3117 if (m_HasCutItems)
3118 {
3119 m_ClipboardChain.Unhook(m_hWnd);
3120 m_HasCutItems = false;
3121 m_ListView.SetItemState(-1, 0, LVIS_CUT); // Somebody copied or pasted, nothing can be "cut" anymore
3122 m_ListView.SendMessageW(LVM_SETCALLBACKMASK, m_ListView.SendMessageW(LVM_GETCALLBACKMASK, 0, 0) | LVIS_CUT, 0);
3123 }
3124 return res;
3125}
3126
3128{
3129 for (UINT i = 0, c = m_ListView.GetItemCount(); i < c; ++i)
3130 m_ListView.SetItemState(i, GetItemAttributes(i, SFGAO_HIDDEN | SFGAO_GHOSTED) ? LVIS_CUT : 0, LVIS_CUT);
3131}
3132
3133// The INTERFACE of the IShellView object
3134
3136{
3137 TRACE("(%p)\n", this);
3138
3139 *phWnd = m_hWnd;
3140
3141 return S_OK;
3142}
3143
3145{
3146 FIXME("(%p) stub\n", this);
3147
3148 return E_NOTIMPL;
3149}
3150
3151// FIXME: use the accel functions
3153{
3154 if (m_isEditing)
3155 return S_FALSE;
3156
3157 if (lpmsg->message >= WM_KEYFIRST && lpmsg->message <= WM_KEYLAST)
3158 {
3159 if (::TranslateAcceleratorW(m_hWnd, m_hAccel, lpmsg) != 0)
3160 return S_OK;
3161
3162 TRACE("-- key=0x%04lx\n", lpmsg->wParam);
3163 }
3164
3165 return m_pShellBrowser ? m_pShellBrowser->TranslateAcceleratorSB(lpmsg, 0) : S_FALSE;
3166}
3167
3169{
3170 FIXME("(%p)\n", this);
3171 return E_NOTIMPL;
3172}
3173
3175{
3176 TRACE("(%p)->(state=%x)\n", this, uState);
3177
3178 // don't do anything if the state isn't changing
3179 if (m_uState == uState)
3180 return S_OK;
3181
3182 // OnActivate handles the menu merging and internal state
3183 DoActivate(uState);
3184
3185 // only do this if we are active
3186 if (uState != SVUIA_DEACTIVATE)
3187 {
3189
3190 // Set the text for the status bar
3192 }
3193
3194 return S_OK;
3195}
3196
3198{
3199 TRACE("(%p)\n", this);
3200
3202
3204 FillList();
3205
3206 return S_OK;
3207}
3208
3210{
3211 return CreateViewWindow3(psb, lpPrevView, SV3CVW3_DEFAULT,
3212 (FOLDERFLAGS)lpfs->fFlags, (FOLDERFLAGS)lpfs->fFlags, (FOLDERVIEWMODE)lpfs->ViewMode, NULL, prcView, phWnd);
3213}
3214
3216{
3217 TRACE("(%p)\n", this);
3218
3219 /* Make absolutely sure all our UI is cleaned up */
3221
3222 if (m_hAccel)
3223 {
3224 // MSDN: Accelerator tables loaded from resources are freed automatically when application terminates
3225 m_hAccel = NULL;
3226 }
3227
3229 {
3232 }
3233
3234 if (m_hMenuViewModes)
3235 {
3238 }
3239
3240 if (m_hMenu)
3241 {
3243 m_hMenu = NULL;
3244 }
3245
3246 if (m_ListView)
3247 {
3248 m_ListView.DestroyWindow();
3249 }
3250
3251 if (m_hWnd)
3252 {
3254 DestroyWindow();
3255 }
3256
3259
3260 return S_OK;
3261}
3262
3264{
3265 TRACE("(%p)->(%p) vmode=%x flags=%x\n", this, lpfs,
3267
3268 if (!lpfs)
3269 return E_INVALIDARG;
3270
3271 *lpfs = m_FolderSettings;
3272 return S_OK;
3273}
3274
3276{
3277 TRACE("(%p)->(0x%lX, %p, %p)\n", this, dwReserved, lpfn, lparam);
3278
3281 return S_OK;
3282}
3283
3285{
3286 ULONG read;
3287 HRESULT hr = pS->Read(buffer, cb, &read);
3288 return FAILED(hr) ? hr : (cb == read ? S_OK : HResultFromWin32(ERROR_MORE_DATA));
3289}
3290
3292{
3293 DWORD value;
3295 return SUCCEEDED(hr) ? value : def;
3296}
3297
3299{
3300 CLSID clsid;
3302 if (SUCCEEDED(hr))
3303 {
3304 WCHAR path[MAX_PATH], name[39];
3305 wsprintfW(path, L"%s\\%s", REGSTR_PATH_EXPLORER, L"Streams\\Default");
3307 *ppStream = SHOpenRegStream2W(HKEY_CURRENT_USER, path, name, Stgm);
3308 hr = *ppStream ? S_OK : E_FAIL;
3309 }
3310 return hr;
3311}
3312
3314{
3316 if (FAILED(hr))
3317 return hr;
3318 if (cols.Signature != PERSISTCOLUMNS::SIG || cols.Count > cols.MAXCOUNT)
3320 return Read(pS, &cols.Columns, sizeof(*cols.Columns) * cols.Count);
3321}
3322
3324{
3326 PERSISTCOLUMNS cols;
3329 bool fallback = false;
3330 HRESULT hrColumns = E_FAIL;
3332 if (SUCCEEDED(hr))
3333 {
3334 DWORD data;
3335 if (FAILED(hr = SHPropertyBag_ReadDWORD(pPB, L"Mode", &data)))
3336 goto loadfallback;
3338 cvs.FolderSettings.fFlags = ReadDWORD(pPB, L"FFlags", FWF_NOGROUPING);
3339 data = ReadDWORD(pPB, L"Sort", ~0ul);
3341 cvs.SortDir = (INT8)ReadDWORD(pPB, L"SortDir", 1);
3342 if (SUCCEEDED(hrColumns = SHPropertyBag_ReadStream(pPB, L"ColInfo", &pS)))
3343 hrColumns = LoadColumnsStream(cols, pS);
3344 }
3345 else
3346 {
3347 if (FAILED(hr = (m_pShellBrowser ? m_pShellBrowser->GetViewStateStream(STGM_READ, &pS) : E_UNEXPECTED)))
3348 {
3349 loadfallback:
3351 fallback = true;
3352 }
3353 if (FAILED(hr) || FAILED(hr = Read(pS, &cvs, sizeof(cvs))))
3354 return hr;
3355 if (cvs.Signature != cvs.SIG)
3357 hrColumns = LoadColumnsStream(cols, pS);
3358 }
3360 m_FolderSettings.fFlags &= ~cvs.VALIDFWF;
3362 if (SUCCEEDED(hrColumns))
3363 {
3364 BOOL failed = FALSE;
3365 if ((m_LoadColumnsList = DPA_Create(cols.Count)) != NULL)
3366 {
3367 for (UINT i = 0; i < cols.Count; ++i)
3368 {
3369 failed |= !DPA_SetPtr(m_LoadColumnsList, i, UlongToPtr(cols.Columns[i]));
3370 }
3371 }
3372 if (failed || !cols.Count)
3373 {
3376 }
3377 }
3380 m_sortInfo.Direction = cvs.SortDir > 0 ? 1 : -1;
3382 return hr;
3383}
3384
3386{
3387 if (!m_ListView.m_hWnd)
3388 return E_UNEXPECTED;
3391 cvs.SortColId = sortcol >= 0 ? (WORD)sortcol : 0;
3393 PERSISTCOLUMNS cols;
3395 cols.Count = 0;
3396 LVCOLUMN lvc;
3397 lvc.mask = LVCF_WIDTH;
3398 for (UINT i = 0, j = 0; i < PERSISTCOLUMNS::MAXCOUNT && ListView_GetColumn(m_ListView, j, &lvc); ++j)
3399 {
3401 if (SUCCEEDED(hr))
3402 {
3403 cols.Columns[i] = MAKELONG(hr, lvc.cx);
3404 cols.Count = ++i;
3405 }
3406 }
3407 UINT cbColumns = FIELD_OFFSET(PERSISTCOLUMNS, Columns) + (sizeof(*cols.Columns) * cols.Count);
3409
3410 IPropertyBag *pPB;
3411 HRESULT hr = S_OK;
3412 if (pStream)
3413 {
3414 pStream->AddRef();
3415 goto stream;
3416 }
3418 if (SUCCEEDED(hr))
3419 {
3420 UINT uViewMode;
3421 GetCurrentViewMode(&uViewMode);
3422 hr = SHPropertyBag_WriteDWORD(pPB, L"Mode", uViewMode);
3424 SHPropertyBag_WriteDWORD(pPB, L"Sort", cvs.SortColId);
3425 SHPropertyBag_WriteDWORD(pPB, L"SortDir", cvs.SortDir);
3426 pStream = cols.Count ? SHCreateMemStream((LPBYTE)&cols, cbColumns) : NULL;
3427 if (!pStream || FAILED(SHPropertyBag_WriteStream(pPB, L"ColInfo", pStream)))
3428 SHPropertyBag_Delete(pPB, L"ColInfo");
3429#if 0 // TODO
3431 memcpy(name, L"ItemPos", sizeof(L"ItemPos"));
3432 if (SHGetPerScreenResName(name + 7, _countof(name) - 7, 0))
3433 {
3434 if (GetAutoArrange() == S_FALSE)
3435 // TODO: Save listview item positions
3436 else
3438 }
3439#endif
3440 pPB->Release();
3441 }
3442 else if (SUCCEEDED(hr = (m_pShellBrowser ? m_pShellBrowser->GetViewStateStream(STGM_WRITE, &pStream) : E_UNEXPECTED)))
3443 {
3444 stream:
3445 ULONG written;
3446 cvs.Signature = cvs.SIG;
3448 hr = pStream->Write(&cvs, sizeof(cvs), &written);
3449 if (SUCCEEDED(hr))
3450 hr = pStream->Write(&cols, cbColumns, &written);
3451 }
3452 // TODO: else if (SUCCEEDED(_DoFolderViewCB(SFVM_GETCOLUMNSTREAM)))
3453 if (pStream)
3454 pStream->Release();
3455 return hr;
3456}
3457
3459{
3461 return SaveViewState(NULL);
3462 return S_FALSE;
3463}
3464
3465#define UPDATEFOLDERVIEWFLAGS(bits, bit, set) ( (bits) = ((bits) & ~(bit)) | ((set) ? (bit) : 0) )
3467{
3471}
3472
3474{
3475 int i;
3476
3477 TRACE("(%p)->(pidl=%p, 0x%08x) stub\n", this, pidl, uFlags);
3478
3479 if (!m_ListView)
3480 {
3481 ERR("!m_ListView\n");
3482 return E_FAIL;
3483 }
3484
3485 i = LV_FindItemByPidl(pidl);
3486 if (i == -1)
3487 return S_OK;
3488
3489 LVITEMW lvItem = {0};
3490 lvItem.mask = LVIF_STATE;
3492
3493 while (m_ListView.GetItem(&lvItem))
3494 {
3495 if (lvItem.iItem == i)
3496 {
3497 if (uFlags & SVSI_SELECT)
3498 lvItem.state |= LVIS_SELECTED;
3499 else
3500 lvItem.state &= ~LVIS_SELECTED;
3501
3502 if (uFlags & SVSI_FOCUSED)
3503 lvItem.state |= LVIS_FOCUSED;
3504 else
3505 lvItem.state &= ~LVIS_FOCUSED;
3506 }
3507 else
3508 {
3509 if (uFlags & SVSI_DESELECTOTHERS)
3510 {
3511 lvItem.state &= ~LVIS_SELECTED;
3512 }
3513 lvItem.state &= ~LVIS_FOCUSED;
3514 }
3515
3516 m_ListView.SetItem(&lvItem);
3517 lvItem.iItem++;
3518 }
3519
3520 if (uFlags & SVSI_ENSUREVISIBLE)
3522
3523 if((uFlags & SVSI_EDIT) == SVSI_EDIT)
3525
3526 return S_OK;
3527}
3528
3530{
3532
3533 TRACE("(%p)->(uItem=0x%08x,\n\tIID=%s, ppv=%p)\n", this, uItem, debugstr_guid(&riid), ppvOut);
3534
3535 if (!ppvOut)
3536 return E_INVALIDARG;
3537
3538 *ppvOut = NULL;
3539
3540 switch (uItem)
3541 {
3542 case SVGIO_BACKGROUND:
3543 if (IsEqualIID(riid, IID_IContextMenu))
3544 {
3547 return hr;
3548
3549 IUnknown_SetSite(*((IUnknown**)ppvOut), (IShellView *)this);
3550 }
3551 else if (IsEqualIID(riid, IID_IDispatch))
3552 {
3554 {
3557 return hr;
3558 }
3559 hr = m_pShellFolderViewDual->QueryInterface(riid, ppvOut);
3560 }
3561 break;
3562 case SVGIO_SELECTION:
3563 GetSelections();
3564 hr = m_pSFParent->GetUIObjectOf(m_hWnd, m_cidl, m_apidl, riid, 0, ppvOut);
3566 return hr;
3567
3568 if (IsEqualIID(riid, IID_IContextMenu))
3569 IUnknown_SetSite(*((IUnknown**)ppvOut), (IShellView *)this);
3570
3571 break;
3572 }
3573
3574 TRACE("-- (%p)->(interface=%p)\n", this, *ppvOut);
3575
3576 return hr;
3577}
3578
3580{
3584 mode = temp;
3585 return mode;
3586}
3587
3589{
3590 TRACE("(%p)->(%p), stub\n", this, pViewMode);
3591
3592 if (!pViewMode)
3593 return E_INVALIDARG;
3594
3595 *pViewMode = m_FolderSettings.ViewMode;
3596 return S_OK;
3597}
3598
3600{
3601 DWORD dwStyle;
3602 TRACE("(%p)->(%u), stub\n", this, ViewMode);
3603
3604 /* It's not redundant to check FVM_AUTO because it's a (UINT)-1 */
3605 if (((INT)ViewMode < FVM_FIRST || (INT)ViewMode > FVM_LAST) && ((INT)ViewMode != FVM_AUTO))
3606 return E_INVALIDARG;
3607
3608 /* Windows before Vista uses LVM_SETVIEW and possibly
3609 LVM_SETEXTENDEDLISTVIEWSTYLE to set the style of the listview,
3610 while later versions seem to accomplish this through other
3611 means. */
3612 switch (ViewMode)
3613 {
3614 case FVM_ICON:
3615 dwStyle = LVS_ICON;
3616 break;
3617 case FVM_DETAILS:
3618 dwStyle = LVS_REPORT;
3619 break;
3620 case FVM_SMALLICON:
3621 dwStyle = LVS_SMALLICON;
3622 break;
3623 case FVM_LIST:
3624 dwStyle = LVS_LIST;
3625 break;
3626 default:
3627 {
3628 FIXME("ViewMode %d not implemented\n", ViewMode);
3629 dwStyle = LVS_LIST;
3630 break;
3631 }
3632 }
3633
3634 m_ListView.ModifyStyle(LVS_TYPEMASK, dwStyle);
3635
3636 /* This will not necessarily be the actual mode set above.
3637 This mimics the behavior of Windows XP. */
3638 m_FolderSettings.ViewMode = ViewMode;
3639
3640 return S_OK;
3641}
3642
3644{
3645 if (m_pSFParent == NULL)
3646 return E_FAIL;
3647
3648 return m_pSFParent->QueryInterface(riid, ppv);
3649}
3650
3652{
3653 PCUITEMID_CHILD pidl = _PidlByItem(iItemIndex);
3654 if (pidl)
3655 {
3656 *ppidl = ILClone(pidl);
3657 return S_OK;
3658 }
3659
3660 *ppidl = 0;
3661 return E_INVALIDARG;
3662}
3663
3665{
3666 TRACE("(%p)->(%u %p)\n", this, uFlags, pcItems);
3668 FIXME("some flags unsupported, %x\n", uFlags & ~(SVGIO_ALLVIEW | SVGIO_SELECTION));
3671 else
3673 return S_OK;
3674}
3675
3677{
3678 return E_NOTIMPL;
3679}
3680
3682{
3683 TRACE("(%p)->(%p)\n", this, piItem);
3684
3685 *piItem = m_ListView.GetSelectionMark();
3686
3687 return S_OK;
3688}
3689
3691{
3692 TRACE("(%p)->(%p)\n", this, piItem);
3693
3694 *piItem = m_ListView.GetNextItem(-1, LVNI_FOCUSED);
3695
3696 return S_OK;
3697}
3698
3700{
3701 if (!m_ListView)
3702 {
3703 ERR("!m_ListView\n");
3704 return E_FAIL;
3705 }
3706
3707 int lvIndex = LV_FindItemByPidl(pidl);
3708 if (lvIndex == -1 || ppt == NULL)
3709 return E_INVALIDARG;
3710
3711 m_ListView.GetItemPosition(lvIndex, ppt);
3712 return S_OK;
3713}
3714
3716{
3717 TRACE("(%p)->(%p)\n", this, ppt);
3718
3719 if (!m_ListView)
3720 {
3721 ERR("!m_ListView\n");
3722 return S_FALSE;
3723 }
3724
3725 if (ppt)
3726 {
3727 SIZE spacing;
3728 m_ListView.GetItemSpacing(spacing);
3729
3730 ppt->x = spacing.cx;
3731 ppt->y = spacing.cy;
3732 }
3733
3734 return S_OK;
3735}
3736
3738{
3739 return E_NOTIMPL;
3740}
3741
3743{
3744 return ((m_ListView.GetStyle() & LVS_AUTOARRANGE) ? S_OK : S_FALSE);
3745}
3746
3748{
3749 DWORD dwExStyle = (DWORD)m_ListView.SendMessage(LVM_GETEXTENDEDLISTVIEWSTYLE, 0, 0);
3750 return ((dwExStyle & LVS_EX_SNAPTOGRID) ? S_OK : S_FALSE);
3751}
3752
3754{
3755 LVITEMW lvItem;
3756
3757 TRACE("(%p)->(%d, %x)\n", this, iItem, dwFlags);
3758
3759 lvItem.state = 0;
3760 lvItem.stateMask = LVIS_SELECTED;
3761
3762 if (dwFlags & SVSI_ENSUREVISIBLE)
3763 m_ListView.EnsureVisible(iItem, 0);
3764
3765 /* all items */
3766 if (dwFlags & SVSI_DESELECTOTHERS)
3768
3769 /* this item */
3770 if (dwFlags & SVSI_SELECT)
3771 lvItem.state |= LVIS_SELECTED;
3772
3773 if (dwFlags & SVSI_FOCUSED)
3774 lvItem.stateMask |= LVIS_FOCUSED;
3775
3776 m_ListView.SetItemState(iItem, lvItem.state, lvItem.stateMask);
3777
3778 if ((dwFlags & SVSI_EDIT) == SVSI_EDIT)
3779 m_ListView.EditLabel(iItem);
3780
3781 return S_OK;
3782}
3783
3785{
3787
3788 /* Reset the selection */
3790
3791 int lvIndex;
3792 for (UINT i = 0 ; i < cidl; i++)
3793 {
3794 lvIndex = LV_FindItemByPidl(apidl[i]);
3795 if (lvIndex != -1)
3796 {
3797 SelectItem(lvIndex, dwFlags);
3798 m_ListView.SetItemPosition(lvIndex, &apt[i]);
3799 }
3800 }
3801
3802 return S_OK;
3803}
3804
3805
3806// IShellView2 implementation
3807
3809{
3810 FIXME("(%p)->(%p, %lu) stub\n", this, view_guid, view_type);
3811 return E_NOTIMPL;
3812}
3813
3815{
3816 return CreateViewWindow3(view_params->psbOwner, view_params->psvPrev,
3817 SV3CVW3_DEFAULT, (FOLDERFLAGS)view_params->pfs->fFlags, (FOLDERFLAGS)view_params->pfs->fFlags,
3818 (FOLDERVIEWMODE)view_params->pfs->ViewMode, view_params->pvid, view_params->prcView, &view_params->hwndView);
3819}
3820
3822{
3823 OLEMENUGROUPWIDTHS omw = { { 0, 0, 0, 0, 0, 0 } };
3824 const UINT SUPPORTED_SV3CVW3 = SV3CVW3_FORCEVIEWMODE | SV3CVW3_FORCEFOLDERFLAGS;
3825 const UINT IGNORE_FWF = FWF_OWNERDATA; // FIXME: Support this
3826
3827 *hwnd = NULL;
3828
3829 TRACE("(%p)->(shlview=%p shlbrs=%p rec=%p hwnd=%p vmode=%x flags=%x)\n", this, psvPrevious, psb, prcView, hwnd, mode, flags);
3830 if (prcView != NULL)
3831 TRACE("-- left=%i top=%i right=%i bottom=%i\n", prcView->left, prcView->top, prcView->right, prcView->bottom);
3832
3833 /* Validate the Shell Browser */
3834 if (psb == NULL || m_hWnd)
3835 return E_UNEXPECTED;
3836
3837 if (view_flags & ~SUPPORTED_SV3CVW3)
3838 FIXME("unsupported view flags 0x%08x\n", view_flags & ~SUPPORTED_SV3CVW3);
3839
3840 if (mode == FVM_AUTO)
3842
3843 /* Set up the member variables */
3844 m_pShellBrowser = psb;
3846 m_FolderSettings.fFlags = (mask & flags) & ~IGNORE_FWF;
3847
3848 if (view_id)
3849 {
3850 if (IsEqualIID(*view_id, VID_LargeIcons))
3852 else if (IsEqualIID(*view_id, VID_SmallIcons))
3854 else if (IsEqualIID(*view_id, VID_List))
3856 else if (IsEqualIID(*view_id, VID_Details))
3858 else if (IsEqualIID(*view_id, VID_Thumbnails))
3860 else if (IsEqualIID(*view_id, VID_Tile))
3862 else if (IsEqualIID(*view_id, VID_ThumbStrip))
3864 else
3865 FIXME("Ignoring unrecognized VID %s\n", debugstr_guid(view_id));
3866 }
3867 const UINT requestedViewMode = m_FolderSettings.ViewMode;
3868
3869 /* Get our parent window */
3870 m_pShellBrowser->GetWindow(&m_hWndParent);
3872
3873 /* Try to get the ICommDlgBrowserInterface, adds a reference !!! */
3876 {
3877 TRACE("-- CommDlgBrowser\n");
3878 }
3879
3880 LoadViewState();
3881 if (view_flags & SV3CVW3_FORCEVIEWMODE)
3882 m_FolderSettings.ViewMode = requestedViewMode;
3883 if (view_flags & SV3CVW3_FORCEFOLDERFLAGS)
3884 m_FolderSettings.fFlags = (mask & flags) & ~IGNORE_FWF;
3885
3886 RECT rcView = *prcView;
3888 if (m_hWnd == NULL)
3889 return E_FAIL;
3890
3891 *hwnd = m_hWnd;
3892
3893 CheckToolbar();
3894
3895 if (!*hwnd)
3896 return E_FAIL;
3897
3899
3901 UpdateWindow();
3902
3903 if (!m_hMenu)
3904 {
3905 m_hMenu = CreateMenu();
3906 m_pShellBrowser->InsertMenusSB(m_hMenu, &omw);
3907 TRACE("-- after fnInsertMenusSB\n");
3908 }
3909
3910 _MergeToolbar();
3911
3912 return S_OK;
3913}
3914
3916{
3917 FIXME("(%p)->(%p) stub\n", this, new_pidl);
3918 return E_NOTIMPL;
3919}
3920
3922{
3923 FIXME("(%p)->(%p, %u, %p) stub\n", this, item, flags, point);
3924 return E_NOTIMPL;
3925}
3926
3927// IShellFolderView implementation
3928
3930{
3931 _Sort(LOWORD(sort & SHCIDS_COLUMNMASK));
3932 return S_OK;
3933}
3934
3936{
3937 int col = m_sortInfo.ListColumn;
3938 *sort = col != LISTVIEW_SORT_INFO::UNSPECIFIEDCOLUMN ? col : 0;
3940}
3941
3943{
3945 return S_OK;
3946}
3947
3949{
3950 m_ListView.ModifyStyle(0, LVS_AUTOARRANGE);
3952 return S_OK;
3953}
3954
3956{
3957 TRACE("(%p)->(%p %p)\n", this, pidl, item);
3958 if (!m_ListView)
3959 {
3960 ERR("!m_ListView\n");
3961 return E_FAIL;
3962 }
3963 *item = LV_AddItem(pidl);
3964 return (int)*item >= 0 ? S_OK : E_OUTOFMEMORY;
3965}
3966
3968{
3969 TRACE("(%p)->(%p %d)\n", this, pidl, item);
3970 return Item(item, pidl);
3971}
3972
3974{
3975 TRACE("(%p)->(%p %p)\n", this, pidl, item);
3976
3977 if (!m_ListView)
3978 {
3979 ERR("!m_ListView\n");
3980 return E_FAIL;
3981 }
3982
3983 if (pidl)
3984 {
3987 }
3988 else
3989 {
3990 *item = 0;
3992 }
3993
3994 return S_OK;
3995}
3996
3998{
3999 TRACE("(%p)->(%p)\n", this, count);
4001 return S_OK;
4002}
4003
4005{
4006 FIXME("(%p)->(%d %x) stub\n", this, count, flags);
4007 return E_NOTIMPL;
4008}
4009
4011{
4012 FIXME("(%p)->(%p %p %p) stub\n", this, pidl_old, pidl_new, item);
4013 return E_NOTIMPL;
4014}
4015
4017{
4018 FIXME("(%p)->(%p %p) stub\n", this, pidl, item);
4019 return E_NOTIMPL;
4020}
4021
4023{
4024 TRACE("(%p)->(%d)\n", this, redraw);
4025 if (m_ListView)
4027 return S_OK;
4028}
4029
4031{
4033 return S_OK;
4034}
4035
4037{
4038 TRACE("(%p)->(%p %p)\n", this, pidl, items);
4039
4040 *items = GetSelections();
4041
4042 if (*items)
4043 {
4044 *pidl = static_cast<PCUITEMID_CHILD *>(LocalAlloc(0, *items * sizeof(PCUITEMID_CHILD)));
4045 if (!*pidl)
4046 {
4047 return E_OUTOFMEMORY;
4048 }
4049
4050 /* it's documented that caller shouldn't PIDLs, only array itself */
4051 memcpy(*pidl, m_apidl, *items * sizeof(PCUITEMID_CHILD));
4052 }
4053
4054 return S_OK;
4055}
4056
4058{
4059 if ((m_iDragOverItem == -1 || m_pCurDropTarget == NULL) &&
4061 {
4062 return S_OK;
4063 }
4064
4065 return S_FALSE;
4066}
4067
4069{
4070 if (!pt)
4071 return E_INVALIDARG;
4072
4074 return S_OK;
4075}
4076
4078{
4079 FIXME("(%p)->(%p) stub\n", this, pt);
4080 return E_NOTIMPL;
4081}
4082
4084{
4085 TRACE("(%p)->(%p)\n", this, obj);
4086 return E_NOTIMPL;
4087}
4088
4090{
4091 FIXME("(%p)->(%p %p) stub\n", this, pidl, pt);
4092 return E_NOTIMPL;
4093}
4094
4096{
4097 FIXME("(%p)->(%p) stub\n", this, drop_target);
4098 return E_NOTIMPL;
4099}
4100
4102{
4103 if (!move)
4104 return S_OK;
4105
4106 UINT CutCount = 0;
4107 for (int i = -1; (i = m_ListView.GetNextItem(i, LVNI_SELECTED)) != -1;)
4108 {
4109 if (!CutCount++)
4110 {
4111 // Turn off the LVIS_CUT LVM_SETCALLBACKMASK optimization
4112 m_ListView.SendMessageW(LVM_SETCALLBACKMASK, m_ListView.SendMessageW(LVM_GETCALLBACKMASK, 0, 0) & ~LVIS_CUT, 0);
4114 }
4116 }
4117 if (CutCount)
4118 {
4120 m_HasCutItems = true;
4121 }
4122 return S_OK;
4123}
4124
4126{
4127 FIXME("(%p)->(%p) stub\n", this, obj);
4128 return E_NOTIMPL;
4129}
4130
4132{
4133 FIXME("(%p)->(%p) stub\n", this, spacing);
4134 return E_NOTIMPL;
4135}
4136
4137HRESULT STDMETHODCALLTYPE CDefView::SetCallback(IShellFolderViewCB *new_cb, IShellFolderViewCB **old_cb)
4138{
4139 if (old_cb)
4140 *old_cb = m_pShellFolderViewCB.Detach();
4141
4142 m_pShellFolderViewCB = new_cb;
4144 if (new_cb)
4145 new_cb->QueryInterface(IID_PPV_ARG(IFolderFilter, &m_pFolderFilter));
4146 return S_OK;
4147}
4148
4150{
4151 FIXME("(%p)->(%d) stub\n", this, flags);
4152 return E_NOTIMPL;
4153}
4154
4156{
4157 TRACE("(%p)->(%p)\n", this, support);
4158 return S_OK;
4159}
4160
4162{
4163 FIXME("(%p)->(%p) stub\n", this, disp);
4164 return E_NOTIMPL;
4165}
4166
4167HRESULT WINAPI CDefView::QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD *prgCmds, OLECMDTEXT *pCmdText)
4168{
4169 FIXME("(%p)->(%p(%s) 0x%08x %p %p\n",
4170 this, pguidCmdGroup, debugstr_guid(pguidCmdGroup), cCmds, prgCmds, pCmdText);
4171
4172 if (!prgCmds)
4173 return E_INVALIDARG;
4174
4175 for (UINT i = 0; i < cCmds; i++)
4176 {
4177 FIXME("\tprgCmds[%d].cmdID = %d\n", i, prgCmds[i].cmdID);
4178 prgCmds[i].cmdf = 0;
4179 }
4180
4181 return OLECMDERR_E_UNKNOWNGROUP;
4182}
4183
4185// ISVOleCmdTarget_Exec(IOleCommandTarget)
4186//
4187// nCmdID is the OLECMDID_* enumeration
4188HRESULT WINAPI CDefView::Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
4189{
4190 FIXME("(%p)->(\n\tTarget GUID:%s Command:0x%08x Opt:0x%08x %p %p)\n",
4191 this, debugstr_guid(pguidCmdGroup), nCmdID, nCmdexecopt, pvaIn, pvaOut);
4192
4193 if (!pguidCmdGroup)
4194 return OLECMDERR_E_UNKNOWNGROUP;
4195
4196 if (IsEqualCLSID(*pguidCmdGroup, m_Category))
4197 {
4198 if (nCmdID == FCIDM_SHVIEW_AUTOARRANGE)
4199 {
4200 if (V_VT(pvaIn) != VT_INT_PTR)
4201 return OLECMDERR_E_NOTSUPPORTED;
4202
4204 params.cbSize = sizeof(params);
4205 params.rcExclude = *(RECT*) V_INTREF(pvaIn);
4206
4207 if (m_hMenuViewModes)
4208 {
4209 // Duplicate all but the last two items of the view modes menu
4210 HMENU hmenuViewPopup = CreatePopupMenu();
4211 Shell_MergeMenus(hmenuViewPopup, m_hMenuViewModes, 0, 0, 0xFFFF, 0);
4212 DeleteMenu(hmenuViewPopup, GetMenuItemCount(hmenuViewPopup) - 1, MF_BYPOSITION);
4213 DeleteMenu(hmenuViewPopup, GetMenuItemCount(hmenuViewPopup) - 1, MF_BYPOSITION);
4214 CheckViewMode(hmenuViewPopup);
4215 TrackPopupMenuEx(hmenuViewPopup, TPM_LEFTALIGN | TPM_TOPALIGN, params.rcExclude.left, params.rcExclude.bottom, m_hWndParent, &params);
4216 ::DestroyMenu(hmenuViewPopup);
4217 }
4218
4219 // pvaOut is VT_I4 with value 0x403 (cmd id of the new mode maybe?)
4220 V_VT(pvaOut) = VT_I4;
4221 V_I4(pvaOut) = 0x403;
4222 }
4223 }
4224
4225 if (IsEqualIID(*pguidCmdGroup, CGID_Explorer) &&
4226 (nCmdID == 0x29) &&
4227 (nCmdexecopt == 4) && pvaOut)
4228 return S_OK;
4229
4230 if (IsEqualIID(*pguidCmdGroup, CGID_ShellDocView) &&
4231 (nCmdID == 9) &&
4232 (nCmdexecopt == 0))
4233 return 1;
4234
4235 if (IsEqualIID(*pguidCmdGroup, CGID_DefView))
4236 {
4237 CComPtr<IStream> pStream;
4238 WCHAR SubKey[MAX_PATH];
4239 switch (nCmdID)
4240 {
4242 SHDeleteKey(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\ShellNoRoam\\Bags");
4244 SaveViewState(pStream);
4245 return S_OK;
4247 PathCombineW(SubKey, REGSTR_PATH_EXPLORER, L"Streams\\Default");
4249 SHDeleteKey(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\ShellNoRoam\\Bags");
4250 m_FolderSettings.fFlags |= FWF_NOBROWSERVIEWSTATE; // Don't let this folder save itself
4251 return S_OK;
4252 }
4253 }
4254
4255 return OLECMDERR_E_UNKNOWNGROUP;
4256}
4257
4258/**********************************************************
4259 * ISVDropTarget implementation
4260 */
4261
4262/******************************************************************************
4263 * drag_notify_subitem [Internal]
4264 *
4265 * Figure out the shellfolder object, which is currently under the mouse cursor
4266 * and notify it via the IDropTarget interface.
4267 */
4268
4269#define SCROLLAREAWIDTH 20
4270
4272{
4273 LONG lResult;
4274 HRESULT hr;
4275 RECT clientRect;
4276
4277 /* The key state on drop doesn't have MK_LBUTTON or MK_RBUTTON because it
4278 reflects the key state after the user released the button, so we need
4279 to remember the last key state when the button was pressed */
4280 m_grfKeyState = grfKeyState;
4281
4282 // Map from global to client coordinates and query the index of the
4283 // listview-item, which is currently under the mouse cursor.
4284 LVHITTESTINFO htinfo = {{pt.x, pt.y}, LVHT_ONITEM};
4285 ScreenToClient(&htinfo.pt);
4286 lResult = m_ListView.HitTest(&htinfo);
4287
4288 /* Send WM_*SCROLL messages every 250 ms during drag-scrolling */
4289 ::GetClientRect(m_ListView, &clientRect);
4290 if (htinfo.pt.x == m_ptLastMousePos.x && htinfo.pt.y == m_ptLastMousePos.y &&
4291 (htinfo.pt.x < SCROLLAREAWIDTH || htinfo.pt.x > clientRect.right - SCROLLAREAWIDTH ||
4292 htinfo.pt.y < SCROLLAREAWIDTH || htinfo.pt.y > clientRect.bottom - SCROLLAREAWIDTH))
4293 {
4294 m_cScrollDelay = (m_cScrollDelay + 1) % 5; // DragOver is called every 50 ms
4295 if (m_cScrollDelay == 0)
4296 {
4297 /* Mouse did hover another 250 ms over the scroll-area */
4298 if (htinfo.pt.x < SCROLLAREAWIDTH)
4299 m_ListView.SendMessageW(WM_HSCROLL, SB_LINEUP, 0);
4300
4301 if (htinfo.pt.x > clientRect.right - SCROLLAREAWIDTH)
4302 m_ListView.SendMessageW(WM_HSCROLL, SB_LINEDOWN, 0);
4303
4304 if (htinfo.pt.y < SCROLLAREAWIDTH)
4305 m_ListView.SendMessageW(WM_VSCROLL, SB_LINEUP, 0);
4306
4307 if (htinfo.pt.y > clientRect.bottom - SCROLLAREAWIDTH)
4308 m_ListView.SendMessageW(WM_VSCROLL, SB_LINEDOWN, 0);
4309 }
4310 }
4311 else
4312 {
4313 m_cScrollDelay = 0; // Reset, if cursor is not over the listview's scroll-area
4314 }
4315
4316 m_ptLastMousePos = htinfo.pt;
4318
4319 /* We need to check if we drag the selection over itself */
4320 if (lResult != -1 && m_pSourceDataObject.p != NULL)
4321 {
4322 PCUITEMID_CHILD pidl = _PidlByItem(lResult);
4323
4324 for (UINT i = 0; i < m_cidl; i++)
4325 {
4326 if (pidl == m_apidl[i])
4327 {
4328 /* The item that is being draged is hovering itself. */
4329 lResult = -1;
4330 break;
4331 }
4332 }
4333 }
4334
4335 // If we are still over the previous sub-item, notify it via DragOver and return
4336 if (m_pCurDropTarget && lResult == m_iDragOverItem)
4337 return m_pCurDropTarget->DragOver(grfKeyState, pt, pdwEffect);
4338
4339 // We've left the previous sub-item, notify it via DragLeave and release it
4340 if (m_pCurDropTarget)
4341 {
4343 if (pidl)
4344 SelectItem(pidl, 0);
4345
4346 m_pCurDropTarget->DragLeave();
4348 }
4349
4350 m_iDragOverItem = lResult;
4351
4352 if (lResult == -1)
4353 {
4354 // We are not above one of the listview's subitems. Bind to the
4355 // parent folder's DropTarget interface.
4357 }
4358 else
4359 {
4360 // Query the relative PIDL of the shellfolder object represented
4361 // by the currently dragged over listview-item ...
4362 PCUITEMID_CHILD pidl = _PidlByItem(lResult);
4363
4364 // ... and bind m_pCurDropTarget to the IDropTarget interface of an UIObject of this object
4365 hr = m_pSFParent->GetUIObjectOf(m_ListView, 1, &pidl, IID_NULL_PPV_ARG(IDropTarget, &m_pCurDropTarget));
4366 }
4367
4369
4370 // If anything failed, m_pCurDropTarget should be NULL now, which ought to be a save state
4371 if (FAILED(hr))
4372 {
4373 *pdwEffect = DROPEFFECT_NONE;
4374 return hr;
4375 }
4376
4377 if (m_iDragOverItem != -1)
4378 {
4379 SelectItem(m_iDragOverItem, SVSI_SELECT);
4380 }
4381
4382 // Notify the item just entered via DragEnter
4383 return m_pCurDropTarget->DragEnter(m_pCurDataObject, grfKeyState, pt, pdwEffect);
4384}
4385
4386HRESULT WINAPI CDefView::DragEnter(IDataObject *pDataObject, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
4387{
4388 if (*pdwEffect == DROPEFFECT_NONE)
4389 return S_OK;
4390
4391 /* Get a hold on the data object for later calls to DragEnter on the sub-folders */
4392 m_pCurDataObject = pDataObject;
4393
4394 HRESULT hr = drag_notify_subitem(grfKeyState, pt, pdwEffect);
4395 if (SUCCEEDED(hr))
4396 {
4397 POINT ptClient = {pt.x, pt.y};
4398 ScreenToClient(&ptClient);
4399 ImageList_DragEnter(m_hWnd, ptClient.x, ptClient.y);
4400 }
4401
4402 return hr;
4403}
4404
4406{
4407 POINT ptClient = {pt.x, pt.y};
4408 ScreenToClient(&ptClient);
4409 ImageList_DragMove(ptClient.x, ptClient.y);
4410 return drag_notify_subitem(grfKeyState, pt, pdwEffect);
4411}
4412
4414{
4416
4417 if (m_pCurDropTarget)
4418 {
4419 m_pCurDropTarget->DragLeave();
4421 }
4422
4423 if (m_pCurDataObject != NULL)
4424 {
4426 }
4427
4428 m_iDragOverItem = 0;
4429
4430 return S_OK;
4431}
4432
4434{
4435 RECT rcBound;
4436 INT i, nCount = m_ListView.GetItemCount();
4437 DWORD dwSpacing;
4438 INT dx, dy;
4439 BOOL bSmall = ((m_ListView.GetStyle() & LVS_TYPEMASK) != LVS_ICON);
4440
4441 // FIXME: LVM_GETORIGIN is broken. See CORE-17266
4442 pt.x += m_ListView.GetScrollPos(SB_HORZ);
4443 pt.y += m_ListView.GetScrollPos(SB_VERT);
4444
4445 if (m_ListView.GetStyle() & LVS_ALIGNLEFT)
4446 {
4447 // vertically
4448 for (i = 0; i < nCount; ++i)
4449 {
4450 dwSpacing = ListView_GetItemSpacing(m_ListView, bSmall);
4451 dx = LOWORD(dwSpacing);
4452 dy = HIWORD(dwSpacing);
4454 rcBound.right = rcBound.left + dx;
4455 rcBound.bottom = rcBound.top + dy;
4456 if (pt.x < rcBound.right && pt.y < (rcBound.top + rcBound.bottom) / 2)
4457 {
4458 return i;
4459 }
4460 }
4461 for (i = nCount - 1; i >= 0; --i)
4462 {
4464 if (rcBound.left < pt.x && rcBound.top < pt.y)
4465 {
4466 return i + 1;
4467 }
4468 }
4469 }
4470 else
4471 {
4472 // horizontally
4473 for (i = 0; i < nCount; ++i)
4474 {
4475 dwSpacing = ListView_GetItemSpacing(m_ListView, bSmall);
4476 dx = LOWORD(dwSpacing);
4477 dy = HIWORD(dwSpacing);
4479 rcBound.right = rcBound.left + dx;
4480 rcBound.bottom = rcBound.top + dy;
4481 if (pt.y < rcBound.bottom && pt.x < rcBound.left)
4482 {
4483 return i;
4484 }
4485 if (pt.y < rcBound.bottom && pt.x < rcBound.right)
4486 {
4487 return i + 1;
4488 }
4489 }
4490 for (i = nCount - 1; i >= 0; --i)
4491 {
4493 if (rcBound.left < pt.x && rcBound.top < pt.y)
4494 {
4495 return i + 1;
4496 }
4497 }
4498 }
4499
4500 return nCount;
4501}
4502
4504{
4505 LRESULT lResult;
4506
4507 if (!m_isFullStatusBar)
4508 {
4509 int nPartArray[] = {-1};
4510 m_pShellBrowser->SendControlMsg(FCW_STATUS, SB_SETPARTS, _countof(nPartArray), (LPARAM)nPartArray, &lResult);
4511 return;
4512 }
4513
4514 int nFileSizePartLength = 125;
4515 const int nLocationPartLength = 150;
4516 const int nRightPartsLength = nFileSizePartLength + nLocationPartLength;
4517 int nObjectsPartLength = nWidth - nRightPartsLength;
4518
4519 // If the window is small enough just divide each part into thirds
4520 // to match the behavior of Windows Server 2003
4521 if (nObjectsPartLength <= nLocationPartLength)
4522 nObjectsPartLength = nFileSizePartLength = nWidth / 3;
4523
4524 int nPartArray[] = {nObjectsPartLength, nObjectsPartLength + nFileSizePartLength, -1};
4525
4526 m_pShellBrowser->SendControlMsg(FCW_STATUS, SB_SETPARTS, _countof(nPartArray), (LPARAM)nPartArray, &lResult);
4527}
4528
4530{
4531 // Get the handle for the status bar
4532 HWND fStatusBar;
4533 m_pShellBrowser->GetControlWindow(FCW_STATUS, &fStatusBar);
4534
4535 // Get the size of our status bar
4536 RECT statusBarSize;
4537 ::GetWindowRect(fStatusBar, &statusBarSize);
4538
4539 // Resize the status bar
4540 _HandleStatusBarResize(statusBarSize.right - statusBarSize.left);
4541}
4542
4544
4545static INT CALLBACK
4546SelectionMoveCompareFunc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
4547{
4548 CLParamIndexMap *pmap = (CLParamIndexMap *)lParamSort;
4549 INT i1 = pmap->Lookup(lParam1), i2 = pmap->Lookup(lParam2);
4550 if (i1 < i2)
4551 return -1;
4552 if (i1 > i2)
4553 return 1;
4554 return 0;
4555}
4556
4558{
4559 // get insertable index from position
4561
4562 // create identity mapping of indexes
4564 INT nCount = m_ListView.GetItemCount();
4565 for (INT i = 0; i < nCount; ++i)
4566 {
4567 array.Add(i);
4568 }
4569
4570 // re-ordering mapping
4571 INT iItem = -1;
4572 while ((iItem = m_ListView.GetNextItem(iItem, LVNI_SELECTED)) >= 0)
4573 {
4574 INT iFrom = iItem, iTo = iPosition;
4575 if (iFrom < iTo)
4576 --iTo;
4577 if (iFrom >= nCount)
4578 iFrom = nCount - 1;
4579 if (iTo >= nCount)
4580 iTo = nCount - 1;
4581
4582 // shift indexes by swapping (like a bucket relay)
4583 if (iFrom < iTo)
4584 {
4585 for (INT i = iFrom; i < iTo; ++i)
4586 {
4587 // swap array[i] and array[i + 1]
4588 INT tmp = array[i];
4589 array[i] = array[i + 1];
4590 array[i + 1] = tmp;
4591 }
4592 }
4593 else
4594 {
4595 for (INT i = iFrom; i > iTo; --i)
4596 {
4597 // swap array[i] and array[i - 1]
4598 INT tmp = array[i];
4599 array[i] = array[i - 1];
4600 array[i - 1] = tmp;
4601 }
4602 }
4603 }
4604
4605 // create mapping (ListView's lParam to index) from array
4607 for (INT i = 0; i < nCount; ++i)
4608 {
4610 map.Add(lParam, i);
4611 }
4612
4613 // finally sort
4615}
4616
4617HRESULT WINAPI CDefView::Drop(IDataObject* pDataObject, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
4618{
4621
4622 if ((IsDropOnSource(NULL) == S_OK) &&
4623 (*pdwEffect & DROPEFFECT_MOVE) &&
4625 {
4626 if (m_pCurDropTarget)
4627 {
4628 m_pCurDropTarget->DragLeave();
4630 }
4631
4632 POINT ptDrop = { pt.x, pt.y };
4633 ::ScreenToClient(m_ListView, &ptDrop);
4635 m_ptLastMousePos = ptDrop;
4636
4638 if (m_ListView.GetStyle() & LVS_AUTOARRANGE)
4639 {
4641 }
4642 else
4643 {
4644 POINT ptItem;
4645 INT iItem = -1;
4646 while ((iItem = m_ListView.GetNextItem(iItem, LVNI_SELECTED)) >= 0)
4647 {
4648 if (m_ListView.GetItemPosition(iItem, &ptItem))
4649 {
4652 m_ListView.SetItemPosition(iItem, &ptItem);
4653 }
4654 }
4655 }
4657 }
4658 else if (m_pCurDropTarget)
4659 {
4660 m_pCurDropTarget->Drop(pDataObject, grfKeyState, pt, pdwEffect);
4662 }
4663
4665 m_iDragOverItem = 0;
4666 return S_OK;
4667}
4668
4670{
4671 TRACE("(%p)\n", this);
4672
4673 if (fEscapePressed)
4674 return DRAGDROP_S_CANCEL;
4675 else if (!(grfKeyState & MK_LBUTTON) && !(grfKeyState & MK_RBUTTON))
4676 return DRAGDROP_S_DROP;
4677 else
4678 return S_OK;
4679}
4680
4682{
4683 TRACE("(%p)\n", this);
4684
4686}
4687
4688HRESULT WINAPI CDefView::Draw(DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd, HDC hdcTargetDev, HDC hdcDraw, LPCRECTL lprcBounds, LPCRECTL lprcWBounds, BOOL (CALLBACK *pfnContinue)(ULONG_PTR dwContinue), ULONG_PTR dwContinue)
4689{
4690 FIXME("Stub: this=%p\n", this);
4691 return E_NOTIMPL;
4692}
4693
4694HRESULT WINAPI CDefView::GetColorSet(DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd, HDC hicTargetDevice, LOGPALETTE **ppColorSet)
4695{
4696 FIXME("Stub: this=%p\n", this);
4697 return E_NOTIMPL;
4698}
4699
4700HRESULT WINAPI CDefView::Freeze(DWORD dwDrawAspect, LONG lindex, void *pvAspect, DWORD *pdwFreeze)
4701{
4702 FIXME("Stub: this=%p\n", this);
4703 return E_NOTIMPL;
4704}
4705
4707{
4708 FIXME("Stub: this=%p\n", this);
4709 return E_NOTIMPL;
4710}
4711
4713{
4714 FIXME("partial stub: %p 0x%08x 0x%08x %p\n", this, aspects, advf, pAdvSink);
4715
4716 // FIXME: we set the AdviseSink, but never use it to send any advice
4717 m_pAdvSink = pAdvSink;
4718 m_dwAspects = aspects;
4719 m_dwAdvf = advf;
4720
4721 return S_OK;
4722}
4723
4725{
4726 TRACE("this=%p pAspects=%p pAdvf=%p ppAdvSink=%p\n", this, pAspects, pAdvf, ppAdvSink);
4727
4728 if (ppAdvSink)
4729 {
4730 *ppAdvSink = m_pAdvSink;
4731 m_pAdvSink.p->AddRef();
4732 }
4733
4734 if (pAspects)
4735 *pAspects = m_dwAspects;
4736
4737 if (pAdvf)
4738 *pAdvf = m_dwAdvf;
4739
4740 return S_OK;
4741}
4742
4744{
4745 if (IsEqualIID(guidService, SID_SFolderView))
4746 return QueryInterface(riid, ppvObject);
4748}
4749
4751{
4753 HRESULT hr = S_OK;
4754
4755 hr = IUnknown_QueryService(m_pShellBrowser, IID_IExplorerToolbar, IID_PPV_ARG(IExplorerToolbar, &ptb));
4756 if (FAILED(hr))
4757 return hr;
4758
4759 m_Category = CGID_DefViewFrame;
4760
4761 hr = ptb->SetCommandTarget(static_cast<IOleCommandTarget*>(this), &m_Category, 0);
4762 if (FAILED(hr))
4763 return hr;
4764
4765 if (hr == S_FALSE)
4766 return S_OK;
4767
4768#if 0
4769 hr = ptb->AddButtons(&m_Category, buttonsCount, buttons);
4770 if (FAILED(hr))
4771 return hr;
4772#endif
4773
4774 return S_OK;
4775}
4776
4778{
4780
4782 {
4783 hr = m_pShellFolderViewCB->MessageSFVCB(uMsg, wParam, lParam);
4784 }
4785
4786 return hr;
4787}
4788
4790{
4791 return ShellObjectCreatorInit<CDefView>(pFolder, riid, ppvOut);
4792}
4793
4795{
4797 HRESULT hRes;
4798
4799 if (!ppsv)
4800 return E_INVALIDARG;
4801
4802 *ppsv = NULL;
4803
4804 if (!pcsfv || pcsfv->cbSize != sizeof(*pcsfv))
4805 return E_INVALIDARG;
4806
4807 TRACE("sf=%p outer=%p callback=%p\n",
4808 pcsfv->pshf, pcsfv->psvOuter, pcsfv->psfvcb);
4809
4810 hRes = CDefView_CreateInstance(pcsfv->pshf, IID_PPV_ARG(IShellView, &psv));
4811 if (FAILED(hRes))
4812 return hRes;
4813
4814 if (pcsfv->psfvcb)
4815 {
4817 if (SUCCEEDED(psv->QueryInterface(IID_PPV_ARG(IShellFolderView, &sfv))))
4818 {
4819 sfv->SetCallback(pcsfv->psfvcb, NULL);
4820 }
4821 }
4822
4823 *ppsv = psv.Detach();
4824 return hRes;
4825}
static HDC hDC
Definition: 3dtext.c:33
BOOL _ILIsDesktop(LPCITEMIDLIST pidl)
Definition: CBandSite.h:24
HRESULT CDefViewBckgrndMenu_CreateInstance(IShellFolder *psf, REFIID riid, void **ppv)
HRESULT WINAPI CDefViewDual_Constructor(REFIID riid, LPVOID *ppvOut)
static UINT GetContextMenuFlags(IShellBrowser *pSB, SFGAOF sfgao)
Definition: CDefView.cpp:104
static BOOL AppendMenuItem(HMENU hMenu, UINT MF, UINT Id, LPCWSTR String, SIZE_T Data=0)
Definition: CDefView.cpp:157
#define GET_WM_COMMAND_HWND(wp, lp)
Definition: CDefView.cpp:587
static SIZE_T GetMenuItemDataById(HMENU hMenu, UINT Id)
Definition: CDefView.cpp:170
CSimpleMap< LPARAM, INT > CLParamIndexMap
Definition: CDefView.cpp:4543
@ DEFVIEW_ARRANGESORT_MAX
Definition: CDefView.cpp:48
@ DVIDM_CONTEXTMENU_LAST
Definition: CDefView.cpp:53
@ DVIDM_ARRANGESORT_FIRST
Definition: CDefView.cpp:50
@ DEFVIEW_ARRANGESORT_MAXENUM
Definition: CDefView.cpp:47
@ DVIDM_ARRANGESORT_LAST
Definition: CDefView.cpp:49
@ DVIDM_CONTEXTMENU_FIRST
Definition: CDefView.cpp:57
@ DVIDM_COMMDLG_SELECT
Definition: CDefView.cpp:51
#define SCROLLAREAWIDTH
Definition: CDefView.cpp:4269
#define SHV_UPDATESTATUSBAR
Definition: CDefView.cpp:78
static BOOL ILIsParentOrSpecialParent(PCIDLIST_ABSOLUTE pidl1, PCIDLIST_ABSOLUTE pidl2)
Definition: CDefView.cpp:2898
void(CALLBACK * PFNSHGETSETTINGSPROC)(LPSHELLFLAGSTATE lpsfs, DWORD dwMask)
Definition: CDefView.cpp:590
#define SHV_CHANGE_NOTIFY
Definition: CDefView.cpp:77
static COLORREF GetViewColor(COLORREF Clr, UINT SysFallback)
Definition: CDefView.cpp:215
#define GET_WM_COMMAND_ID(wp, lp)
Definition: CDefView.cpp:586
#define CONTEXT_MENU_BASE_ID
Definition: CDefView.cpp:82
#define UPDATEFOLDERVIEWFLAGS(bits, bit, set)
Definition: CDefView.cpp:3465
HRESULT SHSetMenuIdInMenuMsg(UINT uMsg, LPARAM lParam, UINT CmdId)
HRESULT CDefView_CreateInstance(IShellFolder *pFolder, REFIID riid, LPVOID *ppvOut)
Definition: CDefView.cpp:4789
#define ID_LISTVIEW
Definition: CDefView.cpp:583
static HRESULT LoadColumnsStream(PERSISTCOLUMNS &cols, IStream *pS)
Definition: CDefView.cpp:3313
#define GET_WM_COMMAND_CMD(wp, lp)
Definition: CDefView.cpp:588
static UINT ReallyGetMenuItemID(HMENU hmenu, int i)
Definition: CDefView.cpp:192
static INT CALLBACK SelectionMoveCompareFunc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
Definition: CDefView.cpp:4546
HRESULT WINAPI SHCreateShellFolderView(const SFV_CREATE *pcsfv, IShellView **ppsv)
Definition: CDefView.cpp:4794
static DWORD ReadDWORD(IPropertyBag *pPB, LPCWSTR name, DWORD def)
Definition: CDefView.cpp:3291
static HMENU GetSubmenuByID(HMENU hmenu, UINT id)
Definition: CDefView.cpp:181
static VOID DrawTileBitmap(HDC hDC, LPCRECT prc, HBITMAP hbm, INT nWidth, INT nHeight, INT dx, INT dy)
Definition: CDefView.cpp:1687
static HRESULT SHGetLVColumnSubItem(HWND List, UINT Col)
Definition: CDefView.cpp:1014
static void ClientToListView(HWND hwndLV, POINT *ppt)
Definition: CDefView.cpp:119
static UINT CalculateCharWidth(HWND hwnd)
Definition: CDefView.cpp:201
static BOOL SelectExtOnRename(void)
Definition: CDefView.cpp:2625
HRESULT SHGetMenuIdFromMenuMsg(UINT uMsg, LPARAM lParam, UINT *CmdId)
DWORD Id
#define SFVM_GETCOMMANDDIR
#define SFVM_CANSELECTALL
#define SFVM_GET_CUSTOMVIEWINFO
#define SFVM_GETNAMELENGTH
#define SFVM_VIEWRELEASE
#define SFVM_ADDINGOBJECT
#define SFVM_REMOVINGOBJECT
#define SFVM_LISTREFRESHED
#define SFVM_WINDOWCLOSING
#define SFVM_SELECTIONCHANGED
unsigned char BOOLEAN
unsigned long long UINT64
signed char INT8
unsigned char UINT8
#define shell32_hInstance
@ lparam
Definition: SystemMenu.c:31
_STLP_MOVE_TO_STD_NAMESPACE void sort(_RandomAccessIter __first, _RandomAccessIter __last)
Definition: _algo.c:993
#define read
Definition: acwin.h:96
static int state
Definition: maze.c:121
HWND hWnd
Definition: settings.c:17
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
int sortcol
Definition: sort.c:23
static const COLUMN_LIST Columns[]
Definition: listview.c:19
void shell(int argc, const char *argv[])
Definition: cmds.c:1231
BOOL Query(LPCTSTR *ServiceArgs, DWORD ArgCount, BOOL bExtended)
Definition: query.c:292
#define U(x)
Definition: wordpad.c:45
@ Create
Definition: registry.c:563
#define FIXME(fmt,...)
Definition: precomp.h:53
#define ERR(fmt,...)
Definition: precomp.h:57
#define STDMETHOD(m)
Definition: basetyps.h:62
#define STDMETHODCALLTYPE
Definition: bdasup.h:9
#define RegCloseKey(hKey)
Definition: registry.h:49
EXTERN_C HANDLE WINAPI SHChangeNotification_Lock(HANDLE hTicket, DWORD dwOwnerPID, LPITEMIDLIST **lppidls, LPLONG lpwEventId)
EXTERN_C ULONG WINAPI SHChangeNotifyRegister(HWND hwnd, INT fSources, LONG wEventMask, UINT uMsg, INT cItems, SHChangeNotifyEntry *lpItems)
EXTERN_C BOOL WINAPI SHChangeNotification_Unlock(HANDLE hLock)
EXTERN_C BOOL WINAPI SHChangeNotifyDeregister(ULONG hNotify)
void Release()
Definition: atlcomcli.h:170
T * Detach()
Definition: atlcomcli.h:186
static LRESULT CALLBACK StartWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
Definition: atlwin.h:1619
BOOL DestroyWindow()
Definition: atlwin.h:462
CWindow GetParent() const
Definition: atlwin.h:700
BOOL IsWindowVisible() const
Definition: atlwin.h:958
BOOL UpdateWindow()
Definition: atlwin.h:1345
HWND m_hWnd
Definition: atlwin.h:273
STDMETHOD() Drop(IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect) override
Definition: CDefView.cpp:4617
STDMETHOD() Unfreeze(DWORD dwFreeze) override
Definition: CDefView.cpp:4706
HMENU m_hMenu
Definition: CDefView.cpp:245
HRESULT LoadColumn(UINT FoldCol, UINT ListCol, BOOL Insert, UINT ForceWidth=0)
Definition: CDefView.cpp:1089
DWORD GetCommDlgViewFlags()
Definition: CDefView.cpp:361
LRESULT OnShowWindow(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:1637
CComPtr< IShellFolder > m_pSFParent
Definition: CDefView.cpp:233
LRESULT OnKillFocus(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:2513
STDMETHOD() GetAutoArrange() override
Definition: CDefView.cpp:3742
void RefreshGhostedState()
Definition: CDefView.cpp:3127
LRESULT OnChangeCBChain(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:3107
LRESULT OnSetFocus(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:2493
STDMETHOD() SelectAndPositionItem(LPCITEMIDLIST item, UINT flags, POINT *point) override
Definition: CDefView.cpp:3921
HRESULT OnStateChange(UINT uFlags)
Definition: CDefView.cpp:693
HDPA m_LoadColumnsList
Definition: CDefView.cpp:254
static INT CALLBACK fill_list(LPVOID ptr, LPVOID arg)
Definition: CDefView.cpp:1518
CComPtr< IShellDetails > m_pSDParent
Definition: CDefView.cpp:235
STDMETHOD() DestroyViewWindow() override
Definition: CDefView.cpp:3215
LRESULT OnSysColorChange(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:1735
LRESULT OnContextMenu(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:2227
int LV_AddItem(PCUITEMID_CHILD pidl)
Definition: CDefView.cpp:1379
STDMETHOD() SetItemPos(PCUITEMID_CHILD pidl, POINT *pt) override
Definition: CDefView.cpp:4089
BOOL IsSpecialFolder(int &csidl) const
Definition: CDefView.cpp:298
bool m_ScheduledStatusbarUpdate
Definition: CDefView.cpp:278
HRESULT FillFileMenu()
Definition: CDefView.cpp:1847
STDMETHOD() RemoveObject(PITEMID_CHILD pidl, UINT *item) override
Definition: CDefView.cpp:3973
void UpdateStatusbar()
Definition: CDefView.cpp:731
BOOL IsDesktop() const
Definition: CDefView.cpp:296
HMENU m_hMenuArrangeModes
Definition: CDefView.cpp:246
CComPtr< IDataObject > m_pCurDataObject
Definition: CDefView.cpp:265
HRESULT FillEditMenu()
Definition: CDefView.cpp:1893
bool m_isFullStatusBar
Definition: CDefView.cpp:277
STDMETHOD() SetAutomationObject(IDispatch *disp) override
Definition: CDefView.cpp:4161
CComPtr< IShellFolderViewDual > m_pShellFolderViewDual
Definition: CDefView.cpp:240
STDMETHOD() DragLeave() override
Definition: CDefView.cpp:4413
LRESULT OnNCCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:1749
STDMETHOD() AutoArrange() override
Definition: CDefView.cpp:3948
BOOL CreateList()
Definition: CDefView.cpp:840
void UpdateListColors()
Definition: CDefView.cpp:938
HWND m_hWndParent
Definition: CDefView.cpp:243
STDMETHOD() ContextSensitiveHelp(BOOL fEnterMode) override
Definition: CDefView.cpp:3144
STDMETHOD() AddPropertySheetPages(DWORD dwReserved, LPFNSVADDPROPSHEETPAGE pfn, LPARAM lparam) override
Definition: CDefView.cpp:3275
STDMETHOD() QueryService(REFGUID guidService, REFIID riid, void **ppvObject) override
Definition: CDefView.cpp:4743
BOOLEAN LV_DeleteItem(PCUITEMID_CHILD pidl)
Definition: CDefView.cpp:1403
STDMETHOD() GetItemObject(UINT uItem, REFIID riid, void **ppv) override
Definition: CDefView.cpp:3529
STDMETHOD() GetObjectCount(UINT *count) override
Definition: CDefView.cpp:3997
HRESULT _MergeToolbar()
Definition: CDefView.cpp:4750
STDMETHOD() SetCallback(IShellFolderViewCB *new_cb, IShellFolderViewCB **old_cb) override
Definition: CDefView.cpp:4137
HRESULT drag_notify_subitem(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
Definition: CDefView.cpp:4271
DWORD m_dwAdvf
Definition: CDefView.cpp:260
HRESULT _DoFolderViewCB(UINT uMsg, WPARAM wParam, LPARAM lParam)
Definition: CDefView.cpp:4777
STDMETHOD() Items(UINT uFlags, REFIID riid, void **ppv) override
Definition: CDefView.cpp:3676
STDMETHOD() CreateViewWindow2(LPSV2CVW2_PARAMS view_params) override
Definition: CDefView.cpp:3814
STDMETHOD() SelectItem(PCUITEMID_CHILD pidlItem, SVSIF uFlags) override
Definition: CDefView.cpp:3473
LRESULT OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:2394
STDMETHOD() GetAdvise(DWORD *pAspects, DWORD *pAdvf, IAdviseSink **ppAdvSink) override
Definition: CDefView.cpp:4724
LRESULT OnGetDlgCode(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:1645
void CheckToolbar()
Definition: CDefView.cpp:712
HRESULT IncludeObject(PCUITEMID_CHILD pidl)
Definition: CDefView.cpp:663
DWORD m_dwAspects
Definition: CDefView.cpp:259
STDMETHOD() SaveViewState() override
Definition: CDefView.cpp:3458
CComPtr< IContextMenu > m_pCM
Definition: CDefView.cpp:272
CComPtr< IShellBrowser > m_pShellBrowser
Definition: CDefView.cpp:237
void _DoCopyToMoveToFolder(BOOL bCopy)
Definition: CDefView.cpp:2464
HRESULT GetDetailsByListColumn(PCUITEMID_CHILD pidl, UINT ListCol, SHELLDETAILS &sd)
Definition: CDefView.cpp:1080
INT _FindInsertableIndexFromPoint(POINT pt)
Definition: CDefView.cpp:4433
LRESULT OnPrintClient(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:1708
LRESULT DoColumnContextMenu(LRESULT lParam)
Definition: CDefView.cpp:1995
UINT m_cScrollDelay
Definition: CDefView.cpp:267
LISTVIEW_SORT_INFO m_sortInfo
Definition: CDefView.cpp:256
CComPtr< IDataObject > m_pSourceDataObject
Definition: CDefView.cpp:263
HRESULT CheckViewMode(HMENU hmenuView)
Definition: CDefView.cpp:1982
CComPtr< IAdviseSink > m_pAdvSink
Definition: CDefView.cpp:261
void _HandleStatusBarResize(int width)
Definition: CDefView.cpp:4503
STDMETHOD() SetCurrentViewMode(UINT ViewMode) override
Definition: CDefView.cpp:3599
LRESULT OnInitMenuPopup(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:3049
LRESULT OnUpdateStatusbar(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:829
POINT m_ptFirstMousePos
Definition: CDefView.cpp:269
LRESULT OnExplorerCommand(UINT uCommand, BOOL bUseSelection)
Definition: CDefView.cpp:2344
LRESULT OnSettingChange(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:3039
ClipboardViewerChain m_ClipboardChain
Definition: CDefView.cpp:241
STDMETHOD() GetItemPosition(PCUITEMID_CHILD pidl, POINT *ppt) override
Definition: CDefView.cpp:3699
STDMETHOD() SetPoints(IDataObject *obj) override
Definition: CDefView.cpp:4125
STDMETHOD() IsDropOnSource(IDropTarget *drop_target) override
Definition: CDefView.cpp:4057
HRESULT FillList(BOOL IsRefreshCommand=TRUE)
Definition: CDefView.cpp:1535
CComPtr< IDropTarget > m_pCurDropTarget
Definition: CDefView.cpp:264
PIDLIST_ABSOLUTE m_pidlParent
Definition: CDefView.cpp:253
STDMETHOD() GetSelectionMarkedItem(int *piItem) override
Definition: CDefView.cpp:3681
STDMETHOD() TranslateAccelerator(MSG *pmsg) override
Definition: CDefView.cpp:3152
STDMETHOD() QueryContinueDrag(BOOL fEscapePressed, DWORD grfKeyState) override
Definition: CDefView.cpp:4669
STDMETHOD() Draw(DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd, HDC hdcTargetDev, HDC hdcDraw, LPCRECTL lprcBounds, LPCRECTL lprcWBounds, BOOL(STDMETHODCALLTYPE *pfnContinue)(ULONG_PTR dwContinue), ULONG_PTR dwContinue) override
Definition: CDefView.cpp:4688
LRESULT OnCustomItem(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:3016
HMENU m_hContextMenu
Definition: CDefView.cpp:248
CComPtr< IShellFolderViewCB > m_pShellFolderViewCB
Definition: CDefView.cpp:236
STDMETHOD() GiveFeedback(DWORD dwEffect) override
Definition: CDefView.cpp:4681
STDMETHOD() ArrangeGrid() override
Definition: CDefView.cpp:3942
STDMETHOD() SetRedraw(BOOL redraw) override
Definition: CDefView.cpp:4022
HRESULT OpenSelectedItems()
Definition: CDefView.cpp:2187
void _ForceStatusBarResize()
Definition: CDefView.cpp:4529
BOOL m_Destroyed
Definition: CDefView.cpp:282
CComPtr< IContextMenu > m_pFileMenu
Definition: CDefView.cpp:273
HRESULT WINAPI Initialize(IShellFolder *shellFolder)
Definition: CDefView.cpp:652
PCUITEMID_CHILD * m_apidl
Definition: CDefView.cpp:252
CComPtr< IFolderFilter > m_pFolderFilter
Definition: CDefView.cpp:239
void LV_RefreshIcons()
Definition: CDefView.cpp:1504
LRESULT OnActivate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:2487
STDMETHOD() GetSelectedObjects(PCUITEMID_CHILD **pidl, UINT *items) override
Definition: CDefView.cpp:4036
HDPA m_ListToFolderColMap
Definition: CDefView.cpp:255
STDMETHOD() QuerySupport(UINT *support) override
Definition: CDefView.cpp:4155
void OnDeactivate()
Definition: CDefView.cpp:2419
LRESULT OnEraseBackground(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:1676
void _MoveSelectionOnAutoArrange(POINT pt)
Definition: CDefView.cpp:4557
static INT CALLBACK ListViewCompareItems(LPARAM lParam1, LPARAM lParam2, LPARAM lpData)
Definition: CDefView.cpp:1257
STDMETHOD() GetDefaultSpacing(POINT *ppt) override
Definition: CDefView.cpp:3737
CLSID m_Category
Definition: CDefView.cpp:281
HRESULT FillArrangeAsMenu(HMENU hmenuArrange)
Definition: CDefView.cpp:1926
signed char m_SpecialFolder
Definition: CDefView.cpp:276
STDMETHOD() UpdateObject(PITEMID_CHILD pidl_old, PITEMID_CHILD pidl_new, UINT *item) override
Definition: CDefView.cpp:4010
STDMETHOD() GetItemSpacing(ITEMSPACING *spacing) override
Definition: CDefView.cpp:4131
static ATL::CWndClassInfo & GetWndClassInfo()
Definition: CDefView.cpp:508
SFGAOF GetItemAttributes(PCUITEMID_CHILD pidl, UINT Query)
Definition: CDefView.cpp:1323
CComPtr< IShellFolder2 > m_pSF2Parent
Definition: CDefView.cpp:234
LRESULT OnCommand(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:2525
STDMETHOD() AddObject(PITEMID_CHILD pidl, UINT *item) override
Definition: CDefView.cpp:3955
STDMETHOD() GetDropPoint(POINT *pt) override
Definition: CDefView.cpp:4077
HICON m_hMyComputerIcon
Definition: CDefView.cpp:285
STDMETHOD() GetSelectedCount(UINT *count) override
Definition: CDefView.cpp:4030
STDMETHOD() GetFocusedItem(int *piItem) override
Definition: CDefView.cpp:3690
LRESULT OnDrawClipboard(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:3113
STDMETHOD() GetSpacing(POINT *ppt) override
Definition: CDefView.cpp:3715
LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:1650
STDMETHOD() CreateViewWindow(IShellView *psvPrevious, LPCFOLDERSETTINGS pfs, IShellBrowser *psb, RECT *prcView, HWND *phWnd) override
Definition: CDefView.cpp:3209
FOLDERVIEWMODE GetDefaultViewMode()
Definition: CDefView.cpp:3579
STDMETHOD() GetDragPoint(POINT *pt) override
Definition: CDefView.cpp:4068
BOOL m_bmenuBarInitialized
Definition: CDefView.cpp:249
HRESULT MapFolderColumnToListColumn(UINT FoldCol)
Definition: CDefView.cpp:1024
SFGAOF GetSelectionAttributes(SFGAOF Query)
Definition: CDefView.cpp:2135
PCUITEMID_CHILD _PidlByItem(int i)
Definition: CDefView.cpp:1335
UINT m_cidl
Definition: CDefView.cpp:251
void ColumnListChanged()
Definition: CDefView.cpp:1191
STDMETHOD() GetFolder(REFIID riid, void **ppv) override
Definition: CDefView.cpp:3643
STDMETHOD() Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut) override
Definition: CDefView.cpp:4188
UINT m_uState
Definition: CDefView.cpp:250
STDMETHOD() DragOver(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect) override
Definition: CDefView.cpp:4405
STDMETHOD() Rearrange(LPARAM sort) override
Definition: CDefView.cpp:3929
HRESULT InvokeContextMenuCommand(CComPtr< IContextMenu > &pCM, LPCSTR lpVerb, POINT *pt=NULL)
Definition: CDefView.cpp:2143
DWORD m_grfKeyState
Definition: CDefView.cpp:270
STDMETHOD() GetView(SHELLVIEWID *view_guid, ULONG view_type) override
Definition: CDefView.cpp:3808
STDMETHOD() QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT *pCmdText) override
Definition: CDefView.cpp:4167
HRESULT _GetSnapToGrid()
Definition: CDefView.cpp:3747
STDMETHOD() HandleRename(LPCITEMIDLIST new_pidl) override
Definition: CDefView.cpp:3915
void LV_RefreshIcon(INT iItem)
Definition: CDefView.cpp:1493
HRESULT GetDefaultViewStream(DWORD Stgm, IStream **ppStream)
Definition: CDefView.cpp:3298
UINT GetSelections()
Definition: CDefView.cpp:2102
BOOL m_isEditing
Definition: CDefView.cpp:275
BOOLEAN LV_RenameItem(PCUITEMID_CHILD pidlOld, PCUITEMID_CHILD pidlNew)
Definition: CDefView.cpp:1420
STDMETHOD() GetCurrentInfo(LPFOLDERSETTINGS pfs) override
Definition: CDefView.cpp:3263
CComPtr< ICommDlgBrowser > m_pCommDlgBrowser
Definition: CDefView.cpp:238
STDMETHOD() GetCurrentViewMode(UINT *pViewMode) override
Definition: CDefView.cpp:3588
POINT m_ptLastMousePos
Definition: CDefView.cpp:268
STDMETHOD() RefreshObject(PITEMID_CHILD pidl, UINT *item) override
Definition: CDefView.cpp:4016
BOOL InitList()
Definition: CDefView.cpp:985
ULONG m_hNotify
Definition: CDefView.cpp:257
STDMETHOD() IsBkDropTarget(IDropTarget *drop_target) override
Definition: CDefView.cpp:4095
HRESULT MapListColumnToFolderColumn(UINT ListCol)
Definition: CDefView.cpp:1037
STDMETHOD() Refresh() override
Definition: CDefView.cpp:3197
HRESULT LoadViewState()
Definition: CDefView.cpp:3323
bool m_HasCutItems
Definition: CDefView.cpp:279
HRESULT GetDetailsByFolderColumn(PCUITEMID_CHILD pidl, UINT FoldCol, SHELLDETAILS &sd)
Definition: CDefView.cpp:1058
STDMETHOD() SelectAndPositionItems(UINT cidl, PCUITEMID_CHILD_ARRAY apidl, POINT *apt, DWORD dwFlags) override
Definition: CDefView.cpp:3784
HRESULT OnDefaultCommand()
Definition: CDefView.cpp:679
STDMETHOD() SetClipboard(BOOL move) override
Definition: CDefView.cpp:4101
void UpdateFolderViewFlags()
Definition: CDefView.cpp:3466
HRESULT FillViewMenu()
Definition: CDefView.cpp:1910
LONG m_iDragOverItem
Definition: CDefView.cpp:266
STDMETHOD() ItemCount(UINT uFlags, int *pcItems) override
Definition: CDefView.cpp:3664
virtual VOID OnFinalMessage(HWND) override
Definition: CDefView.cpp:1756
LRESULT OnGetShellBrowser(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:1744
STDMETHOD() MoveIcons(IDataObject *obj) override
Definition: CDefView.cpp:4083
STDMETHOD() GetWindow(HWND *lphwnd) override
Definition: CDefView.cpp:3135
STDMETHOD() CreateViewWindow3(IShellBrowser *psb, IShellView *psvPrevious, SV3CVW3_FLAGS view_flags, FOLDERFLAGS mask, FOLDERFLAGS flags, FOLDERVIEWMODE mode, const SHELLVIEWID *view_id, const RECT *prcView, HWND *hwnd) override
Definition: CDefView.cpp:3821
HMENU m_hMenuViewModes
Definition: CDefView.cpp:247
HACCEL m_hAccel
Definition: CDefView.cpp:258
STDMETHOD() GetArrangeParam(LPARAM *sort) override
Definition: CDefView.cpp:3935
LRESULT OnChangeNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:2910
virtual WNDPROC GetWindowProc() override
Definition: CDefView.cpp:521
STDMETHOD() Freeze(DWORD dwDrawAspect, LONG lindex, void *pvAspect, DWORD *pdwFreeze) override
Definition: CDefView.cpp:4700
STDMETHOD() GetColorSet(DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd, HDC hicTargetDev, LOGPALETTE **ppColorSet) override
Definition: CDefView.cpp:4694
FOLDERSETTINGS m_FolderSettings
Definition: CDefView.cpp:244
STDMETHOD() DragEnter(IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect) override
Definition: CDefView.cpp:4386
static LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
Definition: CDefView.cpp:526
STDMETHOD() SetObjectCount(UINT count, UINT flags) override
Definition: CDefView.cpp:4004
STDMETHOD() GetObject(PITEMID_CHILD *pidl, UINT item) override
Definition: CDefView.cpp:3967
void UpdateStatusbarLocation()
Definition: CDefView.cpp:803
LRESULT OnNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:2642
STDMETHOD() EnableModeless(BOOL fEnable) override
Definition: CDefView.cpp:3168
CListView m_ListView
Definition: CDefView.cpp:242
BOOL _Sort(int Col=-1)
Definition: CDefView.cpp:1271
STDMETHOD() SetAdvise(DWORD aspects, DWORD advf, IAdviseSink *pAdvSink) override
Definition: CDefView.cpp:4712
LRESULT OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:1761
BOOL LV_UpdateItem(INT nItem, PCUITEMID_CHILD pidl)
Definition: CDefView.cpp:1459
STDMETHOD() UIActivate(UINT uState) override
Definition: CDefView.cpp:3174
int LV_FindItemByPidl(PCUITEMID_CHILD pidl)
Definition: CDefView.cpp:1349
STDMETHOD() Item(int iItemIndex, PITEMID_CHILD *ppidl) override
Definition: CDefView.cpp:3651
HRESULT LoadColumns(SIZE_T *pColList=NULL, UINT ColListCount=0)
Definition: CDefView.cpp:1126
void DoActivate(UINT uState)
Definition: CDefView.cpp:2430
STDMETHOD() Select(UINT flags) override
Definition: CDefView.cpp:4149
SFVM_CUSTOMVIEWINFO_DATA m_viewinfo_data
Definition: CDefView.cpp:283
int GetNextItem(int i, WORD flags)
Definition: rosctrls.h:161
UINT GetItemState(int i, UINT mask)
Definition: rosctrls.h:173
BOOL SetTextBkColor(COLORREF cr)
Definition: rosctrls.h:32
BOOL DeleteAllItems()
Definition: rosctrls.h:126
int InsertItem(const LV_ITEM *pitem)
Definition: rosctrls.h:96
DWORD SetExtendedListViewStyle(DWORD dw, DWORD dwMask=0)
Definition: rosctrls.h:47
void SetRedraw(BOOL redraw)
Definition: rosctrls.h:27
BOOL SortItems(PFNLVCOMPARE pfnCompare, PVOID lParam)
Definition: rosctrls.h:141
void SetItemState(int i, UINT state, UINT mask)
Definition: rosctrls.h:178
int GetItemCount()
Definition: rosctrls.h:121
HWND EditLabel(int i)
Definition: rosctrls.h:151
DWORD_PTR GetItemData(int i)
Definition: rosctrls.h:204
BOOL SetTextColor(COLORREF cr)
Definition: rosctrls.h:42
HIMAGELIST SetImageList(HIMAGELIST himl, int iImageList)
Definition: rosctrls.h:91
BOOL EnsureVisible(int i, BOOL fPartialOK)
Definition: rosctrls.h:146
BOOL SetItemText(int i, int subItem, LPCWSTR text)
Definition: rosctrls.h:186
BOOL SetItemPosition(int nItem, POINT *pPoint)
Definition: rosctrls.h:236
BOOL GetItem(LV_ITEM *pitem)
Definition: rosctrls.h:106
BOOL Update(int i)
Definition: rosctrls.h:131
UINT GetSelectedCount()
Definition: rosctrls.h:136
BOOL Arrange(UINT nCode)
Definition: rosctrls.h:241
void GetItemSpacing(SIZE &spacing, BOOL bSmallIconView=FALSE)
Definition: rosctrls.h:166
BOOL DeleteItem(int i)
Definition: rosctrls.h:101
BOOL SetItem(const LV_ITEM *pitem)
Definition: rosctrls.h:111
int HitTest(LV_HITTESTINFO *phtInfo)
Definition: rosctrls.h:199
BOOL GetItemPosition(int nItem, POINT *pPoint)
Definition: rosctrls.h:231
BOOL SetBkColor(COLORREF cr)
Definition: rosctrls.h:37
int GetSelectionMark()
Definition: rosctrls.h:156
HWND Create(HWND hWndParent, _U_RECT rect, LPCTSTR szWindowName=NULL, DWORD dwStyle=0, DWORD dwExStyle=0, _U_MENUorID MenuOrID=0U, LPVOID lpCreateParam=NULL)
Definition: rosctrls.h:8
WPARAM wParam
Definition: combotst.c:138
LPARAM lParam
Definition: combotst.c:139
_In_ size_t const _In_ int _In_ bool const _In_ unsigned const _In_ __acrt_rounding_mode const _Inout_ __crt_cached_ptd_host & ptd
Definition: cvt.cpp:355
#define ERROR_MORE_DATA
Definition: dderror.h:13
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define E_INVALIDARG
Definition: ddrawi.h:101
#define E_NOTIMPL
Definition: ddrawi.h:99
#define E_FAIL
Definition: ddrawi.h:102
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define SHCIDS_CANONICALONLY
Definition: shobjidl.idl:226
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3333
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4103
UINT uFlags
Definition: api.c:59
BOOL WINAPI DPA_SetPtr(HDPA hdpa, INT i, LPVOID p)
Definition: dpa.c:626
BOOL WINAPI DPA_DeleteAllPtrs(HDPA hdpa)
Definition: dpa.c:730
void WINAPI DPA_DestroyCallback(HDPA hdpa, PFNDPAENUMCALLBACK enumProc, LPVOID lParam)
Definition: dpa.c:1003
BOOL WINAPI DPA_Destroy(HDPA hdpa)
Definition: dpa.c:396
HDPA WINAPI DPA_Create(INT nGrow)
Definition: dpa.c:950
VOID WINAPI ImageList_EndDrag(void)
Definition: imagelist.c:1865
BOOL WINAPI ImageList_DragEnter(HWND hwndLock, INT x, INT y)
Definition: imagelist.c:976
BOOL WINAPI ImageList_DragMove(INT x, INT y)
Definition: imagelist.c:1088
BOOL WINAPI ImageList_DragLeave(HWND hwndLock)
Definition: imagelist.c:1010
BOOL WINAPI ImageList_BeginDrag(HIMAGELIST himlTrack, INT iTrack, INT dxHotspot, INT dyHotspot)
Definition: imagelist.c:648
#define MAX_PATH
Definition: compat.h:34
#define CALLBACK
Definition: compat.h:35
@ VT_I4
Definition: compat.h:2298
@ VT_INT_PTR
Definition: compat.h:2327
#define FAILED_UNEXPECTEDLY(hr)
Definition: precomp.h:121
INT WINAPI StringFromGUID2(REFGUID id, LPOLESTR str, INT cmax)
Definition: compobj.c:2434
HRESULT WINAPI RegisterDragDrop(HWND hwnd, LPDROPTARGET pDropTarget)
Definition: ole2.c:557
HRESULT WINAPI DoDragDrop(IDataObject *pDataObject, IDropSource *pDropSource, DWORD dwOKEffect, DWORD *pdwEffect)
Definition: ole2.c:753
HRESULT WINAPI RevokeDragDrop(HWND hwnd)
Definition: ole2.c:639
BOOL SHELL_FS_HideExtension(LPCWSTR szPath)
Definition: CFSFolder.cpp:1438
DWORD SHGetAttributes(_In_ IShellFolder *psf, _In_ LPCITEMIDLIST pidl, _In_ DWORD dwAttributes)
Definition: utils.cpp:425
EXTERN_C HRESULT WINAPI SHGetRealIDL(_In_ IShellFolder *psf, _In_ PCUITEMID_CHILD pidlSimple, _Outptr_ PITEMID_CHILD *ppidlReal)
Definition: utils.cpp:1620
EXTERN_C HRESULT WINAPI DisplayNameOfW(_In_ IShellFolder *psf, _In_ LPCITEMIDLIST pidl, _In_ DWORD dwFlags, _Out_ LPWSTR pszBuf, _In_ UINT cchBuf)
Definition: utils.cpp:409
static BOOL IsEqualPersistClassID(IPersist *pPersist, REFCLSID clsid)
Definition: utils.h:36
void WINAPI SHFree(LPVOID pv)
Definition: shellole.c:326
LPVOID WINAPI SHAlloc(SIZE_T len)
Definition: shellole.c:304
BOOL WINAPI IsOS(DWORD feature)
Definition: ordinal.c:4107
#define EnableModeless(type)
Definition: ordinal.c:3540
DWORD WINAPI SHFillRectClr(HDC hDC, LPCRECT pRect, COLORREF cRef)
Definition: ordinal.c:2133
HRESULT WINAPI IUnknown_QueryService(IUnknown *, REFGUID, REFIID, LPVOID *)
Definition: ordinal.c:1501
HRESULT WINAPI IUnknown_GetClassID(IUnknown *lpUnknown, CLSID *clsid)
Definition: ordinal.c:1457
DWORD WINAPI SHMenuIndexFromID(HMENU hMenu, UINT uID)
Definition: ordinal.c:4541
HRESULT WINAPI IUnknown_SetSite(IUnknown *obj, IUnknown *site)
Definition: ordinal.c:1411
LPWSTR WINAPI PathFindExtensionW(LPCWSTR lpszPath)
Definition: path.c:447
DWORD WINAPI SHGetValueW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData)
Definition: reg.c:1236
INT WINAPI SHUnicodeToAnsi(LPCWSTR lpSrcStr, LPSTR lpDstStr, INT iLen)
Definition: string.c:2797
LPWSTR WINAPI StrFormatByteSizeW(LONGLONG llBytes, LPWSTR lpszDest, UINT cchMax)
Definition: string.c:2394
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
#define assert(x)
Definition: debug.h:53
#define pt(x, y)
Definition: drawing.c:79
static VOID BitBlt(_In_ ULONG Left, _In_ ULONG Top, _In_ ULONG Width, _In_ ULONG Height, _In_reads_bytes_(Delta *Height) PUCHAR Buffer, _In_ ULONG BitsPerPixel, _In_ ULONG Delta)
Definition: common.c:57
#define RGB(r, g, b)
Definition: precomp.h:71
#define GetBValue(quad)
Definition: precomp.h:75
#define GetGValue(quad)
Definition: precomp.h:74
#define GetRValue(quad)
Definition: precomp.h:73
#define UlongToPtr(u)
Definition: config.h:106
static IShellFolder IShellItem **static IBindCtx LPITEMIDLIST SFGAOF
Definition: ebrowser.c:83
POINTL point
Definition: edittest.c:50
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned short WORD
Definition: ntddk_ex.h:93
FxAutoRegKey hKey
pKey DeleteObject()
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLint GLint GLsizei width
Definition: gl.h:1546
GLuint res
Definition: glext.h:9613
GLuint buffer
Definition: glext.h:5915
const GLubyte * c
Definition: glext.h:8905
GLenum GLint GLuint mask
Definition: glext.h:6028
GLenum mode
Definition: glext.h:6217
GLenum const GLfloat * params
Definition: glext.h:5645
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLbitfield flags
Definition: glext.h:7161
GLuint64EXT * result
Definition: glext.h:11304
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint GLenum GLenum GLenum GLint GLuint GLenum GLenum GLfloat GLenum GLfloat GLenum map
Definition: glfuncs.h:262
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:1390
#define _(X)
Definition: i386-dis.c:35
BOOL WINAPI Shell_GetImageLists(HIMAGELIST *lpBigList, HIMAGELIST *lpSmallList)
Definition: iconcache.cpp:689
int WINAPI SHMapPIDLToSystemImageListIndex(IShellFolder *sh, LPCITEMIDLIST pidl, int *pIndex)
Definition: iconcache.cpp:772
REFIID riid
Definition: atlbase.h:39
REFIID LPVOID * ppv
Definition: atlbase.h:39
const DWORD DROPEFFECT_NONE
Definition: oleidl.idl:929
const DWORD DROPEFFECT_MOVE
Definition: oleidl.idl:931
struct IOleCommandTarget::_tagOLECMDTEXT OLECMDTEXT
struct IOleCommandTarget::_tagOLECMD OLECMD
HRESULT Write([in, size_is(cb)] const void *pv, [in] ULONG cb, [out] ULONG *pcbWritten)
HRESULT Read([out, size_is(cb), length_is(*pcbRead)] void *pv, [in] ULONG cb, [out] ULONG *pcbRead)
HRESULT GetControlWindow([in] UINT id, [out] HWND *phwnd)
struct IShellView2::_SV2CVW2_PARAMS * LPSV2CVW2_PARAMS
GUID SHELLVIEWID
Definition: shobjidl.idl:795
@ SV3CVW3_FORCEVIEWMODE
Definition: shobjidl.idl:837
@ SV3CVW3_FORCEFOLDERFLAGS
Definition: shobjidl.idl:838
DWORD SV3CVW3_FLAGS
Definition: shobjidl.idl:841
@ SVUIA_DEACTIVATE
Definition: shobjidl.idl:753
@ SVUIA_ACTIVATE_FOCUS
Definition: shobjidl.idl:755
@ SVUIA_ACTIVATE_NOFOCUS
Definition: shobjidl.idl:754
UINT SVSIF
Definition: shobjidl.idl:739
@ SVGIO_SELECTION
Definition: shobjidl.idl:744
@ SVGIO_BACKGROUND
Definition: shobjidl.idl:743
@ SVGIO_TYPE_MASK
Definition: shobjidl.idl:747
ULONG AddRef()
HRESULT QueryInterface([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
ULONG Release()
#define S_OK
Definition: intsafe.h:52
#define SUCCEEDED(hr)
Definition: intsafe.h:50
#define FAILED(hr)
Definition: intsafe.h:51
#define C_ASSERT(e)
Definition: intsafe.h:73
#define UINT_MAX
Definition: intsafe.h:152
#define debugstr_guid
Definition: kernel32.h:35
#define debugstr_w
Definition: kernel32.h:32
#define BEGIN_COM_MAP(x)
Definition: atlcom.h:581
#define COM_INTERFACE_ENTRY_IID(iid, x)
Definition: atlcom.h:601
#define END_COM_MAP()
Definition: atlcom.h:592
#define MESSAGE_HANDLER(msg, func)
Definition: atlwin.h:1926
#define BEGIN_MSG_MAP(theClass)
Definition: atlwin.h:1898
#define END_MSG_MAP()
Definition: atlwin.h:1917
GLint dy
Definition: linetemp.h:97
GLint y0
Definition: linetemp.h:96
if(dx< 0)
Definition: linetemp.h:194
GLint x0
Definition: linetemp.h:95
GLint dx
Definition: linetemp.h:97
#define HResultFromWin32
Definition: loader.cpp:14
#define error(str)
Definition: mkdosfs.c:1605
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define ASSERT(a)
Definition: mode.c:44
static PVOID ptr
Definition: dispmode.c:27
static HBITMAP
Definition: button.c:44
static HDC
Definition: imagelist.c:88
static HICON
Definition: imagelist.c:80
HRESULT hres
Definition: protocol.c:465
static HMODULE MODULEINFO DWORD cb
Definition: module.c:33
static const WCHAR sd[]
Definition: suminfo.c:286
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
Definition: ordinal.c:63
static ATOM item
Definition: dde.c:856
static HMENU hmenu
Definition: win.c:66
static int int const SCRIPT_CONTROL const SCRIPT_STATE SCRIPT_ITEM ULONG int * pcItems
Definition: usp10.c:62
WORD unused[29]
Definition: crypt.c:1155
REFCLSID clsid
Definition: msctf.c:82
_In_ HANDLE _In_ DWORD _In_ DWORD _Inout_opt_ LPOVERLAPPED _In_opt_ LPTRANSMIT_FILE_BUFFERS _In_ DWORD dwReserved
Definition: mswsock.h:95
unsigned int UINT
Definition: ndis.h:50
#define BOOL
Definition: nt_native.h:43
#define KEY_READ
Definition: nt_native.h:1023
#define DWORD
Definition: nt_native.h:44
#define DBG_UNREFERENCED_LOCAL_VARIABLE(L)
Definition: ntbasedef.h:327
#define UNICODE_NULL
_In_ HBITMAP hbm
Definition: ntgdi.h:2776
_Out_ LPRECT prc
Definition: ntgdi.h:1658
#define L(x)
Definition: ntvdm.h:50
#define STGM_WRITE
Definition: objbase.h:918
#define STGM_READ
Definition: objbase.h:917
#define V_VT(A)
Definition: oleauto.h:211
#define V_I4(A)
Definition: oleauto.h:247
#define V_INTREF(A)
Definition: oleauto.h:252
const GUID IID_IViewObject
const GUID IID_IDispatch
static TCHAR * items[]
Definition: page1.c:45
#define PathCombineW
Definition: pathcch.h:317
#define LOWORD(l)
Definition: pedump.c:82
#define WS_CHILD
Definition: pedump.c:617
#define WS_TABSTOP
Definition: pedump.c:634
#define WS_VISIBLE
Definition: pedump.c:620
short SHORT
Definition: pedump.c:59
long LONG
Definition: pedump.c:60
#define WS_CHILDWINDOW
Definition: pedump.c:639
#define WS_CLIPSIBLINGS
Definition: pedump.c:618
#define WS_CLIPCHILDREN
Definition: pedump.c:619
LPITEMIDLIST WINAPI SHCloneSpecialIDList(HWND hwndOwner, int nFolder, BOOL fCreate)
Definition: pidl.c:445
LPITEMIDLIST WINAPI ILClone(LPCITEMIDLIST pidl)
Definition: pidl.c:237
void WINAPI ILFree(LPITEMIDLIST pidl)
Definition: pidl.c:1044
LPITEMIDLIST WINAPI ILFindLastID(LPCITEMIDLIST pidl)
Definition: pidl.c:198
BOOL WINAPI ILIsParent(LPCITEMIDLIST pidlParent, LPCITEMIDLIST pidlChild, BOOL bImmediate)
Definition: pidl.c:697
LPITEMIDLIST WINAPI ILCombine(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
Definition: pidl.c:816
BOOL WINAPI ILRemoveLastID(LPITEMIDLIST pidl)
Definition: pidl.c:221
BOOL _ILIsSpecialFolder(LPCITEMIDLIST pidl)
Definition: pidl.c:2084
BOOL _ILIsFolder(LPCITEMIDLIST pidl)
Definition: pidl.c:2102
BOOL WINAPI SHGetPathFromIDListW(LPCITEMIDLIST pidl, LPWSTR pszPath)
Definition: pidl.c:1454
DWORD _ILGetFileSize(LPCITEMIDLIST pidl, LPWSTR pOut, UINT uOutSize)
Definition: pidl.c:2477
BOOL WINAPI ILIsEqual(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
Definition: pidl.c:582
#define INT
Definition: polytest.cpp:20
static const WCHAR szName[]
Definition: powrprof.c:45
EXTERN_C INT WINAPI SHGetPerScreenResName(_Out_writes_(cchBuffer) LPWSTR pszBuffer, _In_ INT cchBuffer, _In_ DWORD dwReserved)
Definition: propbag.cpp:1938
EXTERN_C HRESULT WINAPI IUnknown_QueryServicePropertyBag(_In_ IUnknown *punk, _In_ long flags, _In_ REFIID riid, _Outptr_ void **ppvObj)
Definition: propbag.cpp:1967
BOOL(CALLBACK * LPFNADDPROPSHEETPAGE)(HPROPSHEETPAGE, LPARAM)
Definition: prsht.h:327
#define LVIR_ICON
Definition: commctrl.h:2478
#define NM_RELEASEDCAPTURE
Definition: commctrl.h:141
#define Header_GetItem(hwndHD, i, phdi)
Definition: commctrl.h:751
#define LVM_GETCALLBACKMASK
Definition: commctrl.h:2421
#define LVSIL_SMALL
Definition: commctrl.h:2304
#define I_IMAGECALLBACK
Definition: commctrl.h:2390
#define LVN_GETDISPINFOA
Definition: commctrl.h:3158
#define LVS_EX_ONECLICKACTIVATE
Definition: commctrl.h:2740
#define ListView_IsGroupViewEnabled(hwnd)
Definition: commctrl.h:3012
#define ListView_GetItemRect(hwnd, i, prc, code)
Definition: commctrl.h:2483
#define LVS_SINGLESEL
Definition: commctrl.h:2271
#define LVS_ICON
Definition: commctrl.h:2266
#define LVS_SHAREIMAGELISTS
Definition: commctrl.h:2275
#define LVN_BEGINRDRAG
Definition: commctrl.h:3146
#define LVS_EX_LABELTIP
Definition: commctrl.h:2748
#define LVN_COLUMNCLICK
Definition: commctrl.h:3144
#define ListView_GetColumn(hwnd, iCol, pcol)
Definition: commctrl.h:2627
#define ListView_InsertColumn(hwnd, iCol, pcol)
Definition: commctrl.h:2641
#define LVS_NOCOLUMNHEADER
Definition: commctrl.h:2289
#define NM_DBLCLK
Definition: commctrl.h:131
#define LPSTR_TEXTCALLBACKW
Definition: commctrl.h:2385
#define LVIF_STATE
Definition: commctrl.h:2317
#define LVS_EX_SNAPTOGRID
Definition: commctrl.h:2753
#define ListView_GetEditControl(hwndLV)
Definition: commctrl.h:2548
#define Header_SetItem(hwndHD, i, phdi)
Definition: commctrl.h:758
#define LVS_TYPEMASK
Definition: commctrl.h:2270
#define LVNI_SELECTED
Definition: commctrl.h:2429
#define ListView_GetHeader(hwnd)
Definition: commctrl.h:2656
#define LVHT_ONITEM
Definition: commctrl.h:2502
#define CLR_NONE
Definition: commctrl.h:319
#define LVS_SHOWSELALWAYS
Definition: commctrl.h:2272
#define LVS_REPORT
Definition: commctrl.h:2267
#define LVS_SMALLICON
Definition: commctrl.h:2268
#define LVN_DELETEALLITEMS
Definition: commctrl.h:3139
#define LVM_SETCALLBACKMASK
Definition: commctrl.h:2424
#define LVA_DEFAULT
Definition: commctrl.h:2532
#define ListView_DeleteColumn(hwnd, iCol)
Definition: commctrl.h:2644
#define CDRF_DODEFAULT
Definition: commctrl.h:268
#define LVCF_WIDTH
Definition: commctrl.h:2592
#define TB_CHECKBUTTON
Definition: commctrl.h:1043
#define LVNI_FOCUSED
Definition: commctrl.h:2428
#define LVN_INSERTITEM
Definition: commctrl.h:3137
#define LVS_ALIGNTOP
Definition: commctrl.h:2284
#define ListView_GetNextItem(hwnd, i, flags)
Definition: commctrl.h:2439
#define HDN_ENDTRACKW
Definition: commctrl.h:850
#define DPA_FastGetPtr(hdpa, i)
Definition: commctrl.h:4965
#define NM_CLICK
Definition: commctrl.h:130
#define LVN_BEGINDRAG
Definition: commctrl.h:3145
#define LVS_EX_FULLROWSELECT
Definition: commctrl.h:2739
#define NM_KILLFOCUS
Definition: commctrl.h:136
#define SB_SETICON
Definition: commctrl.h:1966
#define LVS_EX_TRACKSELECT
Definition: commctrl.h:2737
#define LPSTR_TEXTCALLBACK
Definition: commctrl.h:2388
#define HDF_SORTUP
Definition: commctrl.h:724
#define ListView_GetOrigin(hwndLV, ppt)
Definition: commctrl.h:2674
#define NM_CUSTOMDRAW
Definition: commctrl.h:137
#define LVN_ENDLABELEDITW
Definition: commctrl.h:3143
#define TB_ENABLEBUTTON
Definition: commctrl.h:1042
#define LVIS_SELECTED
Definition: commctrl.h:2324
#define LVN_BEGINLABELEDITW
Definition: commctrl.h:3141
#define LVITEM
Definition: commctrl.h:2380
#define NM_RETURN
Definition: commctrl.h:132
#define ListView_RedrawItems(hwndLV, iFirst, iLast)
Definition: commctrl.h:2530
#define LVIF_PARAM
Definition: commctrl.h:2316
#define LVM_EDITLABEL
Definition: commctrl.h:2543
#define HDI_FORMAT
Definition: commctrl.h:705
struct tagNMLISTVIEW * LPNMLISTVIEW
#define LVM_GETITEMRECT
Definition: commctrl.h:2482
#define LVS_NOSORTHEADER
Definition: commctrl.h:2290
#define LVS_EDITLABELS
Definition: commctrl.h:2278
#define LVIF_TEXT
Definition: commctrl.h:2314
#define LVIR_SELECTBOUNDS
Definition: commctrl.h:2480
#define LVM_GETEXTENDEDLISTVIEWSTYLE
Definition: commctrl.h:2732
#define Header_GetItemCount(hwndHD)
Definition: commctrl.h:734
#define LVA_SNAPTOGRID
Definition: commctrl.h:2535
#define LVCF_FMT
Definition: commctrl.h:2591
#define NM_RCLICK
Definition: commctrl.h:133
#define NM_SETFOCUS
Definition: commctrl.h:135
#define LVCF_SUBITEM
Definition: commctrl.h:2594
#define LV_HITTESTINFO
Definition: commctrl.h:2509
#define DPA_GetPtrPtr(hdpa)
Definition: commctrl.h:4962
#define SB_SETTEXT
Definition: commctrl.h:1954
#define DPA_AppendPtr(hdpa, pitem)
Definition: commctrl.h:4963
#define DPA_GetPtrCount(hdpa)
Definition: commctrl.h:4960
#define SB_SETPARTS
Definition: commctrl.h:1959
#define LVN_GETDISPINFOW
Definition: commctrl.h:3159
#define LVS_EX_DOUBLEBUFFER
Definition: commctrl.h:2750
#define ListView_SetColumn(hwnd, iCol, pcol)
Definition: commctrl.h:2634
#define LVIF_IMAGE
Definition: commctrl.h:2315
#define LVS_ALIGNLEFT
Definition: commctrl.h:2285
#define ListView_GetItemSpacing(hwndLV, fSmall)
Definition: commctrl.h:2717
#define LVN_ITEMCHANGED
Definition: commctrl.h:3136
#define LVIF_DI_SETITEM
Definition: commctrl.h:3171
#define LVCF_TEXT
Definition: commctrl.h:2593
#define LVN_DELETEITEM
Definition: commctrl.h:3138
#define HDITEM
Definition: commctrl.h:697
#define LVIS_FOCUSED
Definition: commctrl.h:2323
#define HDF_SORTDOWN
Definition: commctrl.h:725
#define LVCOLUMN
Definition: commctrl.h:2586
#define LVS_AUTOARRANGE
Definition: commctrl.h:2277
#define LVS_LIST
Definition: commctrl.h:2269
#define LVS_EX_INFOTIP
Definition: commctrl.h:2744
#define LVN_ITEMACTIVATE
Definition: commctrl.h:3152
#define LVSIL_NORMAL
Definition: commctrl.h:2303
#define LVIS_CUT
Definition: commctrl.h:2325
#define LVNI_ALL
Definition: commctrl.h:2427
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
#define REFIID
Definition: guiddef.h:118
#define IsEqualCLSID(rclsid1, rclsid2)
Definition: guiddef.h:96
void redraw(int x, int y, int cx, int cy)
Definition: qtewin.cpp:1248
#define REGSTR_PATH_EXPLORER
Definition: regstr.h:33
IStream *WINAPI SHOpenRegStream2W(HKEY hKey, LPCWSTR pszSubkey, LPCWSTR pszValue, DWORD dwMode)
Definition: regstream.c:537
IStream *WINAPI SHCreateMemStream(const BYTE *lpbData, UINT dwDataLen)
Definition: regstream.c:652
#define EM_SCROLLCARET
Definition: richedit.h:81
#define WM_CONTEXTMENU
Definition: richedit.h:64
#define WM_PRINTCLIENT
Definition: richedit.h:70
#define WM_NOTIFY
Definition: richedit.h:61
HRESULT WINAPI SHForwardContextMenuMsg(IUnknown *pUnk, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *pResult, BOOL useIContextMenu2)
Definition: rosordinal.c:11
static calc_node_t temp
Definition: rpn_ieee.c:38
static HWND hEdit
Definition: autocomplete.c:34
#define ILGetSize
Definition: shellclasses.h:638
VOID WINAPI SHGetSetSettings(LPSHELLSTATE lpss, DWORD dwMask, BOOL bSet)
Definition: shellord.c:225
HRESULT WINAPI SHLimitInputEdit(HWND hWnd, IShellFolder *psf)
Definition: shellord.c:3048
BOOL WINAPI StrRetToStrNW(LPWSTR dest, DWORD len, LPSTRRET src, const ITEMIDLIST *pidl)
Definition: shellstring.c:85
BOOL WINAPI StrRetToStrNA(LPSTR dest, DWORD len, LPSTRRET src, const ITEMIDLIST *pidl)
Definition: shellstring.c:54
#define SHELL_GetSetting(pss, ssf, field)
Definition: shellutils.h:830
#define S_EQUAL
Definition: shellutils.h:621
#define SHELL_ErrorBox
Definition: shellutils.h:126
HRESULT hr
Definition: shlfolder.c:183
UINT WINAPI Shell_MergeMenus(HMENU hmDst, HMENU hmSrc, UINT uInsert, UINT uIDAdjust, UINT uIDAdjustMax, ULONG uFlags)
Definition: shlmenu.c:856
#define FCIDM_BROWSERLAST
Definition: shlobj.h:631
#define SHCNE_DRIVEREMOVED
Definition: shlobj.h:1905
#define SFVM_UPDATINGOBJECT
Definition: shlobj.h:1341
#define SHCNE_RMDIR
Definition: shlobj.h:1902
#define SFVM_DEFVIEWMODE
Definition: shlobj.h:1326
#define SHCNE_DELETE
Definition: shlobj.h:1900
#define SHCNE_MKDIR
Definition: shlobj.h:1901
#define SFVM_WINDOWCREATED
Definition: shlobj.h:1316
#define SHCNE_UPDATEITEM
Definition: shlobj.h:1911
#define SHCNE_RENAMEITEM
Definition: shlobj.h:1898
#define SSF_DOUBLECLICKINWEBVIEW
Definition: shlobj.h:1618
#define SHCNE_UPDATEDIR
Definition: shlobj.h:1910
#define SHCNE_MEDIAINSERTED
Definition: shlobj.h:1903
#define SHCNE_UPDATEIMAGE
Definition: shlobj.h:1913
#define SFVM_SIZE
Definition: shlobj.h:1347
#define SSF_WIN95CLASSIC
Definition: shlobj.h:1621
#define SHCNE_CREATE
Definition: shlobj.h:1899
#define FCIDM_MENU_VIEW_SEP_OPTIONS
Definition: shlobj.h:641
#define SHCNE_RENAMEFOLDER
Definition: shlobj.h:1915
#define SHCNRF_NewDelivery
Definition: shlobj.h:1946
#define MM_SUBMENUSHAVEIDS
Definition: shlobj.h:2537
#define MM_DONTREMOVESEPS
Definition: shlobj.h:2538
#define SHCNRF_ShellLevel
Definition: shlobj.h:1944
#define SHCNE_MEDIAREMOVED
Definition: shlobj.h:1904
#define FCIDM_MENU_FILE
Definition: shlobj.h:638
#define SHCNE_EXTENDED_EVENT
Definition: shlobj.h:1918
#define SHCNE_DRIVEADD
Definition: shlobj.h:1906
#define SHCNE_ASSOCCHANGED
Definition: shlobj.h:1919
#define CSIDL_DESKTOP
Definition: shlobj.h:2181
#define CSIDL_NETWORK
Definition: shlobj.h:2198
#define SFVM_COLUMNCLICK
Definition: shlobj.h:1323
#define SFVM_ADDPROPERTYPAGES
Definition: shlobj.h:1343
#define FCIDM_SHVIEWFIRST
Definition: shlobj.h:588
#define FCIDM_MENU_VIEW
Definition: shlobj.h:640
#define SHCNRF_InterruptLevel
Definition: shlobj.h:1943
#define SHCNE_ATTRIBUTES
Definition: shlobj.h:1909
#define SHCNE_ALLEVENTS
Definition: shlobj.h:1922
#define MM_ADDSEPARATOR
Definition: shlobj.h:2536
#define SSF_SHOWSUPERHIDDEN
Definition: shlobj.h:1629
#define SFVM_HWNDMAIN
Definition: shlobj.h:1342
#define SHCNE_FREESPACE
Definition: shlobj.h:1916
#define SFVM_FSNOTIFY
Definition: shlobj.h:1315
#define SSF_SHOWALLOBJECTS
Definition: shlobj.h:1613
#define FCIDM_MENU_EDIT
Definition: shlobj.h:639
@ REST_NOVIEWCONTEXTMENU
Definition: shlobj.h:1677
#define SFVM_QUERYFSNOTIFY
Definition: shlobj.h:1324
#define SFVM_GETNOTIFY
Definition: shlobj.h:1345
#define CSIDL_BITBUCKET
Definition: shlobj.h:2191
#define FCIDM_SHVIEWLAST
Definition: shlobj.h:622
#define DVCMDID_SET_DEFAULTFOLDER_SETTINGS
Definition: shlobj_undoc.h:78
#define DVCMDID_RESET_DEFAULTFOLDER_SETTINGS
Definition: shlobj_undoc.h:79
#define OS_SERVERADMINUI
Definition: shlwapi.h:2095
#define SHDeleteKey
Definition: shlwapi.h:53
HRESULT WINAPI SHPropertyBag_ReadDWORD(IPropertyBag *ppb, LPCWSTR pszPropName, DWORD *pdwValue)
HRESULT WINAPI SHPropertyBag_Delete(IPropertyBag *ppb, LPCWSTR pszPropName)
HRESULT WINAPI SHPropertyBag_ReadStream(IPropertyBag *ppb, LPCWSTR pszPropName, IStream **ppStream)
HRESULT WINAPI SHPropertyBag_WriteStream(IPropertyBag *ppb, LPCWSTR pszPropName, IStream *pStream)
HRESULT WINAPI SHPropertyBag_WriteDWORD(IPropertyBag *ppb, LPCWSTR pszPropName, DWORD dwValue)
FOLDERFLAGS
Definition: shobjidl.idl:641
@ FWF_SNAPTOGRID
Definition: shobjidl.idl:644
@ FWF_AUTOARRANGE
Definition: shobjidl.idl:642
@ FWF_NOGROUPING
Definition: shobjidl.idl:662
@ FWF_ALIGNLEFT
Definition: shobjidl.idl:653
@ FWF_NOSCROLL
Definition: shobjidl.idl:652
@ FWF_NOHEADERINALLVIEWS
Definition: shobjidl.idl:666
@ FWF_SINGLECLICKACTIVATE
Definition: shobjidl.idl:657
@ FWF_OWNERDATA
Definition: shobjidl.idl:645
@ FWF_FULLROWSELECT
Definition: shobjidl.idl:663
@ FWF_NOBROWSERVIEWSTATE
Definition: shobjidl.idl:670
@ FWF_NOCLIENTEDGE
Definition: shobjidl.idl:651
@ FWF_TRANSPARENT
Definition: shobjidl.idl:650
@ FWF_SINGLESEL
Definition: shobjidl.idl:648
@ FWF_NOCOLUMNHEADER
Definition: shobjidl.idl:665
@ FWF_DESKTOP
Definition: shobjidl.idl:647
@ FWF_NOSUBFOLDERS
Definition: shobjidl.idl:649
LPARAM LPFNSVADDPROPSHEETPAGE
Definition: shobjidl.idl:117
FOLDERVIEWMODE
Definition: shobjidl.idl:677
@ FVM_SMALLICON
Definition: shobjidl.idl:681
@ FVM_AUTO
Definition: shobjidl.idl:678
@ FVM_LIST
Definition: shobjidl.idl:682
@ FVM_TILE
Definition: shobjidl.idl:685
@ FVM_THUMBNAIL
Definition: shobjidl.idl:684
@ FVM_LAST
Definition: shobjidl.idl:688
@ FVM_THUMBSTRIP
Definition: shobjidl.idl:686
@ FVM_ICON
Definition: shobjidl.idl:679
@ FVM_DETAILS
Definition: shobjidl.idl:683
@ FVM_FIRST
Definition: shobjidl.idl:680
DWORD WINAPI SHRestricted(RESTRICTIONS rest)
Definition: shpolicy.c:150
#define FCIDM_SHVIEW_AUTOARRANGE
Definition: shresdef.h:869
#define FCIDM_SHVIEW_SELECTALL
Definition: shresdef.h:861
#define IDS_OBJECTS_SELECTED
Definition: shresdef.h:283
#define FCIDM_SHVIEW_CUT
Definition: shresdef.h:854
#define FCIDM_SHVIEW_LISTVIEW
Definition: shresdef.h:866
#define FCIDM_SHVIEW_UNDO
Definition: shresdef.h:857
#define FCIDM_SHVIEW_ALIGNTOGRID
Definition: shresdef.h:871
#define FCIDM_SHVIEW_COPY
Definition: shresdef.h:855
#define IDM_DVSELECT
Definition: shresdef.h:904
#define FCIDM_SHVIEW_BIGICON
Definition: shresdef.h:864
#define IDS_MYCOMPUTER
Definition: shresdef.h:279
#define FCIDM_SHVIEW_INSERTLINK
Definition: shresdef.h:858
#define FCIDM_SHVIEW_REFRESH
Definition: shresdef.h:879
#define IDI_SHELL_COMPUTER_DESKTOP
Definition: shresdef.h:673
#define FCIDM_SHVIEW_NEWFOLDER
Definition: shresdef.h:877
#define FCIDM_SHVIEW_SMALLICON
Definition: shresdef.h:865
#define FCIDM_TB_SMALLICON
Definition: shresdef.h:885
#define FCIDM_SHVIEW_PROPERTIES
Definition: shresdef.h:853
#define FCIDM_SHVIEW_SNAPTOGRID
Definition: shresdef.h:870
#define FCIDM_SHVIEW_VIEW
Definition: shresdef.h:851
#define FCIDM_SHVIEW_COPYTO
Definition: shresdef.h:859
#define FCIDM_SHVIEW_MOVETO
Definition: shresdef.h:860
#define FCIDM_SHVIEW_DELETE
Definition: shresdef.h:852
#define FCIDM_SHVIEW_RENAME
Definition: shresdef.h:874
#define IDS_OBJECTS
Definition: shresdef.h:282
#define FCIDM_TB_REPORTVIEW
Definition: shresdef.h:886
#define FCIDM_SHVIEW_REPORTVIEW
Definition: shresdef.h:867
#define IDA_SHELLVIEW
Definition: shresdef.h:26
#define FCIDM_SHVIEW_INVERTSELECTION
Definition: shresdef.h:862
#define FCIDM_SHVIEW_ARRANGE
Definition: shresdef.h:850
#define FCIDM_SHVIEW_INSERT
Definition: shresdef.h:856
ITEMIDLIST UNALIGNED * LPITEMIDLIST
Definition: shtypes.idl:41
ITEMID_CHILD UNALIGNED * PUITEMID_CHILD
Definition: shtypes.idl:68
@ STRRET_WSTR
Definition: shtypes.idl:85
const PCUITEMID_CHILD * PCUITEMID_CHILD_ARRAY
Definition: shtypes.idl:71
const ITEMID_CHILD UNALIGNED * PCUITEMID_CHILD
Definition: shtypes.idl:70
@ SHCOLSTATE_HIDDEN
Definition: shtypes.idl:129
@ SHCOLSTATE_SECONDARYUI
Definition: shtypes.idl:128
@ SHCOLSTATE_TYPE_STR
Definition: shtypes.idl:121
@ SHCOLSTATE_ONBYDEFAULT
Definition: shtypes.idl:125
const ITEMIDLIST_RELATIVE UNALIGNED * PCUIDLIST_RELATIVE
Definition: shtypes.idl:57
const ITEMIDLIST UNALIGNED * LPCITEMIDLIST
Definition: shtypes.idl:42
DWORD SHCOLSTATEF
Definition: shtypes.idl:142
HWND buttons[5]
Definition: sndrec32.cpp:40
#define _countof(array)
Definition: sndvol32.h:70
#define TRACE(s)
Definition: solgame.cpp:4
#define true
Definition: stdbool.h:36
#define false
Definition: stdbool.h:37
_In_ BOOLEAN Read
Definition: strmini.h:479
STRSAFEAPI StringCchPrintfW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszFormat,...)
Definition: strsafe.h:530
LPCFOLDERSETTINGS pfs
Definition: shobjidl.idl:801
SHELLVIEWID const * pvid
Definition: shobjidl.idl:804
IShellBrowser * psbOwner
Definition: shobjidl.idl:802
bool bLoadedFromViewState
Definition: CDefView.cpp:64
bool bColumnIsFolderColumn
Definition: CDefView.cpp:65
HMENU & m_hMenu
Definition: CDefView.cpp:136
CComPtr< IContextMenu > & m_pCM
Definition: CDefView.cpp:135
MenuCleanup(CComPtr< IContextMenu > &pCM, HMENU &menu)
Definition: CDefView.cpp:138
FOLDERSETTINGS FolderSettings
Definition: CDefView.cpp:100
static const UINT SIG
Definition: CDefView.cpp:95
static const UINT VALIDFWF
Definition: CDefView.cpp:99
static const UINT SIG
Definition: CDefView.cpp:87
UINT Columns[MAXCOUNT]
Definition: CDefView.cpp:90
BOOL fShowSuperHidden
Definition: shlobj.h:1565
BOOL fShowAllObjects
Definition: shlobj.h:1549
Definition: bl.h:1331
Definition: dpa.c:49
Definition: scsiwmi.h:51
IShellFolderViewCB * psfvcb
Definition: shlobj.h:1368
IShellView * psvOuter
Definition: shlobj.h:1367
UINT cbSize
Definition: shlobj.h:1365
IShellFolder * pshf
Definition: shlobj.h:1366
PCIDLIST_ABSOLUTE pidl
Definition: shlobj.h:1894
LONG cx
Definition: kdterminal.h:27
LONG cy
Definition: kdterminal.h:28
Definition: cache.c:49
Definition: name.c:39
Definition: pmap_prot.h:88
Definition: parse.h:23
LVITEMW item
Definition: commctrl.h:3184
LVITEMA item
Definition: commctrl.h:3179
int cchTextMax
Definition: commctrl.h:2354
LPSTR pszText
Definition: commctrl.h:2353
LPWSTR pszText
Definition: commctrl.h:2370
int iSubItem
Definition: commctrl.h:2367
int cchTextMax
Definition: commctrl.h:2371
UINT state
Definition: commctrl.h:2368
UINT mask
Definition: commctrl.h:2365
LPARAM lParam
Definition: commctrl.h:2373
UINT stateMask
Definition: commctrl.h:2369
int iImage
Definition: commctrl.h:2372
ULONG_PTR dwItemData
Definition: winuser.h:3279
LPWSTR dwTypeData
Definition: winuser.h:3280
UINT message
Definition: winuser.h:3126
WPARAM wParam
Definition: winuser.h:3127
UINT code
Definition: winuser.h:3170
HWND hwndFrom
Definition: winuser.h:3168
UINT uNewState
Definition: commctrl.h:3041
LPARAM lParam
Definition: commctrl.h:3045
UINT uOldState
Definition: commctrl.h:3042
long y
Definition: polytest.cpp:48
long x
Definition: polytest.cpp:48
LONG right
Definition: windef.h:308
LONG bottom
Definition: windef.h:309
LONG top
Definition: windef.h:307
LONG left
Definition: windef.h:306
HANDLE lEvent
Definition: tftpd.cpp:56
TW_UINT32 TW_UINT16 TW_UINT16 MSG
Definition: twain.h:1829
int32_t INT_PTR
Definition: typedefs.h:64
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
unsigned char * LPBYTE
Definition: typedefs.h:53
PVOID HANDLE
Definition: typedefs.h:73
ULONG_PTR SIZE_T
Definition: typedefs.h:80
int32_t INT
Definition: typedefs.h:58
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define MAKELONG(a, b)
Definition: typedefs.h:249
uint32_t ULONG
Definition: typedefs.h:59
#define HIWORD(l)
Definition: typedefs.h:247
#define CWM_GETISHELLBROWSER
Definition: undocshell.h:248
BOOL WINAPI SetShellWindowEx(HWND, HWND)
Definition: ntwrapper.h:58
Definition: pdh_main.c:96
DWORD dwAttributes
Definition: vdmdbg.h:34
#define _T(x)
Definition: vfdio.h:22
view_type
int ret
_In_ WDFCOLLECTION _In_ WDFOBJECT Item
_Must_inspect_result_ _In_ WDFDEVICE _In_ WDFSTRING String
Definition: wdfdevice.h:2433
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
#define ZeroMemory
Definition: winbase.h:1743
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176
_In_ void _In_ PCCERT_CONTEXT _In_opt_ LPFILETIME _In_ DWORD _In_ DWORD _Outptr_opt_ void ** ppvObject
Definition: wincrypt.h:6082
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG _In_ LONG y1
Definition: winddi.h:3709
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG x1
Definition: winddi.h:3708
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023
LONG_PTR LPARAM
Definition: windef.h:208
LONG_PTR LRESULT
Definition: windef.h:209
UINT_PTR WPARAM
Definition: windef.h:207
DWORD COLORREF
Definition: windef.h:300
void * arg
Definition: msvc.h:10
#define WINAPI
Definition: msvc.h:6
#define GET_Y_LPARAM(lp)
Definition: windowsx.h:300
#define GET_X_LPARAM(lp)
Definition: windowsx.h:299
#define S_FALSE
Definition: winerror.h:2357
#define DRAGDROP_S_USEDEFAULTCURSORS
Definition: winerror.h:2648
#define DRAGDROP_S_DROP
Definition: winerror.h:2646
#define E_NOINTERFACE
Definition: winerror.h:2364
#define NOERROR
Definition: winerror.h:2354
#define DRAGDROP_S_CANCEL
Definition: winerror.h:2647
#define E_UNEXPECTED
Definition: winerror.h:2456
#define HRESULT_CODE(hr)
Definition: winerror.h:76
#define ERROR_INVALID_DATA
Definition: winerror.h:116
LONG WINAPI GdiGetCharDimensions(HDC, LPTEXTMETRICW, LONG *)
Definition: font.c:2293
HGDIOBJ WINAPI SelectObject(_In_ HDC, _In_ HGDIOBJ)
Definition: dc.c:1546
HDC WINAPI CreateCompatibleDC(_In_opt_ HDC hdc)
#define CLR_INVALID
Definition: wingdi.h:883
#define SRCCOPY
Definition: wingdi.h:333
#define GetObject
Definition: wingdi.h:4468
BOOL WINAPI DeleteDC(_In_ HDC)
#define HKEY_CURRENT_USER
Definition: winreg.h:11
HWND WINAPI GetFocus(void)
Definition: window.c:1875
int WINAPI ReleaseDC(_In_opt_ HWND, _In_ HDC)
#define WM_ERASEBKGND
Definition: winuser.h:1636
#define MK_RBUTTON
Definition: winuser.h:2379
DWORD WINAPI GetSysColor(_In_ int)
HMENU WINAPI CreatePopupMenu(void)
Definition: menu.c:838
UINT WINAPI GetMenuDefaultItem(_In_ HMENU hMenu, _In_ UINT fByPos, _In_ UINT gmdiFlags)
#define MF_BYCOMMAND
Definition: winuser.h:202
#define SB_LINEUP
Definition: winuser.h:564
#define WM_HSCROLL
Definition: winuser.h:1754
#define MIIM_ID
Definition: winuser.h:733
#define COLOR_WINDOW
Definition: winuser.h:929
BOOL WINAPI SetMenuDefaultItem(_In_ HMENU, _In_ UINT, _In_ UINT)
int WINAPI GetMenuItemCount(_In_opt_ HMENU)
#define SPI_SETDESKWALLPAPER
Definition: winuser.h:1380
BOOL WINAPI PostMessageW(_In_opt_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
#define COLOR_WINDOWTEXT
Definition: winuser.h:932
#define WM_VSCROLL
Definition: winuser.h:1755
#define TPM_RIGHTBUTTON
Definition: winuser.h:2391
BOOL WINAPI GetWindowRect(_In_ HWND, _Out_ LPRECT)
#define WM_CREATE
Definition: winuser.h:1619
int WINAPI LoadStringW(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_writes_to_(cchBufferMax, return+1) LPWSTR lpBuffer, _In_ int cchBufferMax)
int WINAPIV wsprintfW(_Out_ LPWSTR, _In_ _Printf_format_string_ LPCWSTR,...)
BOOL WINAPI SetWindowPos(_In_ HWND, _In_opt_ HWND, _In_ int, _In_ int, _In_ int, _In_ int, _In_ UINT)
#define WM_DRAWCLIPBOARD
Definition: winuser.h:1880
#define WM_SIZE
Definition: winuser.h:1622
BOOL WINAPI InsertMenuW(_In_ HMENU, _In_ UINT, _In_ UINT, _In_ UINT_PTR, _In_opt_ LPCWSTR)
#define SB_VERT
Definition: winuser.h:553
HMENU WINAPI CreateMenu(void)
Definition: menu.c:829
#define SWP_NOMOVE
Definition: winuser.h:1255
#define WM_COMMAND
Definition: winuser.h:1751
#define MF_STRING
Definition: winuser.h:138
#define IDC_ARROW
Definition: winuser.h:695
#define WM_KEYFIRST
Definition: winuser.h:1725
#define VK_CONTROL
Definition: winuser.h:2214
#define MFS_DISABLED
Definition: winuser.h:760
#define WM_SETFOCUS
Definition: winuser.h:1624
BOOL WINAPI DeleteMenu(_In_ HMENU, _In_ UINT, _In_ UINT)
#define MF_CHECKED
Definition: winuser.h:132
#define SWP_NOSIZE
Definition: winuser.h:1256
UINT WINAPI GetMenuItemID(_In_ HMENU, _In_ int)
BOOL WINAPI MessageBeep(_In_ UINT uType)
#define WM_SYSCOLORCHANGE
Definition: winuser.h:1637
BOOL WINAPI TrackPopupMenuEx(_In_ HMENU, _In_ UINT, _In_ int, _In_ int, _In_ HWND, _In_opt_ LPTPMPARAMS)
#define WM_CHANGECBCHAIN
Definition: winuser.h:1885
#define WM_GETFONT
Definition: winuser.h:1662
BOOL WINAPI ClientToScreen(_In_ HWND, _Inout_ LPPOINT)
#define MF_UNCHECKED
Definition: winuser.h:204
#define TPM_TOPALIGN
Definition: winuser.h:2394
#define WM_DRAWITEM
Definition: winuser.h:1656
DWORD WINAPI CheckMenuItem(_In_ HMENU, _In_ UINT, _In_ UINT)
#define WM_NCCREATE
Definition: winuser.h:1694
#define MIIM_STATE
Definition: winuser.h:732
#define WM_ACTIVATE
Definition: winuser.h:1623
#define WM_SHOWWINDOW
Definition: winuser.h:1639
#define WM_SETTINGCHANGE
Definition: winuser.h:1640
BOOL WINAPI PtInRect(_In_ LPCRECT, _In_ POINT)
BOOL WINAPI GetClientRect(_In_ HWND, _Out_ LPRECT)
#define HWND_TOP
Definition: winuser.h:1218
HMENU WINAPI GetSubMenu(_In_ HMENU, _In_ int)
#define MIIM_SUBMENU
Definition: winuser.h:734
#define WM_INITMENUPOPUP
Definition: winuser.h:1757
#define MF_ENABLED
Definition: winuser.h:128
#define MF_SEPARATOR
Definition: winuser.h:137
#define EM_SETLIMITTEXT
Definition: winuser.h:2022
#define COLOR_DESKTOP
Definition: winuser.h:925
#define TPM_LEFTALIGN
Definition: winuser.h:2388
#define MF_BYPOSITION
Definition: winuser.h:203
BOOL WINAPI RemoveMenu(_In_ HMENU, _In_ UINT, _In_ UINT)
struct tagNMHDR * LPNMHDR
#define HTCLIENT
Definition: winuser.h:2486
#define SWP_SHOWWINDOW
Definition: winuser.h:1259
#define SendMessage
Definition: winuser.h:5863
#define LoadCursor
Definition: winuser.h:5832
WNDCLASSEXA WNDCLASSEX
Definition: winuser.h:5739
#define MFS_CHECKED
Definition: winuser.h:758
HDC WINAPI GetDC(_In_opt_ HWND)
#define SB_LINEDOWN
Definition: winuser.h:565
#define EM_SETSEL
Definition: winuser.h:2029
#define TPM_LEFTBUTTON
Definition: winuser.h:2390
#define WM_MEASUREITEM
Definition: winuser.h:1657
#define PostMessage
Definition: winuser.h:5852
BOOL WINAPI CheckMenuRadioItem(_In_ HMENU, _In_ UINT, _In_ UINT, _In_ UINT, _In_ UINT)
#define MAKEINTRESOURCEA(i)
Definition: winuser.h:581
HACCEL WINAPI LoadAcceleratorsW(_In_opt_ HINSTANCE, _In_ LPCWSTR)
BOOL WINAPI DestroyMenu(_In_ HMENU)
BOOL WINAPI GetMenuItemInfoW(_In_ HMENU, _In_ UINT, _In_ BOOL, _Inout_ LPMENUITEMINFOW)
int WINAPI TranslateAcceleratorW(_In_ HWND, _In_ HACCEL, _In_ LPMSG)
#define WM_SETCURSOR
Definition: winuser.h:1647
#define MK_LBUTTON
Definition: winuser.h:2378
#define VK_SHIFT
Definition: winuser.h:2213
#define SW_SHOW
Definition: winuser.h:786
BOOL WINAPI TrackPopupMenu(_In_ HMENU, _In_ UINT, _In_ int, _In_ int, _Reserved_ int, _In_ HWND, _Reserved_ LPCRECT)
#define WM_DESTROY
Definition: winuser.h:1620
#define WS_EX_CLIENTEDGE
Definition: winuser.h:384
#define SetWindowText
Definition: winuser.h:5877
int WINAPI GetScrollPos(_In_ HWND, _In_ int)
#define MAKEINTRESOURCEW(i)
Definition: winuser.h:582
HMENU WINAPI LoadMenuW(_In_opt_ HINSTANCE, _In_ LPCWSTR)
LRESULT(CALLBACK * WNDPROC)(HWND, UINT, WPARAM, LPARAM)
Definition: winuser.h:2917
#define TPM_RETURNCMD
Definition: winuser.h:2398
#define GWL_STYLE
Definition: winuser.h:863
#define CS_PARENTDC
Definition: winuser.h:664
#define TranslateAccelerator
Definition: winuser.h:5880
#define WM_KEYLAST
Definition: winuser.h:1739
BOOL WINAPI EnableMenuItem(_In_ HMENU, _In_ UINT, _In_ UINT)
#define WM_KILLFOCUS
Definition: winuser.h:1625
HICON WINAPI LoadIconW(_In_opt_ HINSTANCE hInstance, _In_ LPCWSTR lpIconName)
Definition: cursoricon.c:2412
#define MIIM_DATA
Definition: winuser.h:737
#define MIIM_TYPE
Definition: winuser.h:736
BOOL WINAPI MoveWindow(_In_ HWND, _In_ int, _In_ int, _In_ int, _In_ int, _In_ BOOL)
#define WM_GETDLGCODE
Definition: winuser.h:1700
LRESULT WINAPI SendMessageW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
BOOL WINAPI InsertMenuItemW(_In_ HMENU, _In_ UINT, _In_ BOOL, _In_ LPCMENUITEMINFOW)
#define SB_HORZ
Definition: winuser.h:552
SHORT WINAPI GetKeyState(_In_ int)
#define MF_GRAYED
Definition: winuser.h:129
BOOL WINAPI ScreenToClient(_In_ HWND, _Inout_ LPPOINT)
#define MF_DISABLED
Definition: winuser.h:130
static void Initialize()
Definition: xlate.c:212
#define IID_PPV_ARG(Itype, ppType)
#define IID_NULL_PPV_ARG(Itype, ppType)
static int insert
Definition: xmllint.c:138
const char * LPCSTR
Definition: xmlstorage.h:183
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
char CHAR
Definition: xmlstorage.h:175