ReactOS 0.4.16-dev-1489-g8fbbb41
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 INT FolderColumn; // Only valid during a sorting operation
69
70 enum { UNSPECIFIEDCOLUMN = -1 };
71 void Reset()
72 {
73 *(UINT*)this = 0;
75 }
76};
77
78#define SHV_CHANGE_NOTIFY (WM_USER + 0x1111)
79#define SHV_UPDATESTATUSBAR (WM_USER + 0x1112)
80
81// For the context menu of the def view, the id of the items are based on 1 because we need
82// to call TrackPopupMenu and let it use the 0 value as an indication that the menu was canceled
83#define CONTEXT_MENU_BASE_ID 1
84
86{
87 enum { MAXCOUNT = 100 };
88 static const UINT SIG = ('R' << 0) | ('O' << 8) | ('S' << 16) | (('c') << 24);
92};
93
95{
96 static const UINT SIG = ('R' << 0) | ('O' << 8) | ('S' << 16) | (('c' ^ 'v' ^ 's') << 24);
100 static const UINT VALIDFWF = FWF_AUTOARRANGE | FWF_SNAPTOGRID | FWF_NOGROUPING; // Note: The desktop applies FWF_NOICONS when appropriate
102};
103
104static UINT
106{
107 UINT cmf = CMF_NORMAL;
108 if (GetKeyState(VK_SHIFT) < 0)
109 cmf |= CMF_EXTENDEDVERBS;
110 if (sfgao & SFGAO_CANRENAME)
111 cmf |= CMF_CANRENAME;
112 HWND hwnd = NULL;
113 if (pSB && SUCCEEDED(pSB->GetControlWindow(FCW_TREE, &hwnd)) && hwnd)
114 cmf |= CMF_EXPLORE;
115 return cmf;
116}
117
118// Convert client coordinates to listview coordinates
119static void
121{
122 POINT Origin = {};
123
124 // FIXME: LVM_GETORIGIN is broken. See CORE-17266
125 if (!ListView_GetOrigin(hwndLV, &Origin))
126 return;
127
128 ppt->x += Origin.x;
129 ppt->y += Origin.y;
130}
131
132// Helper struct to automatically cleanup the IContextMenu
133// We want to explicitly reset the Site, so there are no circular references
135{
138
140 : m_pCM(pCM), m_hMenu(menu)
141 {
142 }
144 {
145 if (m_pCM)
146 {
148 m_pCM.Release();
149 }
150 if (m_hMenu)
151 {
153 m_hMenu = NULL;
154 }
155 }
156};
157
159{
160 MENUITEMINFOW mii;
161 mii.cbSize = sizeof(mii);
163 mii.fState = MF & (MFS_CHECKED | MFS_DISABLED);
164 mii.fType = MF & ~mii.fState;
165 mii.wID = Id;
166 mii.dwTypeData = const_cast<LPWSTR>(String);
167 mii.dwItemData = Data;
168 return InsertMenuItemW(hMenu, -1, TRUE, &mii);
169}
170
172{
173 MENUITEMINFOW mii;
174 mii.cbSize = FIELD_OFFSET(MENUITEMINFOW, hbmpItem);
175 mii.fMask = MIIM_DATA;
176 if (GetMenuItemInfoW(hMenu, Id, FALSE, &mii))
177 return mii.dwItemData;
178 else
179 return 0;
180}
181
183{
184 MENUITEMINFOW mii = {sizeof(mii), MIIM_SUBMENU};
185 if (::GetMenuItemInfoW(hmenu, id, FALSE, &mii))
186 return mii.hSubMenu;
187
188 return NULL;
189}
190
191/* ReallyGetMenuItemID returns the id of an item even if it opens a submenu,
192 GetMenuItemID returns -1 if the specified item opens a submenu */
194{
195 MENUITEMINFOW mii = {sizeof(mii), MIIM_ID};
196 if (::GetMenuItemInfoW(hmenu, i, TRUE, &mii))
197 return mii.wID;
198
199 return UINT_MAX;
200}
201
203{
204 UINT ret = 0;
205 HDC hDC = GetDC(hwnd);
206 if (hDC)
207 {
210 SelectObject(hDC, hOrg);
212 }
213 return ret;
214}
215
216static inline COLORREF GetViewColor(COLORREF Clr, UINT SysFallback)
217{
218 return Clr != CLR_INVALID ? Clr : GetSysColor(SysFallback);
219}
220
221class CDefView :
222 public CWindowImpl<CDefView, CWindow, CControlWinTraits>,
223 public CComObjectRootEx<CComMultiThreadModelNoCS>,
224 public IShellView3,
225 public IFolderView,
226 public IShellFolderView,
227 public IOleCommandTarget,
228 public IDropTarget,
229 public IDropSource,
230 public IViewObject,
231 public IServiceProvider
232{
233private:
242 ClipboardViewerChain m_ClipboardChain;
246 HMENU m_hMenu; // Handle to the menu bar of the browser
247 HMENU m_hMenuArrangeModes; // Handle to the popup menu with the arrange modes
248 HMENU m_hMenuViewModes; // Handle to the popup menu with the view modes
249 HMENU m_hContextMenu; // Handle to the open context menu
258 ULONG m_hNotify; // Change notification handle
259 HACCEL m_hAccel;
263 // for drag and drop
265 CComPtr<IDropTarget> m_pCurDropTarget; // The sub-item, which is currently dragged over
266 CComPtr<IDataObject> m_pCurDataObject; // The dragged data-object
267 LONG m_iDragOverItem; // Dragged over item's index, if m_pCurDropTarget != NULL
268 UINT m_cScrollDelay; // Send a WM_*SCROLL msg every 250 ms during drag-scroll
269 POINT m_ptLastMousePos; // Mouse position at last DragOver call
270 POINT m_ptFirstMousePos; // Mouse position when the drag operation started
272 //
275
277 signed char m_SpecialFolder;
281
285
287
289 BOOL _Sort(int Col = -1);
296 void _DoCopyToMoveToFolder(BOOL bCopy);
298
299 inline BOOL IsSpecialFolder(int &csidl) const
300 {
301 csidl = m_SpecialFolder;
302 return m_SpecialFolder >= 0;
303 }
304
305public:
306 CDefView();
307 ~CDefView();
312 void UpdateStatusbar();
314 void CheckToolbar();
316 void UpdateListColors();
317 BOOL InitList();
318 static INT CALLBACK ListViewCompareItems(LPARAM lParam1, LPARAM lParam2, LPARAM lpData);
319
324 HRESULT LoadColumn(UINT FoldCol, UINT ListCol, BOOL Insert, UINT ForceWidth = 0);
325 HRESULT LoadColumns(SIZE_T *pColList = NULL, UINT ColListCount = 0);
326 void ColumnListChanged();
329 void RefreshGhostedState();
333 int LV_AddItem(PCUITEMID_CHILD pidl);
338 void LV_RefreshIcon(INT iItem);
339 void LV_RefreshIcons();
341 HRESULT FillList(BOOL IsRefreshCommand = TRUE);
345 HRESULT FillArrangeAsMenu(HMENU hmenuArrange);
346 HRESULT CheckViewMode(HMENU hmenuView);
348 HRESULT SelectAndPositionItem(int Idx, UINT fSVSI, POINT *ppt);
352 void OnDeactivate();
353 void DoActivate(UINT uState);
354 HRESULT drag_notify_subitem(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect);
355 HRESULT InvokeContextMenuCommand(CComPtr<IContextMenu>& pCM, LPCSTR lpVerb, POINT* pt = NULL, bool TryMapVerb = false);
356 LRESULT OnExplorerCommand(UINT uCommand, BOOL bUseSelection);
358 HRESULT GetDefaultViewStream(DWORD Stgm, IStream **ppStream);
360 HRESULT SaveViewState(IStream *pStream);
363
365 {
368 {
369 DWORD flags;
370 if (SUCCEEDED(pcdb2->GetViewFlags(&flags)))
371 return flags;
372 }
373 return 0;
374 }
375
376 // *** IOleWindow methods ***
377 STDMETHOD(GetWindow)(HWND *lphwnd) override;
378 STDMETHOD(ContextSensitiveHelp)(BOOL fEnterMode) override;
379
380 // *** IShellView methods ***
381 STDMETHOD(TranslateAccelerator)(MSG *pmsg) override;
382 STDMETHOD(EnableModeless)(BOOL fEnable) override;
383 STDMETHOD(UIActivate)(UINT uState) override;
384 STDMETHOD(Refresh)() override;
385 STDMETHOD(CreateViewWindow)(IShellView *psvPrevious, LPCFOLDERSETTINGS pfs, IShellBrowser *psb, RECT *prcView, HWND *phWnd) override;
386 STDMETHOD(DestroyViewWindow)() override;
389 STDMETHOD(SaveViewState)() override;
390 STDMETHOD(SelectItem)(PCUITEMID_CHILD pidlItem, SVSIF uFlags) override;
391 STDMETHOD(GetItemObject)(UINT uItem, REFIID riid, void **ppv) override;
392
393 // *** IShellView2 methods ***
394 STDMETHOD(GetView)(SHELLVIEWID *view_guid, ULONG view_type) override;
395 STDMETHOD(CreateViewWindow2)(LPSV2CVW2_PARAMS view_params) override;
396 STDMETHOD(HandleRename)(LPCITEMIDLIST pidl) override;
398
399 // *** IShellView3 methods ***
401 IShellBrowser *psb,
402 IShellView *psvPrevious,
403 SV3CVW3_FLAGS view_flags,
407 const SHELLVIEWID *view_id,
408 const RECT *prcView,
409 HWND *hwnd) override;
410
411 // *** IFolderView methods ***
412 STDMETHOD(GetCurrentViewMode)(UINT *pViewMode) override;
413 STDMETHOD(SetCurrentViewMode)(UINT ViewMode) override;
414 STDMETHOD(GetFolder)(REFIID riid, void **ppv) override;
415 STDMETHOD(Item)(int iItemIndex, PITEMID_CHILD *ppidl) override;
416 STDMETHOD(ItemCount)(UINT uFlags, int *pcItems) override;
417 STDMETHOD(Items)(UINT uFlags, REFIID riid, void **ppv) override;
418 STDMETHOD(GetSelectionMarkedItem)(int *piItem) override;
419 STDMETHOD(GetFocusedItem)(int *piItem) override;
420 STDMETHOD(GetItemPosition)(PCUITEMID_CHILD pidl, POINT *ppt) override;
421 STDMETHOD(GetSpacing)(POINT *ppt) override;
422 STDMETHOD(GetDefaultSpacing)(POINT *ppt) override;
423 STDMETHOD(GetAutoArrange)() override;
424 STDMETHOD(SelectItem)(int iItem, DWORD dwFlags) override;
426
427 // *** IShellFolderView methods ***
428 STDMETHOD(Rearrange)(LPARAM sort) override;
430 STDMETHOD(ArrangeGrid)() override;
431 STDMETHOD(AutoArrange)() override;
432 STDMETHOD(AddObject)(PITEMID_CHILD pidl, UINT *item) override;
433 STDMETHOD(GetObject)(PITEMID_CHILD *pidl, UINT item) override;
434 STDMETHOD(RemoveObject)(PITEMID_CHILD pidl, UINT *item) override;
437 STDMETHOD(UpdateObject)(PITEMID_CHILD pidl_old, PITEMID_CHILD pidl_new, UINT *item) override;
439 STDMETHOD(SetRedraw)(BOOL redraw) override;
442 STDMETHOD(IsDropOnSource)(IDropTarget *drop_target) override;
443 STDMETHOD(GetDragPoint)(POINT *pt) override;
444 STDMETHOD(GetDropPoint)(POINT *pt) override;
446 STDMETHOD(SetItemPos)(PCUITEMID_CHILD pidl, POINT *pt) override;
447 STDMETHOD(IsBkDropTarget)(IDropTarget *drop_target) override;
448 STDMETHOD(SetClipboard)(BOOL move) override;
450 STDMETHOD(GetItemSpacing)(ITEMSPACING *spacing) override;
451 STDMETHOD(SetCallback)(IShellFolderViewCB *new_cb, IShellFolderViewCB **old_cb) override;
452 STDMETHOD(Select)(UINT flags) override;
453 STDMETHOD(QuerySupport)(UINT *support) override;
454 STDMETHOD(SetAutomationObject)(IDispatch *disp) override;
455
456 // *** IOleCommandTarget methods ***
457 STDMETHOD(QueryStatus)(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT *pCmdText) override;
458 STDMETHOD(Exec)(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut) override;
459
460 // *** IDropTarget methods ***
461 STDMETHOD(DragEnter)(IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect) override;
462 STDMETHOD(DragOver)(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect) override;
463 STDMETHOD(DragLeave)() override;
464 STDMETHOD(Drop)(IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect) override;
465
466 // *** IDropSource methods ***
467 STDMETHOD(QueryContinueDrag)(BOOL fEscapePressed, DWORD grfKeyState) override;
468 STDMETHOD(GiveFeedback)(DWORD dwEffect) override;
469
470 // *** IViewObject methods ***
471 STDMETHOD(Draw)(DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd,
472 HDC hdcTargetDev, HDC hdcDraw, LPCRECTL lprcBounds, LPCRECTL lprcWBounds,
473 BOOL (STDMETHODCALLTYPE *pfnContinue)(ULONG_PTR dwContinue), ULONG_PTR dwContinue) override;
474 STDMETHOD(GetColorSet)(DWORD dwDrawAspect, LONG lindex, void *pvAspect,
475 DVTARGETDEVICE *ptd, HDC hicTargetDev, LOGPALETTE **ppColorSet) override;
476 STDMETHOD(Freeze)(DWORD dwDrawAspect, LONG lindex, void *pvAspect, DWORD *pdwFreeze) override;
477 STDMETHOD(Unfreeze)(DWORD dwFreeze) override;
478 STDMETHOD(SetAdvise)(DWORD aspects, DWORD advf, IAdviseSink *pAdvSink) override;
479 STDMETHOD(GetAdvise)(DWORD *pAspects, DWORD *pAdvf, IAdviseSink **ppAdvSink) override;
480
481 // *** IServiceProvider methods ***
482 STDMETHOD(QueryService)(REFGUID guidService, REFIID riid, void **ppvObject) override;
483
484 // Message handlers
487 LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
493 LRESULT OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
495 LRESULT OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
499 LRESULT OnCommand(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
500 LRESULT OnNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
508
509 virtual VOID OnFinalMessage(HWND) override;
510
512 {
513 static ATL::CWndClassInfo wc =
514 {
516 0, 0, NULL, NULL,
517 LoadCursor(NULL, IDC_ARROW), NULL, NULL, L"SHELLDLL_DefView", NULL
518 },
519 NULL, NULL, IDC_ARROW, TRUE, 0, _T("")
520 };
521 return wc;
522 }
523
524 virtual WNDPROC GetWindowProc() override
525 {
526 return WindowProc;
527 }
528
530 {
531 CDefView *pThis;
533
534 // Must hold a reference during message handling
535 pThis = reinterpret_cast<CDefView *>(hWnd);
536 pThis->AddRef();
538 pThis->Release();
539 return result;
540 }
541
568
570 // Windows returns E_NOINTERFACE for IOleWindow
571 // COM_INTERFACE_ENTRY_IID(IID_IOleWindow, IOleWindow)
572 COM_INTERFACE_ENTRY_IID(IID_IShellView, IShellView)
574 COM_INTERFACE_ENTRY_IID(IID_IShellView2, IShellView2)
575 COM_INTERFACE_ENTRY_IID(IID_IShellView3, IShellView3)
576 COM_INTERFACE_ENTRY_IID(IID_IFolderView, IFolderView)
577 COM_INTERFACE_ENTRY_IID(IID_IShellFolderView, IShellFolderView)
578 COM_INTERFACE_ENTRY_IID(IID_IOleCommandTarget, IOleCommandTarget)
579 COM_INTERFACE_ENTRY_IID(IID_IDropTarget, IDropTarget)
580 COM_INTERFACE_ENTRY_IID(IID_IDropSource, IDropSource)
582 COM_INTERFACE_ENTRY_IID(IID_IServiceProvider, IServiceProvider)
584};
585
586#define ID_LISTVIEW 1
587
588// windowsx.h
589#define GET_WM_COMMAND_ID(wp, lp) LOWORD(wp)
590#define GET_WM_COMMAND_HWND(wp, lp) (HWND)(lp)
591#define GET_WM_COMMAND_CMD(wp, lp) HIWORD(wp)
592
594
596 m_ListView(),
598 m_hMenu(NULL),
603 m_uState(0),
604 m_cidl(0),
605 m_apidl(NULL),
608 m_hNotify(0),
609 m_hAccel(NULL),
610 m_dwAspects(0),
611 m_dwAdvf(0),
615 m_SpecialFolder(-1),
620{
627
631}
632
634{
635 TRACE(" destroying IShellView(%p)\n", this);
636
638
640 {
643 }
644
645 if (m_hWnd)
646 {
648 }
649
653}
654
656{
657 m_pSFParent = shellFolder;
659 shellFolder->QueryInterface(IID_PPV_ARG(IShellDetails, &m_pSDParent));
660
661 return S_OK;
662}
663
664// ##### helperfunctions for communication with ICommDlgBrowser #####
665
667{
668 HRESULT ret = S_OK;
669 if (m_pCommDlgBrowser && !(GetCommDlgViewFlags() & CDB2GVF_NOINCLUDEITEM))
670 {
671 TRACE("ICommDlgBrowser::IncludeObject pidl=%p\n", pidl);
672 ret = m_pCommDlgBrowser->IncludeObject(this, pidl);
673 TRACE("-- returns 0x%08x\n", ret);
674 }
675 else if (m_pFolderFilter)
676 {
677 ret = m_pFolderFilter->ShouldShow(m_pSFParent, m_pidlParent, pidl);
678 }
679 return ret;
680}
681
683{
685
686 if (m_pCommDlgBrowser.p != NULL)
687 {
688 TRACE("ICommDlgBrowser::OnDefaultCommand\n");
689 ret = m_pCommDlgBrowser->OnDefaultCommand(this);
690 TRACE("-- returns 0x%08x\n", ret);
691 }
692
693 return ret;
694}
695
697{
699
700 if (m_pCommDlgBrowser.p != NULL)
701 {
702 TRACE("ICommDlgBrowser::OnStateChange flags=%x\n", uFlags);
703 ret = m_pCommDlgBrowser->OnStateChange(this, uFlags);
704 TRACE("--\n");
705 }
706
707 return ret;
708}
709/**********************************************************
710 * set the toolbar of the filedialog buttons
711 *
712 * - activates the buttons from the shellbrowser according to
713 * the view state
714 */
716{
718
719 TRACE("\n");
720
721 if (m_pCommDlgBrowser != NULL)
722 {
723 m_pShellBrowser->SendControlMsg(FCW_TOOLBAR, TB_CHECKBUTTON,
725 m_pShellBrowser->SendControlMsg(FCW_TOOLBAR, TB_CHECKBUTTON,
727 m_pShellBrowser->SendControlMsg(FCW_TOOLBAR, TB_ENABLEBUTTON,
729 m_pShellBrowser->SendControlMsg(FCW_TOOLBAR, TB_ENABLEBUTTON,
731 }
732}
733
735{
736 WCHAR szFormat[MAX_PATH];
737 WCHAR szPartText[MAX_PATH];
738 UINT cSelectedItems;
739
740 if (!m_ListView)
741 return;
742
743 cSelectedItems = m_ListView.GetSelectedCount();
744 if (cSelectedItems)
745 {
747 StringCchPrintfW(szPartText, _countof(szPartText), szFormat, cSelectedItems);
748 }
749 else
750 {
751 LoadStringW(shell32_hInstance, IDS_OBJECTS, szFormat, _countof(szFormat));
752 StringCchPrintfW(szPartText, _countof(szPartText), szFormat, m_ListView.GetItemCount());
753 }
754
755 LRESULT lResult;
756 m_pShellBrowser->SendControlMsg(FCW_STATUS, SB_SETTEXT, 0, (LPARAM)szPartText, &lResult);
757
758 // Don't bother with the extra processing if we only have one StatusBar part
760 {
761 UINT64 uTotalFileSize = 0;
762 WORD uFileFlags = LVNI_ALL;
763 INT nItem = -1;
764 bool bIsOnlyFoldersSelected = true;
765
766 // If we have something selected then only count selected file sizes
767 if (cSelectedItems)
768 {
769 uFileFlags = LVNI_SELECTED;
770 }
771
772 while ((nItem = m_ListView.GetNextItem(nItem, uFileFlags)) >= 0)
773 {
774 PCUITEMID_CHILD pidl = _PidlByItem(nItem);
775
776 uTotalFileSize += _ILGetFileSize(pidl, NULL, 0);
777
778 if (!_ILIsFolder(pidl))
779 {
780 bIsOnlyFoldersSelected = false;
781 }
782 }
783
784 // Don't show the file size text if there is 0 bytes in the folder
785 // OR we only have folders selected
786 if ((cSelectedItems && !bIsOnlyFoldersSelected) || uTotalFileSize)
787 StrFormatByteSizeW(uTotalFileSize, szPartText, _countof(szPartText));
788 else
789 *szPartText = 0;
790
791 m_pShellBrowser->SendControlMsg(FCW_STATUS, SB_SETTEXT, 1, (LPARAM)szPartText, &lResult);
792 }
793
794 SFGAOF att = 0;
795 if (cSelectedItems > 0)
796 {
797 UINT maxquery = 42; // Checking the attributes can be slow, only check small selections (_DoCopyToMoveToFolder will verify the full array)
798 att = SFGAO_CANCOPY | SFGAO_CANMOVE;
799 if (cSelectedItems <= maxquery && (!GetSelections() || FAILED(m_pSFParent->GetAttributesOf(m_cidl, m_apidl, &att))))
800 att = 0;
801 }
802 m_pShellBrowser->SendControlMsg(FCW_TOOLBAR, TB_ENABLEBUTTON, FCIDM_SHVIEW_COPYTO, (att & SFGAO_CANCOPY) != 0, &lResult);
803 m_pShellBrowser->SendControlMsg(FCW_TOOLBAR, TB_ENABLEBUTTON, FCIDM_SHVIEW_MOVETO, (att & SFGAO_CANMOVE) != 0, &lResult);
804}
805
807{
808 LRESULT lResult;
809 LPARAM pIcon = NULL;
810 WCHAR szPartText[MAX_PATH];
811 *szPartText = 0;
813 {
814 // If we are in a Recycle Bin then show no text for the location part
815 int csidl;
816 if (!IsSpecialFolder(csidl) || (csidl != CSIDL_NETWORK && csidl != CSIDL_BITBUCKET))
817 {
818 LoadStringW(shell32_hInstance, IDS_MYCOMPUTER, szPartText, _countof(szPartText));
819 pIcon = (LPARAM)m_hMyComputerIcon;
820 }
821 /*else if (csidl == CSIDL_NETWORK) // TODO: Figure out the type of share (My Computer/Local Intranet/Internet?)
822 {
823 ImageList_GetIconSize(ListView_GetImageList(m_ListView, LVSIL_SMALL), &x, &y);
824 pIcon = (LPARAM)LoadImage(shell32_hInstance, MAKEINTRESOURCEW(IDI_SHELL_MY_NETWORK_PLACES),
825 IMAGE_ICON, x, y, LR_SHARED);
826 }*/
827 }
828 m_pShellBrowser->SendControlMsg(FCW_STATUS, SB_SETICON, 2, pIcon, &lResult);
829 m_pShellBrowser->SendControlMsg(FCW_STATUS, SB_SETTEXT, 2, (LPARAM)szPartText, &lResult);
830}
831
833{
836 return 0;
837}
838
839
840// ##### helperfunctions for initializing the view #####
841
842// creates the list view window
844{
845 HRESULT hr;
846 DWORD dwStyle, dwExStyle, ListExStyle;
847 UINT ViewMode;
848
849 TRACE("%p\n", this);
850
852 LVS_SHAREIMAGELISTS | LVS_EDITLABELS | LVS_AUTOARRANGE; // FIXME: Remove LVS_AUTOARRANGE when the view is able to save ItemPos
854 ListExStyle = LVS_EX_INFOTIP | LVS_EX_LABELTIP;
855
857 {
859 dwStyle |= LVS_ALIGNLEFT;
860 // LVS_EX_REGIONAL?
861 }
862 else
863 {
864 dwStyle |= LVS_SHOWSELALWAYS; // MSDN says FWF_SHOWSELALWAYS is deprecated, always turn on for folders
866#if 0 // FIXME: Temporarily disabled until ListView is fixed (CORE-19624, CORE-19818)
867 ListExStyle |= LVS_EX_DOUBLEBUFFER;
868#endif
869 }
870
871 ViewMode = m_FolderSettings.ViewMode;
872 hr = _DoFolderViewCB(SFVM_DEFVIEWMODE, 0, (LPARAM)&ViewMode);
873 if (SUCCEEDED(hr))
874 {
875 if (ViewMode >= FVM_FIRST && ViewMode <= FVM_LAST)
876 m_FolderSettings.ViewMode = ViewMode;
877 else
878 ERR("Ignoring invalid ViewMode from SFVM_DEFVIEWMODE: %u (was: %u)\n", ViewMode, m_FolderSettings.ViewMode);
879 }
880
882 {
883 case FVM_ICON:
884 dwStyle |= LVS_ICON;
885 break;
886 case FVM_DETAILS:
887 dwStyle |= LVS_REPORT;
888 break;
889 case FVM_SMALLICON:
890 dwStyle |= LVS_SMALLICON;
891 break;
892 case FVM_LIST:
893 dwStyle |= LVS_LIST;
894 break;
895 default:
896 dwStyle |= LVS_LIST;
897 break;
898 }
899
901 dwStyle |= LVS_AUTOARRANGE;
902
904 ListExStyle |= LVS_EX_SNAPTOGRID;
905
907 dwStyle |= LVS_SINGLESEL;
908
910 ListExStyle |= LVS_EX_FULLROWSELECT;
911
912 ListExStyle |= GetItemActivateFlags();
913 if (ListExStyle & LVS_EX_ONECLICKACTIVATE)
914 ListExStyle |= SHELL_GetIconUnderlineFlags();
915
917 dwStyle |= LVS_NOCOLUMNHEADER;
918
919#if 0
920 // FIXME: Because this is a negative, everyone gets the new flag by default unless they
921 // opt out. This code should be enabled when shell looks like Vista instead of 2003
923 ListExStyle |= LVS_EX_HEADERINALLVIEWS;
924#endif
925
927 dwExStyle &= ~WS_EX_CLIENTEDGE;
928
929 RECT rcListView = {0,0,0,0};
930 m_ListView.Create(m_hWnd, rcListView, L"FolderView", dwStyle, dwExStyle, ID_LISTVIEW);
931
932 if (!m_ListView)
933 return FALSE;
934
936
937 /* UpdateShellSettings(); */
938 return TRUE;
939}
940
942{
944 {
945 /* Check if drop shadows option is enabled */
946 BOOL bDropShadow = FALSE;
947 DWORD cbDropShadow = sizeof(bDropShadow);
948
949 /*
950 * The desktop ListView always take the default desktop colours, by
951 * remaining transparent and letting user32/win32k paint itself the
952 * desktop background color, if any.
953 */
955
956 SHGetValueW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced",
957 L"ListviewShadow", NULL, &bDropShadow, &cbDropShadow);
958 if (bDropShadow)
959 {
960 /* Set the icon background transparent */
962 m_ListView.SetTextColor(RGB(255, 255, 255));
963 m_ListView.SetExtendedListViewStyle(LVS_EX_TRANSPARENTSHADOWTEXT, LVS_EX_TRANSPARENTSHADOWTEXT);
964 }
965 else
966 {
967 /* Set the icon background as the same colour as the desktop */
969 m_ListView.SetTextBkColor(crDesktop);
970 if (GetRValue(crDesktop) + GetGValue(crDesktop) + GetBValue(crDesktop) > 128 * 3)
971 m_ListView.SetTextColor(RGB(0, 0, 0));
972 else
973 m_ListView.SetTextColor(RGB(255, 255, 255));
974 m_ListView.SetExtendedListViewStyle(0, LVS_EX_TRANSPARENTSHADOWTEXT);
975 }
976 }
977 else
978 {
981
982 // Background is painted by the parent via WM_PRINTCLIENT
983 m_ListView.SetExtendedListViewStyle(LVS_EX_TRANSPARENTBKGND, LVS_EX_TRANSPARENTBKGND);
984 }
985}
986
987// adds all needed columns to the shellview
989{
990 HIMAGELIST big_icons, small_icons;
991
992 TRACE("%p\n", this);
993
995
996 Shell_GetImageLists(&big_icons, &small_icons);
998 m_ListView.SetImageList(small_icons, LVSIL_SMALL);
999
1001
1003 UINT ColumnCount = pColumns ? DPA_GetPtrCount(m_LoadColumnsList) : 0;
1004 LoadColumns(pColumns, ColumnCount);
1006 {
1010 }
1011 return TRUE;
1012}
1013
1014/**********************************************************
1015* Column handling
1016*/
1018{
1019 LVCOLUMN lvc;
1020 lvc.mask = LVCF_SUBITEM;
1021 if (!ListView_GetColumn(List, Col, &lvc))
1022 return E_FAIL;
1023 else
1024 return lvc.iSubItem;
1025}
1026
1028{
1029 // This function is only called during column management, performance is not critical.
1030 for (UINT i = 0;; ++i)
1031 {
1033 if ((UINT)r == FoldCol)
1034 return i;
1035 else if (FAILED(r))
1036 return r;
1037 }
1038}
1039
1041{
1042 // This function is called every time a LVITEM::iSubItem is mapped to
1043 // a folder column (calls to GetDetailsOf etc.) and should be fast.
1045 {
1047 if (ListCol < count)
1048 {
1050 assert(col >= 0 && col == SHGetLVColumnSubItem(m_ListView.m_hWnd, ListCol));
1051 return col;
1052 }
1053 else if (count)
1054 {
1055 TRACE("m_ListToFolderColMap cache miss while mapping %d\n", ListCol);
1056 }
1057 }
1058 return SHGetLVColumnSubItem(m_ListView.m_hWnd, ListCol);
1059}
1060
1062{
1063 // According to learn.microsoft.com/en-us/windows/win32/shell/sfvm-getdetailsof
1064 // the query order is IShellFolder2, IShellDetails, SFVM_GETDETAILSOF.
1065 HRESULT hr = E_FAIL;
1066 if (m_pSF2Parent)
1067 {
1068 hr = m_pSF2Parent->GetDetailsOf(pidl, FoldCol, &sd);
1069 }
1070 if (FAILED(hr) && m_pSDParent)
1071 {
1072 hr = m_pSDParent->GetDetailsOf(pidl, FoldCol, &sd);
1073 }
1074#if 0 // TODO
1075 if (FAILED(hr))
1076 {
1077 FIXME("Try SFVM_GETDETAILSOF\n");
1078 }
1079#endif
1080 return hr;
1081}
1082
1084{
1086 if (SUCCEEDED(hr))
1087 return GetDetailsByFolderColumn(pidl, hr, sd);
1088 ERR("Unable to determine folder column from list column %d\n", (int) ListCol);
1089 return hr;
1090}
1091
1092HRESULT CDefView::LoadColumn(UINT FoldCol, UINT ListCol, BOOL Insert, UINT ForceWidth)
1093{
1096 HRESULT hr;
1097
1098 sd.str.uType = !STRRET_WSTR; // Make sure "uninitialized" uType is not WSTR
1099 hr = GetDetailsByFolderColumn(NULL, FoldCol, sd);
1100 if (FAILED(hr))
1101 return hr;
1102 hr = StrRetToStrNW(buf, _countof(buf), &sd.str, NULL);
1103 if (FAILED(hr))
1104 return hr;
1105
1106 UINT chavewidth = CalculateCharWidth(m_ListView.m_hWnd);
1107 if (!chavewidth)
1108 chavewidth = 6; // 6 is a reasonable default fallback
1109
1110 LVCOLUMN lvc;
1111 lvc.mask = LVCF_TEXT | LVCF_FMT | LVCF_WIDTH | LVCF_SUBITEM;
1112 lvc.pszText = buf;
1113 lvc.fmt = sd.fmt;
1114 lvc.cx = ForceWidth ? ForceWidth : (sd.cxChar * chavewidth); // FIXME: DPI?
1115 lvc.iSubItem = FoldCol; // Used by MapFolderColumnToListColumn & MapListColumnToFolderColumn
1116 if ((int)ListCol == -1)
1117 {
1118 assert(Insert); // You can insert at the end but you can't change something that is not there
1119 if (Insert)
1120 ListCol = 0x7fffffff;
1121 }
1122 if (Insert)
1123 ListView_InsertColumn(m_ListView.m_hWnd, ListCol, &lvc);
1124 else
1125 ListView_SetColumn(m_ListView.m_hWnd, ListCol, &lvc);
1126 return S_OK;
1127}
1128
1130{
1131 HWND hWndHdr = ListView_GetHeader(m_ListView.m_hWnd);
1132 UINT newColCount = 0, oldColCount = Header_GetItemCount(hWndHdr);
1133 UINT width = 0, foldCol, i;
1134 HRESULT hr = S_FALSE;
1135
1137 for (i = 0, foldCol = 0;; ++foldCol)
1138 {
1139 if (newColCount >= 0xffff)
1140 break; // CompareIDs limit reached
1141
1142 if (pColList)
1143 {
1144 if (i >= ColListCount)
1145 break;
1146 width = HIWORD(pColList[i]);
1147 foldCol = LOWORD(pColList[i++]);
1148 }
1149
1150 SHCOLSTATEF state = 0;
1151 if (!m_pSF2Parent || FAILED(m_pSF2Parent->GetDefaultColumnState(foldCol, &state)))
1153
1154 if (foldCol == 0)
1155 {
1156 // Force the first column
1157 }
1158 else if (state & SHCOLSTATE_HIDDEN)
1159 {
1160 continue;
1161 }
1162 else if (!pColList && !(state & SHCOLSTATE_ONBYDEFAULT))
1163 {
1164 continue;
1165 }
1166
1167 bool insert = newColCount >= oldColCount;
1168 UINT listCol = insert ? -1 : newColCount;
1169 hr = LoadColumn(foldCol, listCol, insert, width);
1170 if (FAILED(hr))
1171 {
1172 if (!pColList)
1173 hr = S_OK; // No more items, we are done
1174 break;
1175 }
1176 ++newColCount;
1177 }
1178 for (i = newColCount; i < oldColCount; ++i)
1179 {
1181 }
1182
1185 assert(SUCCEEDED(MapFolderColumnToListColumn(0))); // We don't allow turning off the Name column
1187 {
1190 }
1191 return hr;
1192}
1193
1195{
1197 m_ListToFolderColMap = NULL; // No cache while we are building the cache
1199 for (UINT i = 0;; ++i)
1200 {
1202 if (FAILED(hr))
1203 break; // No more columns
1204 if (!DPA_SetPtr(cache, i, (void*)(INT_PTR) hr))
1205 break; // Cannot allow holes in the cache, must stop now.
1206 }
1208
1209 for (;;)
1210 {
1212 break;
1213 }
1215 if (hMenu)
1216 {
1217 hMenu = GetSubmenuByID(hMenu, FCIDM_SHVIEW_ARRANGE);
1218 for (UINT i = DVIDM_ARRANGESORT_FIRST; i <= DVIDM_ARRANGESORT_LAST && hMenu; ++i)
1219 {
1220 RemoveMenu(hMenu, i, MF_BYCOMMAND);
1221 }
1222 if ((int) GetMenuItemID(hMenu, 0) <= 0)
1223 RemoveMenu(hMenu, 0, MF_BYPOSITION); // Separator
1224 }
1226 LVCOLUMN lvc;
1227 lvc.mask = LVCF_TEXT;
1228 lvc.pszText = buf;
1229 lvc.cchTextMax = _countof(buf);
1230 for (UINT listCol = 0; listCol < DEFVIEW_ARRANGESORT_MAXENUM; ++listCol)
1231 {
1232 if (!ListView_GetColumn(m_ListView.m_hWnd, listCol, &lvc))
1233 break;
1234 HRESULT foldCol = MapListColumnToFolderColumn(listCol);
1235 assert(SUCCEEDED(foldCol));
1238 DVIDM_ARRANGESORT_FIRST + listCol, lvc.pszText, listCol);
1239 }
1240
1241 ListView_RedrawItems(m_ListView.m_hWnd, 0, 0x7fffffff);
1242 m_ListView.InvalidateRect(NULL, TRUE);
1243}
1244
1245/*************************************************************************
1246 * ShellView_ListViewCompareItems
1247 *
1248 * Compare Function for the Listview (FileOpen Dialog)
1249 *
1250 * PARAMS
1251 * lParam1 [I] the first ItemIdList to compare with
1252 * lParam2 [I] the second ItemIdList to compare with
1253 * lpData [I] The column ID for the header Ctrl to process
1254 *
1255 * RETURNS
1256 * A negative value if the first item should precede the second,
1257 * a positive value if the first item should follow the second,
1258 * or zero if the two items are equivalent
1259 */
1261{
1262 PCUIDLIST_RELATIVE pidl1 = reinterpret_cast<PCUIDLIST_RELATIVE>(lParam1);
1263 PCUIDLIST_RELATIVE pidl2 = reinterpret_cast<PCUIDLIST_RELATIVE>(lParam2);
1264 CDefView *pThis = reinterpret_cast<CDefView*>(lpData);
1265
1266 HRESULT hres = pThis->m_pSFParent->CompareIDs(pThis->m_sortInfo.FolderColumn, pidl1, pidl2);
1268 return 0;
1269
1270 SHORT nDiff = HRESULT_CODE(hres);
1271 return nDiff * pThis->m_sortInfo.Direction;
1272}
1273
1275{
1276 HWND hHeader;
1277 HDITEM hColumn;
1278 int prevCol = m_sortInfo.ListColumn;
1280
1281 // FIXME: Is this correct? Who sets this style?
1282 // And if it is set, should it also block sorting using the menu?
1283 // Any why should it block sorting when the view is loaded initially?
1284 if (m_ListView.GetWindowLongPtr(GWL_STYLE) & LVS_NOSORTHEADER)
1285 return TRUE;
1286
1287 hHeader = ListView_GetHeader(m_ListView.m_hWnd);
1288 if (Col != -1)
1289 {
1290 if (Col >= Header_GetItemCount(hHeader))
1291 {
1292 ERR("Sort column out of range\n");
1293 return FALSE;
1294 }
1295
1296 if (prevCol == Col)
1297 m_sortInfo.Direction *= -1;
1298 else
1300 m_sortInfo.ListColumn = Col;
1301 }
1302 if (!m_sortInfo.Direction)
1303 m_sortInfo.Direction += 1;
1304
1305 /* If the sorting column changed, remove the sorting style from the old column */
1306 if (prevCol != -1 && prevCol != m_sortInfo.ListColumn)
1307 {
1308 hColumn.mask = HDI_FORMAT;
1309 Header_GetItem(hHeader, prevCol, &hColumn);
1310 hColumn.fmt &= ~(HDF_SORTUP | HDF_SORTDOWN);
1311 Header_SetItem(hHeader, prevCol, &hColumn);
1312 }
1313
1314 /* Set the sorting style on the new column */
1315 hColumn.mask = HDI_FORMAT;
1316 Header_GetItem(hHeader, m_sortInfo.ListColumn, &hColumn);
1317 hColumn.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
1318 hColumn.fmt |= (m_sortInfo.Direction > 0 ? HDF_SORTUP : HDF_SORTDOWN);
1319 Header_SetItem(hHeader, m_sortInfo.ListColumn, &hColumn);
1320
1324}
1325
1327{
1328 SFGAOF Attr = (SFGAOF)Query;
1329 return SUCCEEDED(m_pSFParent->GetAttributesOf(1, &pidl, &Attr)) ? (Attr & Query) : 0;
1330}
1331
1333{
1334 PCUITEMID_CHILD pItem = _PidlByItem(i);
1335 return pItem ? GetItemAttributes(pItem, Query) : 0;
1336}
1337
1339{
1340 if (!m_ListView)
1341 return nullptr;
1342 return reinterpret_cast<PCUITEMID_CHILD>(m_ListView.GetItemData(i));
1343}
1344
1346{
1347 if (!m_ListView)
1348 return nullptr;
1349 return reinterpret_cast<PCUITEMID_CHILD>(lvItem.lParam);
1350}
1351
1353{
1355
1356 int cItems = m_ListView.GetItemCount();
1358 for (int i = 0; i < cItems; i++)
1359 {
1360 PCUITEMID_CHILD currentpidl = _PidlByItem(i);
1361 HRESULT hr = m_pSFParent->CompareIDs(lParam, pidl, currentpidl);
1362 if (SUCCEEDED(hr))
1363 {
1364 if (hr == S_EQUAL)
1365 return i;
1366 }
1367 else
1368 {
1369#if DBG
1370 for (i = 0; pidl && i < cItems; i++)
1371 {
1372 currentpidl = _PidlByItem(i);
1373 if (currentpidl && currentpidl->mkid.cb == pidl->mkid.cb && !memcmp(currentpidl, pidl, pidl->mkid.cb))
1374 DbgPrint("Matched item #%d, broken CompareIDs?\n", i);
1375 }
1376#endif
1377 break;
1378 }
1379 }
1380 return -1;
1381}
1382
1384{
1385 LVITEMW lvItem;
1386
1387 TRACE("(%p)(pidl=%p)\n", this, pidl);
1388
1390
1392 return -1;
1393
1395 lvItem.iItem = m_ListView.GetItemCount(); // add item to lists end
1396 lvItem.iSubItem = 0;
1397 lvItem.lParam = reinterpret_cast<LPARAM>(ILClone(pidl)); // set item's data
1398 lvItem.pszText = LPSTR_TEXTCALLBACKW; // get text on a callback basis
1399 lvItem.iImage = I_IMAGECALLBACK; // get image on a callback basis
1400 lvItem.stateMask = LVIS_CUT;
1401 if (m_HasCutItems)
1402 lvItem.state = GetItemAttributes(pidl, SFGAO_HIDDEN | SFGAO_GHOSTED) ? LVIS_CUT : 0;
1403
1404 return m_ListView.InsertItem(&lvItem);
1405}
1406
1408{
1409 int nIndex;
1410
1411 TRACE("(%p)(pidl=%p)\n", this, pidl);
1412
1414
1415 nIndex = LV_FindItemByPidl(pidl);
1416 if (nIndex < 0)
1417 return FALSE;
1418
1420
1421 return m_ListView.DeleteItem(nIndex);
1422}
1423
1425{
1426 int nItem;
1427 LVITEMW lvItem;
1428
1429 TRACE("(%p)(pidlold=%p pidlnew=%p)\n", this, pidlOld, pidlNew);
1430
1432
1433 nItem = LV_FindItemByPidl(pidlOld);
1434
1435 if (-1 != nItem)
1436 {
1437 lvItem.mask = LVIF_PARAM; // only the pidl
1438 lvItem.iItem = nItem;
1439 lvItem.iSubItem = 0;
1440 m_ListView.GetItem(&lvItem);
1441
1442 // Store old pidl until new item is replaced
1443 LPVOID oldPidl = reinterpret_cast<LPVOID>(lvItem.lParam);
1444
1445 lvItem.mask = LVIF_PARAM | LVIF_IMAGE | LVIF_TEXT;
1446 lvItem.iItem = nItem;
1447 lvItem.iSubItem = 0;
1448 lvItem.lParam = reinterpret_cast<LPARAM>(ILClone(pidlNew)); // set item's data
1451 m_ListView.SetItem(&lvItem);
1452 m_ListView.Update(nItem);
1453
1454 // Now that the new item is in place, we can safely release the old pidl
1455 SHFree(oldPidl);
1456
1457 return TRUE; // FIXME: better handling
1458 }
1459
1460 return FALSE;
1461}
1462
1464{
1465 BOOL bResult = FALSE;
1466 LVITEMW lvItem;
1467 if (nItem >= 0)
1468 {
1470
1471 lvItem.mask = LVIF_IMAGE | LVIF_STATE;
1472 lvItem.iItem = nItem;
1473 lvItem.iSubItem = 0;
1475 lvItem.stateMask = LVIS_CUT;
1476 if (m_HasCutItems)
1477 lvItem.state = GetItemAttributes(pidl, SFGAO_HIDDEN | SFGAO_GHOSTED) ? LVIS_CUT : 0;
1478 PCUITEMID_CHILD pidlOld = _PidlByItem(nItem);
1479 if (pidlOld && (lvItem.lParam = reinterpret_cast<LPARAM>(ILClone(pidl))) != NULL)
1480 lvItem.mask |= LVIF_PARAM;
1481 bResult = m_ListView.SetItem(&lvItem);
1482 if (bResult && lvItem.lParam && pidlOld)
1483 ILFree(const_cast<PUITEMID_CHILD>(pidlOld));
1484 for (UINT i = 0; m_ListView.SetItemText(nItem, i, LPSTR_TEXTCALLBACK); ++i) {} // Update all columns
1485 }
1486 return bResult;
1487}
1488
1490{
1491 TRACE("(%p)(pidl=%p)\n", this, pidl);
1493 INT nItem = LV_FindItemByPidl(pidl);
1494 return nItem >= 0 ? LV_UpdateItem(nItem, pidl) : FALSE;
1495}
1496
1498{
1500
1501 LVITEMW lvItem = { LVIF_IMAGE };
1502 lvItem.iItem = iItem;
1503 lvItem.iImage = I_IMAGECALLBACK;
1504 m_ListView.SetItem(&lvItem);
1505 m_ListView.Update(iItem);
1506}
1507
1509{
1511
1512 for (INT iItem = -1;;)
1513 {
1514 iItem = ListView_GetNextItem(m_ListView, iItem, LVNI_ALL);
1515 if (iItem == -1)
1516 break;
1517
1518 LV_RefreshIcon(iItem);
1519 }
1520}
1521
1523{
1524 PITEMID_CHILD pidl = static_cast<PITEMID_CHILD>(ptr);
1525 CDefView *pThis = static_cast<CDefView *>(arg);
1526
1527 // in a commdlg this works as a filemask
1528 if (pThis->IncludeObject(pidl) == S_OK && pThis->m_ListView)
1529 pThis->LV_AddItem(pidl);
1530
1531 SHFree(pidl);
1532 return TRUE;
1533}
1534
1536// - gets the objectlist from the shellfolder
1537// - sorts the list
1538// - fills the list into the view
1540{
1541 CComPtr<IEnumIDList> pEnumIDList;
1542 PITEMID_CHILD pidl;
1543 DWORD dwFetched;
1544 HRESULT hRes;
1545 HDPA hdpa;
1546 DWORD dFlags = SHCONTF_NONFOLDERS | ((m_FolderSettings.fFlags & FWF_NOSUBFOLDERS) ? 0 : SHCONTF_FOLDERS);
1547
1548 TRACE("%p\n", this);
1549
1550 SHELLSTATE shellstate;
1552 if (GetCommDlgViewFlags() & CDB2GVF_SHOWALLFILES)
1553 shellstate.fShowAllObjects = shellstate.fShowSuperHidden = TRUE;
1554
1555 if (shellstate.fShowAllObjects)
1556 {
1557 dFlags |= SHCONTF_INCLUDEHIDDEN;
1558 m_ListView.SendMessageW(LVM_SETCALLBACKMASK, LVIS_CUT, 0);
1559 }
1560 if (shellstate.fShowSuperHidden)
1561 {
1562 dFlags |= SHCONTF_INCLUDESUPERHIDDEN;
1563 m_ListView.SendMessageW(LVM_SETCALLBACKMASK, LVIS_CUT, 0);
1564 }
1565
1566 // get the itemlist from the shfolder
1567 hRes = m_pSFParent->EnumObjects(m_hWnd, dFlags, &pEnumIDList);
1568 if (hRes != S_OK)
1569 {
1570 if (hRes == S_FALSE)
1571 return(NOERROR);
1572 return(hRes);
1573 }
1574
1575 // create a pointer array
1576 hdpa = DPA_Create(16);
1577 if (!hdpa)
1578 return(E_OUTOFMEMORY);
1579
1580 // copy the items into the array
1581 while((S_OK == pEnumIDList->Next(1, &pidl, &dwFetched)) && dwFetched)
1582 {
1583 if (DPA_AppendPtr(hdpa, pidl) == -1)
1584 {
1585 SHFree(pidl);
1586 }
1587 }
1588
1589 // turn listview's redrawing off
1591
1592 DPA_DestroyCallback( hdpa, fill_list, this);
1593
1594 /* sort the array */
1595 int sortCol = -1;
1596 if (!IsRefreshCommand && !m_sortInfo.bLoadedFromViewState) // Are we loading for the first time?
1597 {
1599 sortCol = 0; // In case the folder does not know/care
1600 if (m_pSF2Parent)
1601 {
1602 ULONG folderSortCol = sortCol, dummy;
1603 HRESULT hr = m_pSF2Parent->GetDefaultColumn(NULL, &folderSortCol, &dummy);
1604 if (SUCCEEDED(hr))
1605 hr = MapFolderColumnToListColumn(folderSortCol);
1606 if (SUCCEEDED(hr))
1607 sortCol = (int) hr;
1608 }
1609 }
1610 _Sort(sortCol);
1611
1613 {
1616 }
1617
1618 // load custom background image and custom text color
1621
1622 // turn listview's redrawing back on and force it to draw
1624
1626
1628 {
1629 // redraw now
1630 m_ListView.InvalidateRect(NULL, TRUE);
1631 }
1632
1633 if (IsRefreshCommand)
1635
1637
1638 return S_OK;
1639}
1640
1642{
1643 if (m_ListView.IsWindow())
1644 m_ListView.UpdateWindow();
1645 bHandled = FALSE;
1646 return 0;
1647}
1648
1650{
1651 return m_ListView.SendMessageW(uMsg, 0, 0);
1652}
1653
1655{
1656 if (!m_Destroyed)
1657 {
1658 m_Destroyed = TRUE;
1661 m_hNotify = NULL;
1662 m_ClipboardChain.Unhook(m_hWnd);
1663 if (m_pFileMenu)
1664 {
1666 m_pFileMenu = NULL;
1667 }
1668 if (m_hMenu)
1669 {
1671 m_hMenu = NULL;
1672 }
1675 }
1676 bHandled = FALSE;
1677 return 0;
1678}
1679
1681{
1682 /* redirect to parent */
1685
1686 bHandled = FALSE;
1687 return 0;
1688}
1689
1690static VOID
1692{
1693 INT x0 = prc->left, y0 = prc->top, x1 = prc->right, y1 = prc->bottom;
1694 x0 += dx;
1695 y0 += dy;
1696
1697 HDC hMemDC = CreateCompatibleDC(hDC);
1698 HGDIOBJ hbmOld = SelectObject(hMemDC, hbm);
1699
1700 for (INT y = y0; y < y1; y += nHeight)
1701 {
1702 for (INT x = x0; x < x1; x += nWidth)
1703 {
1704 BitBlt(hDC, x, y, nWidth, nHeight, hMemDC, 0, 0, SRCCOPY);
1705 }
1706 }
1707
1708 SelectObject(hMemDC, hbmOld);
1709 DeleteDC(hMemDC);
1710}
1711
1713{
1714 HDC hDC = (HDC)wParam;
1715
1716 RECT rc;
1718
1720 {
1721 BITMAP bm;
1722 if (::GetObject(m_viewinfo_data.hbmBack, sizeof(BITMAP), &bm))
1723 {
1724 INT dx = -(::GetScrollPos(m_ListView, SB_HORZ) % bm.bmWidth);
1725 INT dy = -(::GetScrollPos(m_ListView, SB_VERT) % bm.bmHeight);
1726 DrawTileBitmap(hDC, &rc, m_viewinfo_data.hbmBack, bm.bmWidth, bm.bmHeight, dx, dy);
1727 }
1728 }
1729 else
1730 {
1732 }
1733
1734 bHandled = TRUE;
1735
1736 return TRUE;
1737}
1738
1740{
1741 /* Update desktop labels color */
1743
1744 /* Forward WM_SYSCOLORCHANGE to common controls */
1745 return m_ListView.SendMessageW(uMsg, 0, 0);
1746}
1747
1749{
1750 return reinterpret_cast<LRESULT>(m_pShellBrowser.p);
1751}
1752
1754{
1755 this->AddRef();
1756 bHandled = FALSE;
1757 return 0;
1758}
1759
1761{
1762 this->Release();
1763}
1764
1766{
1769
1770 TRACE("%p\n", this);
1771
1773 {
1774 if (FAILED(RegisterDragDrop(m_hWnd, pdt)))
1775 ERR("Error Registering DragDrop\n");
1776 }
1777
1778 /* register for receiving notifications */
1779 m_pSFParent->QueryInterface(IID_PPV_ARG(IPersistFolder2, &ppf2));
1780 if (ppf2)
1781 {
1782 ppf2->GetCurFolder(&m_pidlParent);
1783 }
1784
1785 if (CreateList())
1786 {
1787 if (InitList())
1788 {
1789 FillList(FALSE);
1790 }
1791 }
1792
1794 {
1795 HWND hwndSB;
1796 m_pShellBrowser->GetWindow(&hwndSB);
1798 }
1799
1800 // Set up change notification
1801 LPITEMIDLIST pidlTarget = NULL;
1802 LONG fEvents = 0;
1803 HRESULT hr = _DoFolderViewCB(SFVM_GETNOTIFY, (WPARAM)&pidlTarget, (LPARAM)&fEvents);
1804 if (FAILED(hr) || (!pidlTarget && !fEvents)) // FIXME: MSDN says both zero means no notifications
1805 {
1806 pidlTarget = m_pidlParent;
1807 fEvents = SHCNE_ALLEVENTS;
1808 }
1809 SHChangeNotifyEntry ntreg = {};
1811 if (FAILED(hr))
1812 {
1813 ntreg.fRecursive = FALSE;
1814 ntreg.pidl = pidlTarget;
1815 }
1819 fEvents, SHV_CHANGE_NOTIFY,
1820 1, &ntreg);
1821
1823
1824 int bForceFullStatusBar = false;
1825 BOOL bIsFileSystem = SHGetAttributes(NULL, m_pidlParent, SFGAO_FILESYSTEM) & SFGAO_FILESYSTEM;
1826 m_SpecialFolder = bIsFileSystem ? -1 : 0x7f; // FS folder or "generic" CSIDL
1828 {
1830 }
1831 else if (IsEqualPersistClassID(ppf2, CLSID_RecycleBin))
1832 {
1833 m_SpecialFolder = bForceFullStatusBar = CSIDL_BITBUCKET;
1834 }
1835 else if (bIsFileSystem)
1836 {
1838 if (ILIsParent(pidlNet, m_pidlParent, FALSE) && ILGetSize(pidlNet) < ILGetSize(m_pidlParent))
1840 }
1841 m_isFullStatusBar = bIsFileSystem || bForceFullStatusBar;
1842 _ForceStatusBarResize(); // This handles changing StatusBar parts
1845
1846 return S_OK;
1847}
1848
1849// #### Handling of the menus ####
1850
1852{
1854 if (!hFileMenu)
1855 return E_FAIL;
1856
1857 /* Cleanup the items added previously */
1858 for (int i = GetMenuItemCount(hFileMenu) - 1; i >= 0; i--)
1859 {
1860 UINT id = GetMenuItemID(hFileMenu, i);
1861 if (id < FCIDM_BROWSERFIRST || id > FCIDM_BROWSERLAST)
1862 DeleteMenu(hFileMenu, i, MF_BYPOSITION);
1863 }
1864
1865 // In case we still have this left over, clean it up
1866 if (m_pFileMenu)
1867 {
1870 }
1871 UINT selcount = m_ListView.GetSelectedCount();
1872 // Store context menu in m_pFileMenu and keep it to invoke the selected command later on
1875 return hr;
1876
1878
1880 hr = m_pFileMenu->QueryContextMenu(hmenu, 0, DVIDM_CONTEXTMENU_FIRST, DVIDM_CONTEXTMENU_LAST, cmf);
1882 return hr;
1883
1884 // TODO: filter or something
1885 if (!selcount)
1886 {
1890 }
1891
1892 Shell_MergeMenus(hFileMenu, hmenu, 0, 0, 0xFFFF, MM_ADDSEPARATOR | MM_SUBMENUSHAVEIDS);
1894 return S_OK;
1895}
1896
1898{
1900 if (!hEditMenu)
1901 return E_FAIL;
1902
1903 HMENU hmenuContents = ::LoadMenuW(shell32_hInstance, L"MENU_003");
1904 if (!hmenuContents)
1905 return E_FAIL;
1906
1907 Shell_MergeMenus(hEditMenu, hmenuContents, 0, 0, 0xFFFF, 0);
1908
1909 ::DestroyMenu(hmenuContents);
1910
1911 return S_OK;
1912}
1913
1915{
1917 if (!hViewMenu)
1918 return E_FAIL;
1919
1921 if (!m_hMenuViewModes)
1922 return E_FAIL;
1923
1926
1927 return S_OK;
1928}
1929
1931{
1932 bool forceMerge = false;
1934
1935 // Make sure the column we currently sort by is in the menu
1938 {
1942 LVCOLUMN lvc;
1943 lvc.mask = LVCF_TEXT;
1944 lvc.pszText = buf;
1945 lvc.cchTextMax = _countof(buf);
1946 currentSortId = DVIDM_ARRANGESORT_LAST;
1947 forceMerge = true;
1949 AppendMenuItem(m_hMenuArrangeModes, MF_STRING, currentSortId, lvc.pszText, m_sortInfo.ListColumn);
1950 }
1951
1952 // Prepend the sort-by items unless they are aleady there
1953 if (GetMenuItemID(hmenuArrange, 0) == FCIDM_SHVIEW_AUTOARRANGE || forceMerge)
1954 {
1955 Shell_MergeMenus(hmenuArrange, m_hMenuArrangeModes, 0, 0, 0xFFFF, MM_ADDSEPARATOR);
1956 }
1957
1958 CheckMenuRadioItem(hmenuArrange,
1960 currentSortId, MF_BYCOMMAND);
1961
1963 {
1966 }
1967 else
1968 {
1971
1972 if (GetAutoArrange() == S_OK)
1974 else
1976
1977 if (_GetSnapToGrid() == S_OK)
1979 else
1981 }
1982
1983 return S_OK;
1984}
1985
1987{
1989 {
1990 UINT iItemFirst = FCIDM_SHVIEW_BIGICON;
1991 UINT iItemLast = iItemFirst + FVM_LAST - FVM_FIRST;
1992 UINT iItem = iItemFirst + m_FolderSettings.ViewMode - FVM_FIRST;
1993 CheckMenuRadioItem(hmenuView, iItemFirst, iItemLast, iItem, MF_BYCOMMAND);
1994 }
1995
1996 return S_OK;
1997}
1998
2000{
2001 const UINT maxItems = 15; // Feels about right
2002 const UINT idMore = 0x1337;
2003 UINT idFirst = idMore + 1, idLast = idFirst;
2004 UINT lastValidListCol = 0; // Keep track of where the new column should be inserted
2005 UINT showMore = GetKeyState(VK_SHIFT) < 0;
2007 HWND hWndHdr = ListView_GetHeader(m_ListView.m_hWnd);
2008
2009 if (lParam == ~0)
2010 {
2011 RECT r;
2012 ::GetWindowRect(hWndHdr, &r);
2013 pt.x = r.left + ((r.right - r.left) / 2);
2014 pt.y = r.top + ((r.bottom - r.top) / 2);
2015 }
2016
2017 HMENU hMenu = CreatePopupMenu();
2018 if (!hMenu)
2019 return 0;
2020
2021 for (UINT foldCol = 0;; ++foldCol)
2022 {
2025 sd.str.uType = !STRRET_WSTR;
2026 if (FAILED(GetDetailsByFolderColumn(NULL, foldCol, sd)))
2027 break;
2028 if (FAILED(StrRetToStrNW(buf, _countof(buf), &sd.str, NULL)))
2029 break;
2030
2031 SHCOLSTATEF state = 0;
2032 if (!m_pSF2Parent || FAILED(m_pSF2Parent->GetDefaultColumnState(foldCol, &state)))
2033 state = 0;
2034 showMore |= (state & (SHCOLSTATE_SECONDARYUI));
2035
2036 UINT mf = MF_STRING;
2037 HRESULT listCol = MapFolderColumnToListColumn(foldCol);
2038
2039 if (foldCol == 0)
2040 mf |= MF_CHECKED | MF_GRAYED | MF_DISABLED; // Force column 0
2042 continue;
2043 else if (SUCCEEDED(listCol))
2044 mf |= MF_CHECKED;
2045
2046 if (AppendMenuItem(hMenu, mf, idLast, buf, lastValidListCol + 1))
2047 {
2048 idLast++;
2049 if (SUCCEEDED(listCol))
2050 lastValidListCol = listCol;
2051 }
2052
2053 if (idLast - idFirst == maxItems)
2054 {
2055 showMore++;
2056 break;
2057 }
2058 }
2059
2060 if (showMore)
2061 {
2062#if 0 // TODO
2063 InsertMenuW(hMenu, -1, MF_SEPARATOR, 0, NULL);
2064 InsertMenuW(hMenu, -1, MF_STRING, idMore, L"More...");
2065#endif
2066 }
2067
2068 // A cludge to force the cursor to update so we are not stuck with "size left/right" if
2069 // the right-click was on a column divider.
2071
2072 // Note: Uses the header as the owner so CDefView::OnInitMenuPopup does not mess us up.
2074 pt.x, pt.y, 0, hWndHdr, NULL);
2075 if (idCmd == idMore)
2076 {
2077 FIXME("Open More dialog\n");
2078 }
2079 else if (idCmd)
2080 {
2081 UINT foldCol = idCmd - idFirst;
2082 HRESULT listCol = MapFolderColumnToListColumn(foldCol);
2083 if (SUCCEEDED(listCol))
2084 {
2085 ListView_DeleteColumn(m_ListView.m_hWnd, listCol);
2086 }
2087 else
2088 {
2089 listCol = (UINT) GetMenuItemDataById(hMenu, idCmd);
2090 LoadColumn(foldCol, listCol, TRUE);
2091 }
2093 }
2094 DestroyMenu(hMenu);
2095 return 0;
2096}
2097
2098/**********************************************************
2099* ShellView_GetSelections()
2100*
2101* - fills the m_apidl list with the selected objects
2102*
2103* RETURNS
2104* number of selected items
2105*/
2107{
2109 if (count > m_cidl || !count || !m_apidl) // !count to free possibly large cache, !m_apidl to make sure m_apidl is a valid pointer
2110 {
2111 SHFree(m_apidl);
2112 m_apidl = static_cast<PCUITEMID_CHILD*>(SHAlloc(count * sizeof(PCUITEMID_CHILD)));
2113 if (!m_apidl)
2114 {
2115 m_cidl = 0;
2116 return 0;
2117 }
2118 }
2119 m_cidl = count;
2120
2121 TRACE("-- Items selected =%u\n", m_cidl);
2122
2124
2125 UINT i = 0;
2126 int lvIndex = -1;
2127 while ((lvIndex = m_ListView.GetNextItem(lvIndex, LVNI_SELECTED)) > -1)
2128 {
2129 m_apidl[i] = _PidlByItem(lvIndex);
2130 i++;
2131 if (i == m_cidl)
2132 break;
2133 TRACE("-- selected Item found\n");
2134 }
2135
2136 return m_cidl;
2137}
2138
2140{
2141 if (!GetSelections())
2142 return 0;
2143 SFGAOF Attr = Query;
2144 return SUCCEEDED(m_pSFParent->GetAttributesOf(m_cidl, m_apidl, &Attr)) ? (Attr & Query) : 0;
2145}
2146
2148{
2149 CMINVOKECOMMANDINFOEX cmi;
2150
2151 ZeroMemory(&cmi, sizeof(cmi));
2152 cmi.cbSize = sizeof(cmi);
2153 cmi.hwnd = m_hWnd;
2154 cmi.lpVerb = lpVerb;
2155 cmi.nShow = SW_SHOW;
2156
2157 WCHAR szverbW[sizeof("properties")];
2158 static const WORD verbmap[] = { FCIDM_SHVIEW_DELETE, FCIDM_SHVIEW_RENAME,
2161 for (SIZE_T i = 0; TryMapVerb && i < _countof(verbmap); ++i)
2162 {
2163 if (cmi.lpVerb != MAKEINTRESOURCEA(verbmap[i]))
2164 continue;
2165 if (PCSTR pszverbA = MapFcidmCmdToVerb((UINT_PTR)cmi.lpVerb))
2166 {
2167 // Map our internal commands to canonical verbs so non-shell32 menus can understand us
2168 SHAnsiToUnicode(pszverbA, szverbW, _countof(szverbW));
2169 cmi.lpVerb = pszverbA;
2170 cmi.lpVerbW = szverbW;
2171 break;
2172 }
2173 }
2174
2175 if (GetKeyState(VK_SHIFT) < 0)
2176 cmi.fMask |= CMIC_MASK_SHIFT_DOWN;
2177
2178 if (GetKeyState(VK_CONTROL) < 0)
2179 cmi.fMask |= CMIC_MASK_CONTROL_DOWN;
2180
2181 if (pt)
2182 {
2183 cmi.fMask |= CMIC_MASK_PTINVOKE;
2184 cmi.ptInvoke = *pt;
2185 }
2186
2187 WCHAR szDirW[MAX_PATH] = L"";
2188 CHAR szDirA[MAX_PATH];
2190 *szDirW != UNICODE_NULL)
2191 {
2192 SHUnicodeToAnsi(szDirW, szDirA, _countof(szDirA));
2193 cmi.fMask |= CMIC_MASK_UNICODE;
2194 cmi.lpDirectory = szDirA;
2195 cmi.lpDirectoryW = szDirW;
2196 }
2197
2198 HRESULT hr = pCM->InvokeCommand((LPCMINVOKECOMMANDINFO)&cmi);
2199 // Most of our callers will do this, but if they would forget (File menu!)
2200 IUnknown_SetSite(pCM, NULL);
2201 pCM.Release();
2202
2204 return hr;
2205
2206 return S_OK;
2207}
2208
2210{
2211 HMENU hMenu;
2212 UINT uCommand;
2213 HRESULT hResult;
2214
2215 if (m_ListView.GetSelectedCount() == 0)
2216 return S_OK;
2217
2218 hResult = OnDefaultCommand();
2219 if (hResult == S_OK)
2220 return hResult;
2221
2222 hMenu = CreatePopupMenu();
2223 if (!hMenu)
2224 return E_FAIL;
2225
2228 MenuCleanup _(pCM, hMenu);
2229 if (FAILED_UNEXPECTEDLY(hResult))
2230 return hResult;
2231
2232 UINT cmf = CMF_DEFAULTONLY | GetContextMenuFlags(m_pShellBrowser, 0);
2233 hResult = pCM->QueryContextMenu(hMenu, 0, DVIDM_CONTEXTMENU_FIRST, DVIDM_CONTEXTMENU_LAST, cmf);
2234 if (FAILED_UNEXPECTEDLY(hResult))
2235 return hResult;
2236
2237 uCommand = GetMenuDefaultItem(hMenu, FALSE, 0);
2238 if (uCommand == (UINT)-1 && !pszVerb)
2239 {
2240 ERR("GetMenuDefaultItem returned -1\n");
2241 return E_FAIL;
2242 }
2243 if (!pszVerb)
2244 pszVerb = MAKEINTRESOURCEA(uCommand);
2245
2246 InvokeContextMenuCommand(pCM, pszVerb, NULL);
2247
2248 return hResult;
2249}
2250
2252{
2254 UINT uCommand;
2255 HRESULT hResult;
2256
2257 TRACE("(%p)\n", this);
2258
2259 if (m_hContextMenu != NULL)
2260 {
2261 ERR("HACK: Aborting context menu in nested call\n");
2262 return 0;
2263 }
2264
2265 HWND hWndHdr = ListView_GetHeader(m_ListView.m_hWnd);
2266 RECT r;
2267 if (::GetWindowRect(hWndHdr, &r) && PtInRect(&r, pt) && ::IsWindowVisible(hWndHdr))
2268 {
2270 }
2271
2273 if (!m_hContextMenu)
2274 return E_FAIL;
2275
2276 if (lParam != ~0) // unless app key (menu key) was pressed
2277 {
2278 LV_HITTESTINFO hittest = { pt };
2279 ScreenToClient(&hittest.pt);
2280 m_ListView.HitTest(&hittest);
2281
2282 // Right-Clicked item is selected? If selected, no selection change.
2283 // If not selected, then reset the selection and select the item.
2284 if ((hittest.flags & LVHT_ONITEM) &&
2286 {
2287 SelectItem(hittest.iItem, SVSI_SELECT | SVSI_DESELECTOTHERS | SVSI_ENSUREVISIBLE);
2288 }
2289 }
2290
2292 // In case we still have this left over, clean it up
2295 if (FAILED_UNEXPECTEDLY(hResult))
2296 return 0;
2297
2299 // Use 1 as the first id we want. 0 means that user canceled the menu
2300 hResult = m_pCM->QueryContextMenu(m_hContextMenu, 0, CONTEXT_MENU_BASE_ID, DVIDM_CONTEXTMENU_LAST, cmf);
2301 if (FAILED_UNEXPECTEDLY(hResult))
2302 return 0;
2303
2304 if (m_pCommDlgBrowser && !(GetCommDlgViewFlags() & CDB2GVF_NOSELECTVERB))
2305 {
2306 HMENU hMenuSource = LoadMenuW(_AtlBaseModule.GetResourceInstance(), MAKEINTRESOURCEW(IDM_DVSELECT));
2308 DestroyMenu(hMenuSource);
2310 // TODO: ICommDlgBrowser2::GetDefaultMenuText == S_OK
2311 }
2312
2313 // There is no position requested, so try to find one
2314 if (lParam == ~0)
2315 {
2316 HWND hFocus = ::GetFocus();
2317 int lvIndex = -1;
2318
2319 if (hFocus == m_ListView.m_hWnd || m_ListView.IsChild(hFocus))
2320 {
2321 // Is there an item focused and selected?
2323 // If not, find the first selected item
2324 if (lvIndex < 0)
2325 lvIndex = m_ListView.GetNextItem(-1, LVNI_SELECTED);
2326 }
2327
2328 // We got something
2329 if (lvIndex > -1)
2330 {
2331 // Find the center of the icon
2332 RECT rc = { LVIR_ICON };
2333 m_ListView.SendMessage(LVM_GETITEMRECT, lvIndex, (LPARAM)&rc);
2334 pt.x = (rc.right + rc.left) / 2;
2335 pt.y = (rc.bottom + rc.top) / 2;
2336 }
2337 else
2338 {
2339 // We have to drop it somewhere
2340 pt.x = pt.y = 0;
2341 }
2342
2343 m_ListView.ClientToScreen(&pt);
2344 }
2345
2348 pcdb2->Notify(static_cast<IShellView*>(this), CDB2N_CONTEXTMENU_START);
2349
2350 // This runs the message loop, calling back to us with f.e. WM_INITPOPUP (hence why m_hContextMenu and m_pCM exist)
2351 uCommand = TrackPopupMenu(m_hContextMenu,
2353 pt.x, pt.y, 0, m_hWnd, NULL);
2354 if (uCommand >= DVIDM_ARRANGESORT_FIRST && uCommand <= DVIDM_ARRANGESORT_LAST)
2355 {
2356 SendMessage(WM_COMMAND, uCommand, 0);
2357 }
2358 else if (uCommand != 0 && !(uCommand == DVIDM_COMMDLG_SELECT && OnDefaultCommand() == S_OK))
2359 {
2361 }
2362
2363 if (pcdb2)
2364 pcdb2->Notify(static_cast<IShellView*>(this), CDB2N_CONTEXTMENU_DONE);
2365 return 0;
2366}
2367
2369{
2370 HRESULT hResult;
2371 HMENU hMenu = NULL;
2372
2374 hResult = GetItemObject(bUseSelection ? SVGIO_SELECTION : SVGIO_BACKGROUND, IID_PPV_ARG(IContextMenu, &pCM));
2375 if (FAILED_UNEXPECTEDLY(hResult))
2376 return 0;
2377
2378 MenuCleanup _(pCM, hMenu);
2379
2380 if ((uCommand != FCIDM_SHVIEW_DELETE) && (uCommand != FCIDM_SHVIEW_RENAME))
2381 {
2382 hMenu = CreatePopupMenu();
2383 if (!hMenu)
2384 return 0;
2385
2386 hResult = pCM->QueryContextMenu(hMenu, 0, DVIDM_CONTEXTMENU_FIRST, DVIDM_CONTEXTMENU_LAST, CMF_NORMAL);
2387 if (FAILED_UNEXPECTEDLY(hResult))
2388 return 0;
2389 }
2390
2391 if (bUseSelection)
2392 {
2393 // FIXME: we should cache this
2394 SFGAOF rfg = SFGAO_BROWSABLE | SFGAO_CANCOPY | SFGAO_CANLINK | SFGAO_CANMOVE | SFGAO_CANDELETE | SFGAO_CANRENAME | SFGAO_HASPROPSHEET | SFGAO_FILESYSTEM | SFGAO_FOLDER;
2395 hResult = m_pSFParent->GetAttributesOf(m_cidl, m_apidl, &rfg);
2396 if (FAILED_UNEXPECTEDLY(hResult))
2397 return 0;
2398
2399 if (!(rfg & SFGAO_CANMOVE) && uCommand == FCIDM_SHVIEW_CUT)
2400 return 0;
2401 if (!(rfg & SFGAO_CANCOPY) && uCommand == FCIDM_SHVIEW_COPY)
2402 return 0;
2403 if (!(rfg & SFGAO_CANDELETE) && uCommand == FCIDM_SHVIEW_DELETE)
2404 return 0;
2405 if (!(rfg & SFGAO_CANRENAME) && uCommand == FCIDM_SHVIEW_RENAME)
2406 return 0;
2407 if (!(rfg & SFGAO_HASPROPSHEET) && uCommand == FCIDM_SHVIEW_PROPERTIES)
2408 return 0;
2409 }
2410
2411 // FIXME: We should probably use the objects position?
2412 InvokeContextMenuCommand(pCM, MAKEINTRESOURCEA(uCommand), NULL, true);
2413 return 0;
2414}
2415
2416// ##### message handling #####
2417
2419{
2420 WORD wWidth, wHeight;
2421
2422 wWidth = LOWORD(lParam);
2423 wHeight = HIWORD(lParam);
2424
2425 TRACE("%p width=%u height=%u\n", this, wWidth, wHeight);
2426
2427 // WM_SIZE can come before WM_CREATE
2428 if (!m_ListView)
2429 return 0;
2430
2431 /* Resize the ListView to fit our window */
2432 ::MoveWindow(m_ListView, 0, 0, wWidth, wHeight, TRUE);
2433
2435
2438
2439 return 0;
2440}
2441
2442// internal
2444{
2445 TRACE("%p\n", this);
2446
2448 {
2449 // TODO: cleanup menu after deactivation
2451 }
2452}
2453
2455{
2456 TRACE("%p uState=%x\n", this, uState);
2457
2458 // don't do anything if the state isn't really changing
2459 if (m_uState == uState)
2460 {
2461 return;
2462 }
2463
2464 if (uState == SVUIA_DEACTIVATE)
2465 {
2466 OnDeactivate();
2467 }
2468 else
2469 {
2471 {
2472 FillEditMenu();
2473 FillViewMenu();
2474 m_pShellBrowser->SetMenuSB(m_hMenu, 0, m_hWnd);
2476 }
2477
2478 if (SVUIA_ACTIVATE_FOCUS == uState)
2479 {
2480 m_ListView.SetFocus();
2481 }
2482 }
2483
2484 m_uState = uState;
2485 TRACE("--\n");
2486}
2487
2489{
2490 if (!GetSelections())
2491 return;
2492
2493 SFGAOF rfg = SFGAO_CANCOPY | SFGAO_CANMOVE | SFGAO_FILESYSTEM;
2494 HRESULT hr = m_pSFParent->GetAttributesOf(m_cidl, m_apidl, &rfg);
2496 return;
2497
2498 if (!bCopy && !(rfg & SFGAO_CANMOVE))
2499 return;
2500 if (bCopy && !(rfg & SFGAO_CANCOPY))
2501 return;
2502
2504 hr = m_pSFParent->GetUIObjectOf(m_hWnd, m_cidl, m_apidl, IID_IContextMenu, 0, (void **)&pCM);
2506 return;
2507
2508 InvokeContextMenuCommand(pCM, (bCopy ? "copyto" : "moveto"), NULL);
2509}
2510
2512{
2514 return 0;
2515}
2516
2518{
2519 TRACE("%p\n", this);
2520
2521 /* Tell the browser one of our windows has received the focus. This
2522 should always be done before merging menus (OnActivate merges the
2523 menus) if one of our windows has the focus.*/
2524
2525 m_pShellBrowser->OnViewWindowActive(this);
2527
2528 /* Set the focus to the listview */
2529 m_ListView.SetFocus();
2530
2531 /* Notify the ICommDlgBrowser interface */
2532 OnStateChange(CDBOSC_SETFOCUS);
2533
2534 return 0;
2535}
2536
2538{
2539 TRACE("(%p) stub\n", this);
2540
2542 /* Notify the ICommDlgBrowser */
2543 OnStateChange(CDBOSC_KILLFOCUS);
2544
2545 return 0;
2546}
2547
2548// the CmdID's are the ones from the context menu
2550{
2551 DWORD dwCmdID;
2552 DWORD dwCmd;
2553 HWND hwndCmd;
2554 int nCount;
2555
2556 dwCmdID = GET_WM_COMMAND_ID(wParam, lParam);
2558 hwndCmd = GET_WM_COMMAND_HWND(wParam, lParam);
2559
2560 TRACE("(%p)->(0x%08x 0x%08x %p) stub\n", this, dwCmdID, dwCmd, hwndCmd);
2561
2562 if (dwCmdID >= DVIDM_ARRANGESORT_FIRST && dwCmdID <= DVIDM_ARRANGESORT_LAST)
2563 {
2564 UINT listCol = (UINT)GetMenuItemDataById(m_hMenuArrangeModes, dwCmdID);
2565 _Sort(listCol);
2566 return 0;
2567 }
2568
2569 switch (dwCmdID)
2570 {
2575 case 0x702D:
2577 case 0x702F:
2579 break;
2582 break;
2584 if (_GetSnapToGrid() == S_OK)
2586 else
2587 ArrangeGrid();
2588 break;
2590 if (GetAutoArrange() == S_OK)
2591 m_ListView.ModifyStyle(LVS_AUTOARRANGE, 0);
2592 else
2593 AutoArrange();
2594 break;
2598 break;
2600 nCount = m_ListView.GetItemCount();
2601 for (int i=0; i < nCount; i++)
2603 break;
2606 break;
2608 Refresh();
2609 break;
2611 case FCIDM_SHVIEW_CUT:
2612 case FCIDM_SHVIEW_COPY:
2616 return 0;
2617 return OnExplorerCommand(dwCmdID, TRUE);
2621 return 0;
2623 case FCIDM_SHVIEW_UNDO:
2626 return OnExplorerCommand(dwCmdID, FALSE);
2627 default:
2628 // WM_COMMAND messages from file menu are routed to CDefView to let m_pFileMenu handle them
2629 if (m_pFileMenu && dwCmd == 0)
2630 {
2631 HMENU Dummy = NULL;
2632 MenuCleanup _(m_pFileMenu, Dummy);
2634 }
2635 }
2636
2637 return 0;
2638}
2639
2640static BOOL
2642{
2643 HKEY hKey;
2644 LONG error;
2645 DWORD dwValue = FALSE, cbValue;
2646
2648 if (error)
2649 return dwValue;
2650
2651 cbValue = sizeof(dwValue);
2652 RegQueryValueExW(hKey, L"SelectExtOnRename", NULL, NULL, (LPBYTE)&dwValue, &cbValue);
2653
2655 return !!dwValue;
2656}
2657
2659{
2660 UINT CtlID;
2661 LPNMHDR lpnmh;
2662 LPNMLISTVIEW lpnmlv;
2663 NMLVDISPINFOW *lpdi;
2664 PCUITEMID_CHILD pidl;
2665 BOOL unused;
2666
2667 CtlID = wParam;
2668 lpnmh = (LPNMHDR)lParam;
2669 lpnmlv = (LPNMLISTVIEW)lpnmh;
2670 lpdi = (NMLVDISPINFOW *)lpnmh;
2671
2672 TRACE("%p CtlID=%u lpnmh->code=%x\n", this, CtlID, lpnmh->code);
2673
2674 switch (lpnmh->code)
2675 {
2676 case NM_SETFOCUS:
2677 TRACE("-- NM_SETFOCUS %p\n", this);
2678 OnSetFocus(0, 0, 0, unused);
2679 break;
2680 case NM_KILLFOCUS:
2681 TRACE("-- NM_KILLFOCUS %p\n", this);
2682 OnDeactivate();
2683 /* Notify the ICommDlgBrowser interface */
2684 OnStateChange(CDBOSC_KILLFOCUS);
2685 break;
2686 case NM_CUSTOMDRAW:
2687 TRACE("-- NM_CUSTOMDRAW %p\n", this);
2688 return CDRF_DODEFAULT;
2689 case NM_RELEASEDCAPTURE:
2690 TRACE("-- NM_RELEASEDCAPTURE %p\n", this);
2691 break;
2692 case NM_CLICK:
2693 TRACE("-- NM_CLICK %p\n", this);
2694 break;
2695 case NM_RCLICK:
2696 TRACE("-- NM_RCLICK %p\n", this);
2697 break;
2698 case NM_DBLCLK:
2699 TRACE("-- NM_DBLCLK %p\n", this);
2700 break;
2701 case NM_RETURN:
2702 TRACE("-- NM_RETURN %p\n", this);
2703 break;
2704 case HDN_ENDTRACKW:
2705 TRACE("-- HDN_ENDTRACKW %p\n", this);
2706 //nColumn1 = m_ListView.GetColumnWidth(0);
2707 //nColumn2 = m_ListView.GetColumnWidth(1);
2708 break;
2709 case LVN_DELETEITEM:
2710 TRACE("-- LVN_DELETEITEM %p\n", this);
2711 /*delete the pidl because we made a copy of it*/
2712 SHFree(reinterpret_cast<LPVOID>(lpnmlv->lParam));
2713 break;
2714 case LVN_DELETEALLITEMS:
2715 TRACE("-- LVN_DELETEALLITEMS %p\n", this);
2716 return FALSE;
2717 case LVN_INSERTITEM:
2718 TRACE("-- LVN_INSERTITEM (STUB)%p\n", this);
2719 break;
2720 case LVN_ITEMACTIVATE:
2721 TRACE("-- LVN_ITEMACTIVATE %p\n", this);
2722 OpenSelectedItems(((NMITEMACTIVATE *)lpnmh)->uKeyFlags & LVKF_ALT ? "properties" : NULL);
2723 break;
2724 case LVN_COLUMNCLICK:
2725 {
2726 UINT foldercol = MapListColumnToFolderColumn(lpnmlv->iSubItem);
2727 HRESULT hr = S_FALSE;
2728 if (m_pSDParent)
2729 hr = m_pSDParent->ColumnClick(foldercol);
2730 if (hr != S_OK)
2731 hr = _DoFolderViewCB(SFVM_COLUMNCLICK, foldercol, 0);
2732 if (hr != S_OK)
2733 _Sort(lpnmlv->iSubItem);
2734 break;
2735 }
2736 case LVN_GETDISPINFOA:
2737 case LVN_GETDISPINFOW:
2738 TRACE("-- LVN_GETDISPINFO %p\n", this);
2739 pidl = _PidlByItem(lpdi->item);
2740
2741 if (lpdi->item.mask & LVIF_TEXT) /* text requested */
2742 {
2745 break;
2746
2747 if (lpnmh->code == LVN_GETDISPINFOA)
2748 {
2749 /* shouldn't happen */
2750 NMLVDISPINFOA *lpdiA = (NMLVDISPINFOA *)lpnmh;
2751 StrRetToStrNA( lpdiA->item.pszText, lpdiA->item.cchTextMax, &sd.str, NULL);
2752 TRACE("-- text=%s\n", lpdiA->item.pszText);
2753 }
2754 else /* LVN_GETDISPINFOW */
2755 {
2756 StrRetToStrNW( lpdi->item.pszText, lpdi->item.cchTextMax, &sd.str, NULL);
2757 TRACE("-- text=%s\n", debugstr_w(lpdi->item.pszText));
2758 }
2759 }
2760 if (lpdi->item.mask & LVIF_IMAGE)
2761 {
2763 }
2764 if (lpdi->item.mask & LVIF_STATE)
2765 {
2766 if ((lpdi->item.stateMask & LVIS_CUT) && GetItemAttributes(pidl, SFGAO_HIDDEN | SFGAO_GHOSTED))
2767 lpdi->item.state |= LVIS_CUT;
2768 }
2769 lpdi->item.mask |= LVIF_DI_SETITEM;
2770 break;
2771 case LVN_ITEMCHANGED:
2772 TRACE("-- LVN_ITEMCHANGED %p\n", this);
2773 if ((lpnmlv->uOldState ^ lpnmlv->uNewState) & (LVIS_SELECTED | LVIS_FOCUSED))
2774 {
2775 OnStateChange(CDBOSC_SELCHANGE); // browser will get the IDataObject
2776 // FIXME: Use LVIS_DROPHILITED instead in drag_notify_subitem
2778 {
2781 }
2782 _DoFolderViewCB(SFVM_SELECTIONCHANGED, NULL/* FIXME */, NULL/* FIXME */);
2783 }
2784 break;
2785 case LVN_BEGINDRAG:
2786 case LVN_BEGINRDRAG:
2787 TRACE("-- LVN_BEGINDRAG\n");
2788 if (GetSelections())
2789 {
2791 DWORD dwAttributes = SFGAO_CANCOPY | SFGAO_CANLINK;
2792 DWORD dwEffect = DROPEFFECT_MOVE;
2793
2794 if (SUCCEEDED(m_pSFParent->GetUIObjectOf(m_hWnd, m_cidl, m_apidl, IID_NULL_PPV_ARG(IDataObject, &pda))))
2795 {
2797
2798 if (SUCCEEDED(m_pSFParent->GetAttributesOf(m_cidl, m_apidl, &dwAttributes)))
2799 dwEffect |= dwAttributes & (SFGAO_CANCOPY | SFGAO_CANLINK);
2800
2802 if (SUCCEEDED(pda->QueryInterface(IID_PPV_ARG(IAsyncOperation, &piaso))))
2803 piaso->SetAsyncMode(TRUE);
2804
2805 DWORD dwEffect2;
2806
2807 m_pSourceDataObject = pda;
2808 m_ptFirstMousePos = params->ptAction;
2811
2812 HIMAGELIST big_icons, small_icons;
2813 Shell_GetImageLists(&big_icons, &small_icons);
2814 PCUITEMID_CHILD pidl = _PidlByItem(params->iItem);
2815 int iIcon = SHMapPIDLToSystemImageListIndex(m_pSFParent, pidl, 0);
2816 POINT ptItem;
2817 m_ListView.GetItemPosition(params->iItem, &ptItem);
2818
2819 ImageList_BeginDrag(big_icons, iIcon, params->ptAction.x - ptItem.x, params->ptAction.y - ptItem.y);
2820 DoDragDrop(pda, this, dwEffect, &dwEffect2);
2822 }
2823 }
2824 break;
2826 {
2827 TRACE("-- LVN_BEGINLABELEDITW %p\n", this);
2829 pidl = _PidlByItem(lpdi->item);
2830 DWORD fAttr = pidl ? GetItemAttributes(pidl, SFGAO_CANRENAME | SFGAO_FOLDER | SFGAO_FILESYSTEM) : 0;
2831 if (!hEdit || !(fAttr & SFGAO_CANRENAME))
2832 {
2833 MessageBeep(0xffffffff);
2834 return TRUE;
2835 }
2836
2837 WCHAR szName[MAX_PATH], *pszText = lpdi->item.pszText;
2838 if (SUCCEEDED(DisplayNameOfW(m_pSFParent, pidl, SHGDN_FOREDITING | SHGDN_INFOLDER,
2840 {
2841 pszText = szName;
2842 ::SetWindowText(hEdit, pszText);
2843 }
2844
2845 // smartass-renaming: See CORE-15242
2846 if (!(fAttr & SFGAO_FOLDER) && (fAttr & SFGAO_FILESYSTEM) &&
2847 (lpdi->item.mask & LVIF_TEXT) && !SelectExtOnRename())
2848 {
2850 WCHAR szFullPath[MAX_PATH];
2851 if (SHGetPathFromIDListW(pidlFull, szFullPath) && !SHELL_FS_HideExtension(szFullPath))
2852 {
2853 LPWSTR pchDotExt = PathFindExtensionW(pszText);
2854 ::PostMessageW(hEdit, EM_SETSEL, 0, pchDotExt - pszText);
2856 }
2857 }
2858
2859 INT cchLimit = 0;
2860 _DoFolderViewCB(SFVM_GETNAMELENGTH, (WPARAM)pidl, (LPARAM)&cchLimit);
2861 if (cchLimit)
2862 ::SendMessageW(hEdit, EM_SETLIMITTEXT, cchLimit, 0);
2864 m_isEditing = TRUE;
2865 return FALSE;
2866 }
2867 case LVN_ENDLABELEDITW:
2868 {
2869 TRACE("-- LVN_ENDLABELEDITW %p\n", this);
2871 if (!lpdi->item.pszText)
2872 return TRUE;
2873
2874 pidl = _PidlByItem(lpdi->item);
2875 // We have to copy the old PIDL because SetNameOf might generate a SHCNE_UPDATEITEM
2876 // and that notification can cause us to call LV_UpdateItem and free the old PIDL too soon.
2878 if (!pidlOld)
2879 {
2881 return FALSE;
2882 }
2883 PITEMID_CHILD pidlNew = NULL;
2884 HRESULT hr = m_pSFParent->SetNameOf(0, pidlOld, lpdi->item.pszText, SHGDN_INFOLDER, &pidlNew);
2885 if (SUCCEEDED(hr) && pidlNew)
2886 {
2887 int iNew = LV_FindItemByPidl(pidlNew);
2888 if (iNew != lpdi->item.iItem && iNew >= 0)
2889 ILFree(pidlNew);// A SHCNE has updated the item already
2890 else if (!LV_UpdateItem(lpdi->item.iItem, pidlNew))
2891 ILFree(pidlNew);
2892 OnStateChange(CDBOSC_RENAME);
2893 }
2894 else
2895 {
2896 ::PostMessageW(m_ListView, LVM_EDITLABEL, lpdi->item.iItem, 0); // Renaming failed, let the user try again
2897 }
2898 return FALSE;
2899 }
2900 default:
2901 TRACE("-- %p WM_COMMAND %x unhandled\n", this, lpnmh->code);
2902 break;
2903 }
2904
2905 return 0;
2906}
2907
2908// This is just a quick hack to make the desktop work correctly.
2909// ITranslateShellChangeNotify's IsChildID is undocumented, but most likely the
2910// way that a folder should know if it should update upon a change notification.
2911// It is exported by merged folders at a minimum.
2913{
2914 if (!pidl1 || !pidl2)
2915 return FALSE;
2916 if (ILIsParent(pidl1, pidl2, TRUE))
2917 return TRUE;
2918
2919 CComHeapPtr<ITEMIDLIST_ABSOLUTE> pidl2Clone(ILClone(pidl2));
2920 ILRemoveLastID(pidl2Clone);
2921 return ILIsEqual(pidl1, pidl2Clone);
2922}
2923
2925{
2926 // The change notify can come before WM_CREATE
2927 if (!m_ListView)
2928 return FALSE;
2929
2930 HANDLE hChange = (HANDLE)wParam;
2931 DWORD dwProcID = (DWORD)lParam;
2932 PIDLIST_ABSOLUTE *Pidls;
2933 LONG lEvent;
2934 HANDLE hLock = SHChangeNotification_Lock(hChange, dwProcID, &Pidls, &lEvent);
2935 if (hLock == NULL)
2936 {
2937 ERR("hLock == NULL\n");
2938 return FALSE;
2939 }
2940 lEvent &= ~SHCNE_INTERRUPT;
2941 TRACE("(%p)(%p,%p,%p) %#x\n", this, Pidls[0], Pidls[1], lParam, lEvent);
2942
2944 {
2946 return FALSE;
2947 }
2948
2949 // Translate child IDLs.
2950 // SHSimpleIDListFromPathW creates fake PIDLs (lacking some attributes)
2951 HRESULT hr;
2952 PITEMID_CHILD child0 = NULL, child1 = NULL;
2953 CComHeapPtr<ITEMIDLIST_RELATIVE> pidl0Temp, pidl1Temp;
2955 {
2956 if (_ILIsSpecialFolder(Pidls[0]) || ILIsParentOrSpecialParent(m_pidlParent, Pidls[0]))
2957 {
2958 child0 = ILFindLastID(Pidls[0]);
2959 hr = SHGetRealIDL(m_pSFParent, child0, &pidl0Temp);
2960 if (SUCCEEDED(hr))
2961 child0 = pidl0Temp;
2962 }
2963 if (_ILIsSpecialFolder(Pidls[1]) || ILIsParentOrSpecialParent(m_pidlParent, Pidls[1]))
2964 {
2965 child1 = ILFindLastID(Pidls[1]);
2966 hr = SHGetRealIDL(m_pSFParent, child1, &pidl1Temp);
2967 if (SUCCEEDED(hr))
2968 child1 = pidl1Temp;
2969 }
2970 }
2971
2972 switch (lEvent)
2973 {
2974 case SHCNE_MKDIR:
2975 case SHCNE_CREATE:
2976 case SHCNE_DRIVEADD:
2977 if (!child0)
2978 break;
2979 if (LV_FindItemByPidl(child0) < 0)
2980 LV_AddItem(child0);
2981 else
2982 LV_UpdateItem(child0);
2983 break;
2984 case SHCNE_RMDIR:
2985 case SHCNE_DELETE:
2986 case SHCNE_DRIVEREMOVED:
2987 if (child0)
2988 LV_DeleteItem(child0);
2989 break;
2990 case SHCNE_RENAMEFOLDER:
2991 case SHCNE_RENAMEITEM:
2992 if (child0 && child1)
2993 LV_RenameItem(child0, child1);
2994 else if (child0)
2995 LV_DeleteItem(child0);
2996 else if (child1)
2997 LV_AddItem(child1);
2998 break;
2999 case SHCNE_UPDATEITEM:
3000 if (child0)
3001 LV_UpdateItem(child0);
3002 break;
3003 case SHCNE_UPDATEIMAGE:
3005 case SHCNE_MEDIAREMOVED:
3006 case SHCNE_ASSOCCHANGED:
3008 break;
3009 case SHCNE_UPDATEDIR:
3010 case SHCNE_ATTRIBUTES:
3011 if (child0)
3012 LV_UpdateItem(child0);
3013 else
3014 Refresh();
3016 break;
3017 case SHCNE_FREESPACE:
3019 break;
3020 }
3021
3023 return TRUE;
3024}
3025
3027{
3028 if (!m_pCM)
3029 {
3030 /* no menu */
3031 ERR("no context menu\n");
3032 return FALSE;
3033 }
3034 LRESULT result = 0;
3036 return SUCCEEDED(hres);
3037}
3038
3040{
3041 /* Wallpaper setting affects drop shadows effect */
3042 if (wParam == SPI_SETDESKWALLPAPER || wParam == 0)
3044
3046 UINT ListExBits = GetItemActivateFlags();
3048 (lParam && !lstrcmpiW((PWSTR)lParam, REGSTR_PATH_EXPLORER L"\\IconUnderline")))
3049 {
3051 ListExBits |= SHELL_GetIconUnderlineFlags();
3052 }
3053 m_ListView.SetExtendedListViewStyle(ListExBits, ListExMask);
3054 m_ListView.SendMessage(uMsg, wParam, lParam);
3055 return S_OK;
3056}
3057
3059{
3060 HMENU hmenu = (HMENU) wParam;
3061 int nPos = LOWORD(lParam);
3062 UINT menuItemId;
3063
3064 if (m_isEditing)
3066 if (m_pCM)
3067 OnMenuMessage(uMsg, wParam, lParam, bHandled);
3068
3070
3071 if (GetSelections() == 0)
3072 {
3079 }
3080 else
3081 {
3082 // FIXME: Check copyable
3089 }
3090
3091 /* Lets try to find out what the hell wParam is */
3092 if (hmenu == GetSubMenu(m_hMenu, nPos))
3093 menuItemId = ReallyGetMenuItemID(m_hMenu, nPos);
3094 else if (hViewMenu && hmenu == GetSubMenu(hViewMenu, nPos))
3095 menuItemId = ReallyGetMenuItemID(hViewMenu, nPos);
3096 else if (m_hContextMenu && hmenu == GetSubMenu(m_hContextMenu, nPos))
3097 menuItemId = ReallyGetMenuItemID(m_hContextMenu, nPos);
3098 else
3099 return FALSE;
3100
3101 switch (menuItemId)
3102 {
3103 case FCIDM_MENU_FILE:
3104 FillFileMenu();
3105 break;
3106 case FCIDM_MENU_VIEW:
3107 case FCIDM_SHVIEW_VIEW:
3109 break;
3112 break;
3113 }
3114
3115 return FALSE;
3116}
3117
3119{
3120 bHandled = TRUE;
3121 return m_ClipboardChain.HandleChangeCBChain(wParam, lParam);
3122}
3123
3125{
3126 bHandled = TRUE;
3127 const LRESULT res = m_ClipboardChain.HandleDrawClipboard(wParam, lParam);
3128 if (m_HasCutItems)
3129 {
3130 m_ClipboardChain.Unhook(m_hWnd);
3131 m_HasCutItems = false;
3132 m_ListView.SetItemState(-1, 0, LVIS_CUT); // Somebody copied or pasted, nothing can be "cut" anymore
3133 m_ListView.SendMessageW(LVM_SETCALLBACKMASK, m_ListView.SendMessageW(LVM_GETCALLBACKMASK, 0, 0) | LVIS_CUT, 0);
3134 }
3135 return res;
3136}
3137
3139{
3140 for (UINT i = 0, c = m_ListView.GetItemCount(); i < c; ++i)
3141 m_ListView.SetItemState(i, GetItemAttributes(i, SFGAO_HIDDEN | SFGAO_GHOSTED) ? LVIS_CUT : 0, LVIS_CUT);
3142}
3143
3144// The INTERFACE of the IShellView object
3145
3147{
3148 TRACE("(%p)\n", this);
3149
3150 *phWnd = m_hWnd;
3151
3152 return S_OK;
3153}
3154
3156{
3157 FIXME("(%p) stub\n", this);
3158
3159 return E_NOTIMPL;
3160}
3161
3162// FIXME: use the accel functions
3164{
3165 if (m_isEditing)
3166 return S_FALSE;
3167
3168 if (lpmsg->message >= WM_KEYFIRST && lpmsg->message <= WM_KEYLAST)
3169 {
3170 if (::TranslateAcceleratorW(m_hWnd, m_hAccel, lpmsg) != 0)
3171 return S_OK;
3172
3173 TRACE("-- key=0x%04lx\n", lpmsg->wParam);
3174 }
3175
3176 return m_pShellBrowser ? m_pShellBrowser->TranslateAcceleratorSB(lpmsg, 0) : S_FALSE;
3177}
3178
3180{
3181 FIXME("(%p)\n", this);
3182 return E_NOTIMPL;
3183}
3184
3186{
3187 TRACE("(%p)->(state=%x)\n", this, uState);
3188
3189 // don't do anything if the state isn't changing
3190 if (m_uState == uState)
3191 return S_OK;
3192
3193 // OnActivate handles the menu merging and internal state
3194 DoActivate(uState);
3195
3196 // only do this if we are active
3197 if (uState != SVUIA_DEACTIVATE)
3198 {
3200
3201 // Set the text for the status bar
3203 }
3204
3205 return S_OK;
3206}
3207
3209{
3210 TRACE("(%p)\n", this);
3211
3213
3215 FillList();
3216
3217 return S_OK;
3218}
3219
3221{
3222 return CreateViewWindow3(psb, lpPrevView, SV3CVW3_DEFAULT,
3223 (FOLDERFLAGS)lpfs->fFlags, (FOLDERFLAGS)lpfs->fFlags, (FOLDERVIEWMODE)lpfs->ViewMode, NULL, prcView, phWnd);
3224}
3225
3227{
3228 TRACE("(%p)\n", this);
3229
3230 /* Make absolutely sure all our UI is cleaned up */
3232
3233 if (m_hAccel)
3234 {
3235 // MSDN: Accelerator tables loaded from resources are freed automatically when application terminates
3236 m_hAccel = NULL;
3237 }
3238
3240 {
3243 }
3244
3245 if (m_hMenuViewModes)
3246 {
3249 }
3250
3251 if (m_hMenu)
3252 {
3254 m_hMenu = NULL;
3255 }
3256
3257 if (m_ListView)
3258 {
3259 m_ListView.DestroyWindow();
3260 }
3261
3262 if (m_hWnd)
3263 {
3265 DestroyWindow();
3266 }
3267
3270
3271 return S_OK;
3272}
3273
3275{
3276 TRACE("(%p)->(%p) vmode=%x flags=%x\n", this, lpfs,
3278
3279 if (!lpfs)
3280 return E_INVALIDARG;
3281
3282 *lpfs = m_FolderSettings;
3283 return S_OK;
3284}
3285
3287{
3288 TRACE("(%p)->(0x%lX, %p, %p)\n", this, dwReserved, lpfn, lparam);
3289
3292 return S_OK;
3293}
3294
3296{
3297 ULONG read;
3298 HRESULT hr = pS->Read(buffer, cb, &read);
3299 return FAILED(hr) ? hr : (cb == read ? S_OK : HResultFromWin32(ERROR_MORE_DATA));
3300}
3301
3303{
3304 DWORD value;
3306 return SUCCEEDED(hr) ? value : def;
3307}
3308
3310{
3311 CLSID clsid;
3313 if (SUCCEEDED(hr))
3314 {
3315 WCHAR path[MAX_PATH], name[39];
3316 wsprintfW(path, L"%s\\%s", REGSTR_PATH_EXPLORER, L"Streams\\Default");
3318 *ppStream = SHOpenRegStream2W(HKEY_CURRENT_USER, path, name, Stgm);
3319 hr = *ppStream ? S_OK : E_FAIL;
3320 }
3321 return hr;
3322}
3323
3325{
3327 if (FAILED(hr))
3328 return hr;
3329 if (cols.Signature != PERSISTCOLUMNS::SIG || cols.Count > cols.MAXCOUNT)
3331 return Read(pS, &cols.Columns, sizeof(*cols.Columns) * cols.Count);
3332}
3333
3335{
3337 PERSISTCOLUMNS cols;
3340 bool fallback = false;
3341 HRESULT hrColumns = E_FAIL;
3343 if (SUCCEEDED(hr))
3344 {
3345 DWORD data;
3346 if (FAILED(hr = SHPropertyBag_ReadDWORD(pPB, L"Mode", &data)))
3347 goto loadfallback;
3349 cvs.FolderSettings.fFlags = ReadDWORD(pPB, L"FFlags", FWF_NOGROUPING);
3350 data = ReadDWORD(pPB, L"Sort", ~0ul);
3352 cvs.SortDir = (INT8)ReadDWORD(pPB, L"SortDir", 1);
3353 if (SUCCEEDED(hrColumns = SHPropertyBag_ReadStream(pPB, L"ColInfo", &pS)))
3354 hrColumns = LoadColumnsStream(cols, pS);
3355 }
3356 else
3357 {
3358 if (FAILED(hr = (m_pShellBrowser ? m_pShellBrowser->GetViewStateStream(STGM_READ, &pS) : E_UNEXPECTED)))
3359 {
3360 loadfallback:
3362 fallback = true;
3363 }
3364 if (FAILED(hr) || FAILED(hr = Read(pS, &cvs, sizeof(cvs))))
3365 return hr;
3366 if (cvs.Signature != cvs.SIG)
3368 hrColumns = LoadColumnsStream(cols, pS);
3369 }
3371 m_FolderSettings.fFlags &= ~cvs.VALIDFWF;
3373 if (SUCCEEDED(hrColumns))
3374 {
3375 BOOL failed = FALSE;
3376 if ((m_LoadColumnsList = DPA_Create(cols.Count)) != NULL)
3377 {
3378 for (UINT i = 0; i < cols.Count; ++i)
3379 {
3380 failed |= !DPA_SetPtr(m_LoadColumnsList, i, UlongToPtr(cols.Columns[i]));
3381 }
3382 }
3383 if (failed || !cols.Count)
3384 {
3387 }
3388 }
3391 m_sortInfo.Direction = cvs.SortDir > 0 ? 1 : -1;
3393 return hr;
3394}
3395
3397{
3398 if (!m_ListView.m_hWnd)
3399 return E_UNEXPECTED;
3402 cvs.SortColId = sortcol >= 0 ? (WORD)sortcol : 0;
3404 PERSISTCOLUMNS cols;
3406 cols.Count = 0;
3407 LVCOLUMN lvc;
3408 lvc.mask = LVCF_WIDTH;
3409 for (UINT i = 0, j = 0; i < PERSISTCOLUMNS::MAXCOUNT && ListView_GetColumn(m_ListView, j, &lvc); ++j)
3410 {
3412 if (SUCCEEDED(hr))
3413 {
3414 cols.Columns[i] = MAKELONG(hr, lvc.cx);
3415 cols.Count = ++i;
3416 }
3417 }
3418 UINT cbColumns = FIELD_OFFSET(PERSISTCOLUMNS, Columns) + (sizeof(*cols.Columns) * cols.Count);
3420
3421 IPropertyBag *pPB;
3422 HRESULT hr = S_OK;
3423 if (pStream)
3424 {
3425 pStream->AddRef();
3426 goto stream;
3427 }
3429 if (SUCCEEDED(hr))
3430 {
3431 UINT uViewMode;
3432 GetCurrentViewMode(&uViewMode);
3433 hr = SHPropertyBag_WriteDWORD(pPB, L"Mode", uViewMode);
3435 SHPropertyBag_WriteDWORD(pPB, L"Sort", cvs.SortColId);
3436 SHPropertyBag_WriteDWORD(pPB, L"SortDir", cvs.SortDir);
3437 pStream = cols.Count ? SHCreateMemStream((LPBYTE)&cols, cbColumns) : NULL;
3438 if (!pStream || FAILED(SHPropertyBag_WriteStream(pPB, L"ColInfo", pStream)))
3439 SHPropertyBag_Delete(pPB, L"ColInfo");
3440#if 0 // TODO
3442 memcpy(name, L"ItemPos", sizeof(L"ItemPos"));
3443 if (SHGetPerScreenResName(name + 7, _countof(name) - 7, 0))
3444 {
3445 if (GetAutoArrange() == S_FALSE)
3446 // TODO: Save listview item positions
3447 else
3449 }
3450#endif
3451 pPB->Release();
3452 }
3453 else if (SUCCEEDED(hr = (m_pShellBrowser ? m_pShellBrowser->GetViewStateStream(STGM_WRITE, &pStream) : E_UNEXPECTED)))
3454 {
3455 stream:
3456 ULONG written;
3457 cvs.Signature = cvs.SIG;
3459 hr = pStream->Write(&cvs, sizeof(cvs), &written);
3460 if (SUCCEEDED(hr))
3461 hr = pStream->Write(&cols, cbColumns, &written);
3462 }
3463 // TODO: else if (SUCCEEDED(_DoFolderViewCB(SFVM_GETCOLUMNSTREAM)))
3464 if (pStream)
3465 pStream->Release();
3466 return hr;
3467}
3468
3470{
3472 return SaveViewState(NULL);
3473 return S_FALSE;
3474}
3475
3476#define UPDATEFOLDERVIEWFLAGS(bits, bit, set) ( (bits) = ((bits) & ~(bit)) | ((set) ? (bit) : 0) )
3478{
3482}
3483
3485{
3486 SHELLSTATE ss;
3488 return ((m_FolderSettings.fFlags & FWF_SINGLECLICKACTIVATE) || (!ss.fDoubleClickInWebView && !ss.fWin95Classic))
3490}
3491
3493{
3494 int i;
3495
3496 TRACE("(%p)->(pidl=%p, 0x%08x) stub\n", this, pidl, uFlags);
3497
3498 if (!m_ListView)
3499 {
3500 ERR("!m_ListView\n");
3501 return E_FAIL;
3502 }
3503
3504 i = LV_FindItemByPidl(pidl);
3505 if (i == -1)
3506 return S_OK;
3507
3508 LVITEMW lvItem = {0};
3509 lvItem.mask = LVIF_STATE;
3511
3512 while (m_ListView.GetItem(&lvItem))
3513 {
3514 if (lvItem.iItem == i)
3515 {
3516 if (uFlags & SVSI_SELECT)
3517 lvItem.state |= LVIS_SELECTED;
3518 else
3519 lvItem.state &= ~LVIS_SELECTED;
3520
3521 if (uFlags & SVSI_FOCUSED)
3522 lvItem.state |= LVIS_FOCUSED;
3523 else
3524 lvItem.state &= ~LVIS_FOCUSED;
3525 }
3526 else
3527 {
3528 if (uFlags & SVSI_DESELECTOTHERS)
3529 {
3530 lvItem.state &= ~LVIS_SELECTED;
3531 }
3532 lvItem.state &= ~LVIS_FOCUSED;
3533 }
3534
3535 m_ListView.SetItem(&lvItem);
3536 lvItem.iItem++;
3537 }
3538
3539 if (uFlags & SVSI_ENSUREVISIBLE)
3541
3542 if((uFlags & SVSI_EDIT) == SVSI_EDIT)
3544
3545 return S_OK;
3546}
3547
3549{
3551
3552 TRACE("(%p)->(uItem=0x%08x,\n\tIID=%s, ppv=%p)\n", this, uItem, debugstr_guid(&riid), ppvOut);
3553
3554 if (!ppvOut)
3555 return E_INVALIDARG;
3556
3557 *ppvOut = NULL;
3558
3559 switch (uItem)
3560 {
3561 case SVGIO_BACKGROUND:
3562 if (IsEqualIID(riid, IID_IContextMenu))
3563 {
3566 return hr;
3567
3568 IUnknown_SetSite(*((IUnknown**)ppvOut), (IShellView *)this);
3569 }
3570 else if (IsEqualIID(riid, IID_IDispatch))
3571 {
3573 {
3576 return hr;
3577 }
3578 hr = m_pShellFolderViewDual->QueryInterface(riid, ppvOut);
3579 }
3580 break;
3581 case SVGIO_SELECTION:
3582 GetSelections();
3583 hr = m_pSFParent->GetUIObjectOf(m_hWnd, m_cidl, m_apidl, riid, 0, ppvOut);
3585 return hr;
3586
3587 if (IsEqualIID(riid, IID_IContextMenu))
3588 IUnknown_SetSite(*((IUnknown**)ppvOut), (IShellView *)this);
3589
3590 break;
3591 }
3592
3593 TRACE("-- (%p)->(interface=%p)\n", this, *ppvOut);
3594
3595 return hr;
3596}
3597
3599{
3603 mode = temp;
3604 return mode;
3605}
3606
3608{
3609 TRACE("(%p)->(%p), stub\n", this, pViewMode);
3610
3611 if (!pViewMode)
3612 return E_INVALIDARG;
3613
3614 *pViewMode = m_FolderSettings.ViewMode;
3615 return S_OK;
3616}
3617
3619{
3620 DWORD dwStyle;
3621 TRACE("(%p)->(%u), stub\n", this, ViewMode);
3622
3623 /* It's not redundant to check FVM_AUTO because it's a (UINT)-1 */
3624 if (((INT)ViewMode < FVM_FIRST || (INT)ViewMode > FVM_LAST) && ((INT)ViewMode != FVM_AUTO))
3625 return E_INVALIDARG;
3626
3627 /* Windows before Vista uses LVM_SETVIEW and possibly
3628 LVM_SETEXTENDEDLISTVIEWSTYLE to set the style of the listview,
3629 while later versions seem to accomplish this through other
3630 means. */
3631 switch (ViewMode)
3632 {
3633 case FVM_ICON: dwStyle = LVS_ICON; break;
3634 case FVM_SMALLICON: dwStyle = LVS_SMALLICON; break;
3635 case FVM_LIST: dwStyle = LVS_LIST; break;
3636 case FVM_DETAILS: dwStyle = LVS_REPORT; break;
3637 default:
3638 FIXME("ViewMode %d not implemented\n", ViewMode);
3639 dwStyle = LVS_LIST;
3640 break;
3641 }
3642
3643 m_ListView.ModifyStyle(LVS_TYPEMASK, dwStyle);
3644
3645 /* This will not necessarily be the actual mode set above.
3646 This mimics the behavior of Windows XP. */
3647 m_FolderSettings.ViewMode = ViewMode;
3648 CheckToolbar();
3649 return S_OK;
3650}
3651
3653{
3654 if (m_pSFParent == NULL)
3655 return E_FAIL;
3656
3657 return m_pSFParent->QueryInterface(riid, ppv);
3658}
3659
3661{
3662 PCUITEMID_CHILD pidl = _PidlByItem(iItemIndex);
3663 if (pidl)
3664 {
3665 *ppidl = ILClone(pidl);
3666 return S_OK;
3667 }
3668
3669 *ppidl = 0;
3670 return E_INVALIDARG;
3671}
3672
3674{
3675 TRACE("(%p)->(%u %p)\n", this, uFlags, pcItems);
3677 FIXME("some flags unsupported, %x\n", uFlags & ~(SVGIO_ALLVIEW | SVGIO_SELECTION));
3680 else
3682 return S_OK;
3683}
3684
3686{
3687 return E_NOTIMPL;
3688}
3689
3691{
3692 TRACE("(%p)->(%p)\n", this, piItem);
3693
3694 *piItem = m_ListView.GetSelectionMark();
3695
3696 return S_OK;
3697}
3698
3700{
3701 TRACE("(%p)->(%p)\n", this, piItem);
3702
3703 *piItem = m_ListView.GetNextItem(-1, LVNI_FOCUSED);
3704
3705 return S_OK;
3706}
3707
3709{
3710 if (!m_ListView)
3711 {
3712 ERR("!m_ListView\n");
3713 return E_FAIL;
3714 }
3715
3716 int lvIndex = LV_FindItemByPidl(pidl);
3717 if (lvIndex == -1 || ppt == NULL)
3718 return E_INVALIDARG;
3719
3720 m_ListView.GetItemPosition(lvIndex, ppt);
3721 return S_OK;
3722}
3723
3725{
3726 TRACE("(%p)->(%p)\n", this, ppt);
3727
3728 if (!m_ListView)
3729 {
3730 ERR("!m_ListView\n");
3731 return S_FALSE;
3732 }
3733
3734 if (ppt)
3735 {
3736 SIZE spacing;
3737 m_ListView.GetItemSpacing(spacing);
3738
3739 ppt->x = spacing.cx;
3740 ppt->y = spacing.cy;
3741 }
3742
3743 return S_OK;
3744}
3745
3747{
3748 return E_NOTIMPL;
3749}
3750
3752{
3753 return ((m_ListView.GetStyle() & LVS_AUTOARRANGE) ? S_OK : S_FALSE);
3754}
3755
3757{
3758 DWORD dwExStyle = (DWORD)m_ListView.SendMessage(LVM_GETEXTENDEDLISTVIEWSTYLE, 0, 0);
3759 return ((dwExStyle & LVS_EX_SNAPTOGRID) ? S_OK : S_FALSE);
3760}
3761
3763{
3764 LVITEMW lvItem;
3765
3766 TRACE("(%p)->(%d, %x)\n", this, iItem, dwFlags);
3767
3768 lvItem.state = 0;
3769 lvItem.stateMask = LVIS_SELECTED;
3770
3771 if (dwFlags & SVSI_ENSUREVISIBLE)
3772 m_ListView.EnsureVisible(iItem, 0);
3773
3774 /* all items */
3775 if (dwFlags & SVSI_DESELECTOTHERS)
3777
3778 /* this item */
3779 if (dwFlags & SVSI_SELECT)
3780 lvItem.state |= LVIS_SELECTED;
3781
3782 if (dwFlags & SVSI_FOCUSED)
3783 lvItem.stateMask |= LVIS_FOCUSED;
3784
3785 m_ListView.SetItemState(iItem, lvItem.state, lvItem.stateMask);
3786
3787 if ((dwFlags & SVSI_EDIT) == SVSI_EDIT)
3788 m_ListView.EditLabel(iItem);
3789
3790 return S_OK;
3791}
3792
3794{
3796 m_ListView.SetItemState(-1, 0, LVIS_SELECTED); // Reset the selection
3797 for (UINT i = 0 ; i < cidl; i++)
3798 {
3799 int lvIndex = LV_FindItemByPidl(apidl[i]);
3800 if (lvIndex != -1)
3801 SelectAndPositionItem(lvIndex, dwFlags, apt ? &apt[i] : NULL);
3802 }
3803 return S_OK;
3804}
3805
3806
3807// IShellView2 implementation
3808
3810{
3811 FIXME("(%p)->(%p, %lu) stub\n", this, view_guid, view_type);
3812 return E_NOTIMPL;
3813}
3814
3816{
3817 return CreateViewWindow3(view_params->psbOwner, view_params->psvPrev,
3818 SV3CVW3_DEFAULT, (FOLDERFLAGS)view_params->pfs->fFlags, (FOLDERFLAGS)view_params->pfs->fFlags,
3819 (FOLDERVIEWMODE)view_params->pfs->ViewMode, view_params->pvid, view_params->prcView, &view_params->hwndView);
3820}
3821
3823{
3824 OLEMENUGROUPWIDTHS omw = { { 0, 0, 0, 0, 0, 0 } };
3825 const UINT SUPPORTED_SV3CVW3 = SV3CVW3_FORCEVIEWMODE | SV3CVW3_FORCEFOLDERFLAGS;
3826 const UINT IGNORE_FWF = FWF_OWNERDATA; // FIXME: Support this
3827
3828 *hwnd = NULL;
3829
3830 TRACE("(%p)->(shlview=%p shlbrs=%p rec=%p hwnd=%p vmode=%x flags=%x)\n", this, psvPrevious, psb, prcView, hwnd, mode, flags);
3831 if (prcView != NULL)
3832 TRACE("-- left=%i top=%i right=%i bottom=%i\n", prcView->left, prcView->top, prcView->right, prcView->bottom);
3833
3834 /* Validate the Shell Browser */
3835 if (psb == NULL || m_hWnd)
3836 return E_UNEXPECTED;
3837
3838 if (view_flags & ~SUPPORTED_SV3CVW3)
3839 FIXME("unsupported view flags 0x%08x\n", view_flags & ~SUPPORTED_SV3CVW3);
3840
3841 if (mode == FVM_AUTO)
3843
3844 /* Set up the member variables */
3845 m_pShellBrowser = psb;
3847 m_FolderSettings.fFlags = (mask & flags) & ~IGNORE_FWF;
3848
3849 if (view_id)
3850 {
3851 if (IsEqualIID(*view_id, VID_LargeIcons))
3853 else if (IsEqualIID(*view_id, VID_SmallIcons))
3855 else if (IsEqualIID(*view_id, VID_List))
3857 else if (IsEqualIID(*view_id, VID_Details))
3859 else if (IsEqualIID(*view_id, VID_Thumbnails))
3861 else if (IsEqualIID(*view_id, VID_Tile))
3863 else if (IsEqualIID(*view_id, VID_ThumbStrip))
3865 else
3866 FIXME("Ignoring unrecognized VID %s\n", debugstr_guid(view_id));
3867 }
3868 const UINT requestedViewMode = m_FolderSettings.ViewMode;
3869
3870 /* Get our parent window */
3871 m_pShellBrowser->GetWindow(&m_hWndParent);
3873
3874 /* Try to get the ICommDlgBrowserInterface, adds a reference !!! */
3877 {
3878 TRACE("-- CommDlgBrowser\n");
3879 }
3880
3881 LoadViewState();
3882 if (view_flags & SV3CVW3_FORCEVIEWMODE)
3883 m_FolderSettings.ViewMode = requestedViewMode;
3884 if (view_flags & SV3CVW3_FORCEFOLDERFLAGS)
3885 m_FolderSettings.fFlags = (mask & flags) & ~IGNORE_FWF;
3886
3887 RECT rcView = *prcView;
3889 if (m_hWnd == NULL)
3890 return E_FAIL;
3891
3892 *hwnd = m_hWnd;
3893
3894 CheckToolbar();
3895
3896 if (!*hwnd)
3897 return E_FAIL;
3898
3900
3902 UpdateWindow();
3903
3904 if (!m_hMenu)
3905 {
3906 m_hMenu = CreateMenu();
3907 m_pShellBrowser->InsertMenusSB(m_hMenu, &omw);
3908 TRACE("-- after fnInsertMenusSB\n");
3909 }
3910
3911 _MergeToolbar();
3912
3913 return S_OK;
3914}
3915
3917{
3918 if (!pidl)
3919 {
3921 if (idx < 0)
3923 pidl = _PidlByItem(idx);
3924 }
3925 if (ILFindLastID(pidl) != pidl)
3926 return E_INVALIDARG;
3927 return SelectItem(pidl, SVSI_EDIT | SVSI_ENSUREVISIBLE | SVSI_FOCUSED | SVSI_SELECT);
3928}
3929
3931{
3932 if (Idx == -1)
3933 return fSVSI == SVSI_DESELECTOTHERS ? SelectItem(-2, fSVSI) : E_INVALIDARG;
3934 if (ppt)
3935 m_ListView.SetItemPosition(Idx, ppt);
3936 return SelectItem(Idx, fSVSI); // After SetItemPosition for SVSI_ENSUREVISIBLE
3937}
3938
3940{
3941 if (!item)
3942 return SelectAndPositionItem(-1, flags, point);
3943 int idx = LV_FindItemByPidl(item);
3944 return idx != -1 ? SelectAndPositionItem(idx, flags, point) : S_FALSE;
3945}
3946
3947// IShellFolderView implementation
3948
3950{
3951 _Sort(LOWORD(sort & SHCIDS_COLUMNMASK));
3952 return S_OK;
3953}
3954
3956{
3957 int col = m_sortInfo.ListColumn;
3958 *sort = col != LISTVIEW_SORT_INFO::UNSPECIFIEDCOLUMN ? col : 0;
3960}
3961
3963{
3965 return S_OK;
3966}
3967
3969{
3970 m_ListView.ModifyStyle(0, LVS_AUTOARRANGE);
3972 return S_OK;
3973}
3974
3976{
3977 TRACE("(%p)->(%p %p)\n", this, pidl, item);
3978 if (!m_ListView)
3979 {
3980 ERR("!m_ListView\n");
3981 return E_FAIL;
3982 }
3983 *item = LV_AddItem(pidl);
3984 return (int)*item >= 0 ? S_OK : E_OUTOFMEMORY;
3985}
3986
3988{
3989 TRACE("(%p)->(%p %d)\n", this, pidl, item);
3990 return Item(item, pidl);
3991}
3992
3994{
3995 TRACE("(%p)->(%p %p)\n", this, pidl, item);
3996
3997 if (!m_ListView)
3998 {
3999 ERR("!m_ListView\n");
4000 return E_FAIL;
4001 }
4002
4003 if (pidl)
4004 {
4007 }
4008 else
4009 {
4010 *item = 0;
4012 }
4013
4014 return S_OK;
4015}
4016
4018{
4019 TRACE("(%p)->(%p)\n", this, count);
4021 return S_OK;
4022}
4023
4025{
4026 FIXME("(%p)->(%d %x) stub\n", this, count, flags);
4027 return E_NOTIMPL;
4028}
4029
4031{
4032 FIXME("(%p)->(%p %p %p) stub\n", this, pidl_old, pidl_new, item);
4033 return E_NOTIMPL;
4034}
4035
4037{
4038 FIXME("(%p)->(%p %p) stub\n", this, pidl, item);
4039 return E_NOTIMPL;
4040}
4041
4043{
4044 TRACE("(%p)->(%d)\n", this, redraw);
4045 if (m_ListView)
4047 return S_OK;
4048}
4049
4051{
4053 return S_OK;
4054}
4055
4057{
4058 TRACE("(%p)->(%p %p)\n", this, pidl, items);
4059
4060 *items = GetSelections();
4061
4062 if (*items)
4063 {
4064 *pidl = static_cast<PCUITEMID_CHILD *>(LocalAlloc(0, *items * sizeof(PCUITEMID_CHILD)));
4065 if (!*pidl)
4066 {
4067 return E_OUTOFMEMORY;
4068 }
4069
4070 // It's documented that caller shouldn't free the PIDLs, only the array itself
4071 memcpy(*pidl, m_apidl, *items * sizeof(PCUITEMID_CHILD));
4072 }
4073
4074 return S_OK;
4075}
4076
4078{
4079 if ((m_iDragOverItem == -1 || m_pCurDropTarget == NULL) &&
4081 {
4082 return S_OK;
4083 }
4084
4085 return S_FALSE;
4086}
4087
4089{
4090 if (!pt)
4091 return E_INVALIDARG;
4092
4094 return S_OK;
4095}
4096
4098{
4099 FIXME("(%p)->(%p) stub\n", this, pt);
4100 return E_NOTIMPL;
4101}
4102
4104{
4105 TRACE("(%p)->(%p)\n", this, obj);
4106 return E_NOTIMPL;
4107}
4108
4110{
4111 FIXME("(%p)->(%p %p) stub\n", this, pidl, pt);
4112 return E_NOTIMPL;
4113}
4114
4116{
4117 FIXME("(%p)->(%p) stub\n", this, drop_target);
4118 return E_NOTIMPL;
4119}
4120
4122{
4123 if (!move)
4124 return S_OK;
4125
4126 UINT CutCount = 0;
4127 for (int i = -1; (i = m_ListView.GetNextItem(i, LVNI_SELECTED)) != -1;)
4128 {
4129 if (!CutCount++)
4130 {
4131 // Turn off the LVIS_CUT LVM_SETCALLBACKMASK optimization
4132 m_ListView.SendMessageW(LVM_SETCALLBACKMASK, m_ListView.SendMessageW(LVM_GETCALLBACKMASK, 0, 0) & ~LVIS_CUT, 0);
4134 }
4136 }
4137 if (CutCount)
4138 {
4140 m_HasCutItems = true;
4141 }
4142 return S_OK;
4143}
4144
4146{
4147 FIXME("(%p)->(%p) stub\n", this, obj);
4148 return E_NOTIMPL;
4149}
4150
4152{
4153 FIXME("(%p)->(%p) stub\n", this, spacing);
4154 return E_NOTIMPL;
4155}
4156
4157HRESULT STDMETHODCALLTYPE CDefView::SetCallback(IShellFolderViewCB *new_cb, IShellFolderViewCB **old_cb)
4158{
4159 if (old_cb)
4160 *old_cb = m_pShellFolderViewCB.Detach();
4161
4162 m_pShellFolderViewCB = new_cb;
4164 if (new_cb)
4165 new_cb->QueryInterface(IID_PPV_ARG(IFolderFilter, &m_pFolderFilter));
4166 return S_OK;
4167}
4168
4170{
4171 FIXME("(%p)->(%d) stub\n", this, flags);
4172 return E_NOTIMPL;
4173}
4174
4176{
4177 TRACE("(%p)->(%p)\n", this, support);
4178 return S_OK;
4179}
4180
4182{
4183 FIXME("(%p)->(%p) stub\n", this, disp);
4184 return E_NOTIMPL;
4185}
4186
4187HRESULT WINAPI CDefView::QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD *prgCmds, OLECMDTEXT *pCmdText)
4188{
4189 FIXME("(%p)->(%p(%s) 0x%08x %p %p\n",
4190 this, pguidCmdGroup, debugstr_guid(pguidCmdGroup), cCmds, prgCmds, pCmdText);
4191
4192 if (!prgCmds)
4193 return E_INVALIDARG;
4194
4195 for (UINT i = 0; i < cCmds; i++)
4196 {
4197 FIXME("\tprgCmds[%d].cmdID = %d\n", i, prgCmds[i].cmdID);
4198 prgCmds[i].cmdf = 0;
4199 }
4200
4201 return OLECMDERR_E_UNKNOWNGROUP;
4202}
4203
4205// ISVOleCmdTarget_Exec(IOleCommandTarget)
4206//
4207// nCmdID is the OLECMDID_* enumeration
4208HRESULT WINAPI CDefView::Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
4209{
4210 FIXME("(%p)->(\n\tTarget GUID:%s Command:0x%08x Opt:0x%08x %p %p)\n",
4211 this, debugstr_guid(pguidCmdGroup), nCmdID, nCmdexecopt, pvaIn, pvaOut);
4212
4213 if (!pguidCmdGroup)
4214 return OLECMDERR_E_UNKNOWNGROUP;
4215
4216 if (IsEqualCLSID(*pguidCmdGroup, m_Category))
4217 {
4218 if (nCmdID == FCIDM_SHVIEW_AUTOARRANGE)
4219 {
4220 if (V_VT(pvaIn) != VT_INT_PTR)
4221 return OLECMDERR_E_NOTSUPPORTED;
4222
4224 params.cbSize = sizeof(params);
4225 params.rcExclude = *(RECT*) V_INTREF(pvaIn);
4226
4227 if (m_hMenuViewModes)
4228 {
4229 // Duplicate all but the last two items of the view modes menu
4230 HMENU hmenuViewPopup = CreatePopupMenu();
4231 Shell_MergeMenus(hmenuViewPopup, m_hMenuViewModes, 0, 0, 0xFFFF, 0);
4232 DeleteMenu(hmenuViewPopup, GetMenuItemCount(hmenuViewPopup) - 1, MF_BYPOSITION);
4233 DeleteMenu(hmenuViewPopup, GetMenuItemCount(hmenuViewPopup) - 1, MF_BYPOSITION);
4234 CheckViewMode(hmenuViewPopup);
4235 TrackPopupMenuEx(hmenuViewPopup, TPM_LEFTALIGN | TPM_TOPALIGN, params.rcExclude.left, params.rcExclude.bottom, m_hWndParent, &params);
4236 ::DestroyMenu(hmenuViewPopup);
4237 }
4238
4239 // pvaOut is VT_I4 with value 0x403 (cmd id of the new mode maybe?)
4240 V_VT(pvaOut) = VT_I4;
4241 V_I4(pvaOut) = 0x403;
4242 }
4243 }
4244
4245 if (IsEqualIID(*pguidCmdGroup, CGID_Explorer) &&
4246 (nCmdID == 0x29) &&
4247 (nCmdexecopt == 4) && pvaOut)
4248 return S_OK;
4249
4250 if (IsEqualIID(*pguidCmdGroup, CGID_ShellDocView) &&
4251 (nCmdID == 9) &&
4252 (nCmdexecopt == 0))
4253 return 1;
4254
4255 if (IsEqualIID(*pguidCmdGroup, CGID_DefView))
4256 {
4257 CComPtr<IStream> pStream;
4258 WCHAR SubKey[MAX_PATH];
4259 switch (nCmdID)
4260 {
4262 SHDeleteKey(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\ShellNoRoam\\Bags");
4264 SaveViewState(pStream);
4265 return S_OK;
4267 PathCombineW(SubKey, REGSTR_PATH_EXPLORER, L"Streams\\Default");
4269 SHDeleteKey(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\ShellNoRoam\\Bags");
4270 m_FolderSettings.fFlags |= FWF_NOBROWSERVIEWSTATE; // Don't let this folder save itself
4271 return S_OK;
4272 }
4273 }
4274
4275 return OLECMDERR_E_UNKNOWNGROUP;
4276}
4277
4278/**********************************************************
4279 * ISVDropTarget implementation
4280 */
4281
4282/******************************************************************************
4283 * drag_notify_subitem [Internal]
4284 *
4285 * Figure out the shellfolder object, which is currently under the mouse cursor
4286 * and notify it via the IDropTarget interface.
4287 */
4288
4289#define SCROLLAREAWIDTH 20
4290
4292{
4293 LONG lResult;
4294 HRESULT hr;
4295 RECT clientRect;
4296
4297 /* The key state on drop doesn't have MK_LBUTTON or MK_RBUTTON because it
4298 reflects the key state after the user released the button, so we need
4299 to remember the last key state when the button was pressed */
4300 m_grfKeyState = grfKeyState;
4301
4302 // Map from global to client coordinates and query the index of the
4303 // listview-item, which is currently under the mouse cursor.
4304 LVHITTESTINFO htinfo = {{pt.x, pt.y}, LVHT_ONITEM};
4305 ScreenToClient(&htinfo.pt);
4306 lResult = m_ListView.HitTest(&htinfo);
4307
4308 /* Send WM_*SCROLL messages every 250 ms during drag-scrolling */
4309 ::GetClientRect(m_ListView, &clientRect);
4310 if (htinfo.pt.x == m_ptLastMousePos.x && htinfo.pt.y == m_ptLastMousePos.y &&
4311 (htinfo.pt.x < SCROLLAREAWIDTH || htinfo.pt.x > clientRect.right - SCROLLAREAWIDTH ||
4312 htinfo.pt.y < SCROLLAREAWIDTH || htinfo.pt.y > clientRect.bottom - SCROLLAREAWIDTH))
4313 {
4314 m_cScrollDelay = (m_cScrollDelay + 1) % 5; // DragOver is called every 50 ms
4315 if (m_cScrollDelay == 0)
4316 {
4317 /* Mouse did hover another 250 ms over the scroll-area */
4318 if (htinfo.pt.x < SCROLLAREAWIDTH)
4319 m_ListView.SendMessageW(WM_HSCROLL, SB_LINEUP, 0);
4320
4321 if (htinfo.pt.x > clientRect.right - SCROLLAREAWIDTH)
4322 m_ListView.SendMessageW(WM_HSCROLL, SB_LINEDOWN, 0);
4323
4324 if (htinfo.pt.y < SCROLLAREAWIDTH)
4325 m_ListView.SendMessageW(WM_VSCROLL, SB_LINEUP, 0);
4326
4327 if (htinfo.pt.y > clientRect.bottom - SCROLLAREAWIDTH)
4328 m_ListView.SendMessageW(WM_VSCROLL, SB_LINEDOWN, 0);
4329 }
4330 }
4331 else
4332 {
4333 m_cScrollDelay = 0; // Reset, if cursor is not over the listview's scroll-area
4334 }
4335
4336 m_ptLastMousePos = htinfo.pt;
4338
4339 /* We need to check if we drag the selection over itself */
4340 if (lResult != -1 && m_pSourceDataObject.p != NULL)
4341 {
4342 PCUITEMID_CHILD pidl = _PidlByItem(lResult);
4343
4344 for (UINT i = 0; i < m_cidl; i++)
4345 {
4346 if (pidl == m_apidl[i])
4347 {
4348 /* The item that is being draged is hovering itself. */
4349 lResult = -1;
4350 break;
4351 }
4352 }
4353 }
4354
4355 // If we are still over the previous sub-item, notify it via DragOver and return
4356 if (m_pCurDropTarget && lResult == m_iDragOverItem)
4357 return m_pCurDropTarget->DragOver(grfKeyState, pt, pdwEffect);
4358
4359 // We've left the previous sub-item, notify it via DragLeave and release it
4360 if (m_pCurDropTarget)
4361 {
4363 if (pidl)
4364 SelectItem(pidl, 0);
4365
4366 m_pCurDropTarget->DragLeave();
4368 }
4369
4370 m_iDragOverItem = lResult;
4371
4372 if (lResult == -1)
4373 {
4374 // We are not above one of the listview's subitems. Bind to the
4375 // parent folder's DropTarget interface.
4377 }
4378 else
4379 {
4380 // Query the relative PIDL of the shellfolder object represented
4381 // by the currently dragged over listview-item ...
4382 PCUITEMID_CHILD pidl = _PidlByItem(lResult);
4383
4384 // ... and bind m_pCurDropTarget to the IDropTarget interface of an UIObject of this object
4385 hr = m_pSFParent->GetUIObjectOf(m_ListView, 1, &pidl, IID_NULL_PPV_ARG(IDropTarget, &m_pCurDropTarget));
4386 }
4387
4389
4390 // If anything failed, m_pCurDropTarget should be NULL now, which ought to be a save state
4391 if (FAILED(hr))
4392 {
4393 *pdwEffect = DROPEFFECT_NONE;
4394 return hr;
4395 }
4396
4397 if (m_iDragOverItem != -1)
4398 {
4399 SelectItem(m_iDragOverItem, SVSI_SELECT);
4400 }
4401
4402 // Notify the item just entered via DragEnter
4403 return m_pCurDropTarget->DragEnter(m_pCurDataObject, grfKeyState, pt, pdwEffect);
4404}
4405
4406HRESULT WINAPI CDefView::DragEnter(IDataObject *pDataObject, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
4407{
4408 if (*pdwEffect == DROPEFFECT_NONE)
4409 return S_OK;
4410
4411 /* Get a hold on the data object for later calls to DragEnter on the sub-folders */
4412 m_pCurDataObject = pDataObject;
4413
4414 HRESULT hr = drag_notify_subitem(grfKeyState, pt, pdwEffect);
4415 if (SUCCEEDED(hr))
4416 {
4417 POINT ptClient = {pt.x, pt.y};
4418 ScreenToClient(&ptClient);
4419 ImageList_DragEnter(m_hWnd, ptClient.x, ptClient.y);
4420 }
4421
4422 return hr;
4423}
4424
4426{
4427 POINT ptClient = {pt.x, pt.y};
4428 ScreenToClient(&ptClient);
4429 ImageList_DragMove(ptClient.x, ptClient.y);
4430 return drag_notify_subitem(grfKeyState, pt, pdwEffect);
4431}
4432
4434{
4436
4437 if (m_pCurDropTarget)
4438 {
4439 m_pCurDropTarget->DragLeave();
4441 }
4442
4443 if (m_pCurDataObject != NULL)
4444 {
4446 }
4447
4448 m_iDragOverItem = 0;
4449
4450 return S_OK;
4451}
4452
4454{
4455 RECT rcBound;
4456 INT i, nCount = m_ListView.GetItemCount();
4457 DWORD dwSpacing;
4458 INT dx, dy;
4459 BOOL bSmall = ((m_ListView.GetStyle() & LVS_TYPEMASK) != LVS_ICON);
4460
4461 // FIXME: LVM_GETORIGIN is broken. See CORE-17266
4462 pt.x += m_ListView.GetScrollPos(SB_HORZ);
4463 pt.y += m_ListView.GetScrollPos(SB_VERT);
4464
4465 if (m_ListView.GetStyle() & LVS_ALIGNLEFT)
4466 {
4467 // vertically
4468 for (i = 0; i < nCount; ++i)
4469 {
4470 dwSpacing = ListView_GetItemSpacing(m_ListView, bSmall);
4471 dx = LOWORD(dwSpacing);
4472 dy = HIWORD(dwSpacing);
4474 rcBound.right = rcBound.left + dx;
4475 rcBound.bottom = rcBound.top + dy;
4476 if (pt.x < rcBound.right && pt.y < (rcBound.top + rcBound.bottom) / 2)
4477 {
4478 return i;
4479 }
4480 }
4481 for (i = nCount - 1; i >= 0; --i)
4482 {
4484 if (rcBound.left < pt.x && rcBound.top < pt.y)
4485 {
4486 return i + 1;
4487 }
4488 }
4489 }
4490 else
4491 {
4492 // horizontally
4493 for (i = 0; i < nCount; ++i)
4494 {
4495 dwSpacing = ListView_GetItemSpacing(m_ListView, bSmall);
4496 dx = LOWORD(dwSpacing);
4497 dy = HIWORD(dwSpacing);
4499 rcBound.right = rcBound.left + dx;
4500 rcBound.bottom = rcBound.top + dy;
4501 if (pt.y < rcBound.bottom && pt.x < rcBound.left)
4502 {
4503 return i;
4504 }
4505 if (pt.y < rcBound.bottom && pt.x < rcBound.right)
4506 {
4507 return i + 1;
4508 }
4509 }
4510 for (i = nCount - 1; i >= 0; --i)
4511 {
4513 if (rcBound.left < pt.x && rcBound.top < pt.y)
4514 {
4515 return i + 1;
4516 }
4517 }
4518 }
4519
4520 return nCount;
4521}
4522
4524{
4525 LRESULT lResult;
4526
4527 if (!m_isFullStatusBar)
4528 {
4529 int nPartArray[] = {-1};
4530 m_pShellBrowser->SendControlMsg(FCW_STATUS, SB_SETPARTS, _countof(nPartArray), (LPARAM)nPartArray, &lResult);
4531 return;
4532 }
4533
4534 int nFileSizePartLength = 125;
4535 const int nLocationPartLength = 150;
4536 const int nRightPartsLength = nFileSizePartLength + nLocationPartLength;
4537 int nObjectsPartLength = nWidth - nRightPartsLength;
4538
4539 // If the window is small enough just divide each part into thirds
4540 // to match the behavior of Windows Server 2003
4541 if (nObjectsPartLength <= nLocationPartLength)
4542 nObjectsPartLength = nFileSizePartLength = nWidth / 3;
4543
4544 int nPartArray[] = {nObjectsPartLength, nObjectsPartLength + nFileSizePartLength, -1};
4545
4546 m_pShellBrowser->SendControlMsg(FCW_STATUS, SB_SETPARTS, _countof(nPartArray), (LPARAM)nPartArray, &lResult);
4547}
4548
4550{
4551 // Get the handle for the status bar
4552 HWND fStatusBar;
4553 m_pShellBrowser->GetControlWindow(FCW_STATUS, &fStatusBar);
4554
4555 // Get the size of our status bar
4556 RECT statusBarSize;
4557 ::GetWindowRect(fStatusBar, &statusBarSize);
4558
4559 // Resize the status bar
4560 _HandleStatusBarResize(statusBarSize.right - statusBarSize.left);
4561}
4562
4564
4565static INT CALLBACK
4566SelectionMoveCompareFunc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
4567{
4568 CLParamIndexMap *pmap = (CLParamIndexMap *)lParamSort;
4569 INT i1 = pmap->Lookup(lParam1), i2 = pmap->Lookup(lParam2);
4570 if (i1 < i2)
4571 return -1;
4572 if (i1 > i2)
4573 return 1;
4574 return 0;
4575}
4576
4578{
4579 // get insertable index from position
4581
4582 // create identity mapping of indexes
4584 INT nCount = m_ListView.GetItemCount();
4585 for (INT i = 0; i < nCount; ++i)
4586 {
4587 array.Add(i);
4588 }
4589
4590 // re-ordering mapping
4591 INT iItem = -1;
4592 while ((iItem = m_ListView.GetNextItem(iItem, LVNI_SELECTED)) >= 0)
4593 {
4594 INT iFrom = iItem, iTo = iPosition;
4595 if (iFrom < iTo)
4596 --iTo;
4597 if (iFrom >= nCount)
4598 iFrom = nCount - 1;
4599 if (iTo >= nCount)
4600 iTo = nCount - 1;
4601
4602 // shift indexes by swapping (like a bucket relay)
4603 if (iFrom < iTo)
4604 {
4605 for (INT i = iFrom; i < iTo; ++i)
4606 {
4607 // swap array[i] and array[i + 1]
4608 INT tmp = array[i];
4609 array[i] = array[i + 1];
4610 array[i + 1] = tmp;
4611 }
4612 }
4613 else
4614 {
4615 for (INT i = iFrom; i > iTo; --i)
4616 {
4617 // swap array[i] and array[i - 1]
4618 INT tmp = array[i];
4619 array[i] = array[i - 1];
4620 array[i - 1] = tmp;
4621 }
4622 }
4623 }
4624
4625 // create mapping (ListView's lParam to index) from array
4627 for (INT i = 0; i < nCount; ++i)
4628 {
4630 map.Add(lParam, i);
4631 }
4632
4633 // finally sort
4635}
4636
4637HRESULT WINAPI CDefView::Drop(IDataObject* pDataObject, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
4638{
4641
4642 if ((IsDropOnSource(NULL) == S_OK) &&
4643 (*pdwEffect & DROPEFFECT_MOVE) &&
4645 {
4646 if (m_pCurDropTarget)
4647 {
4648 m_pCurDropTarget->DragLeave();
4650 }
4651
4652 POINT ptDrop = { pt.x, pt.y };
4653 ::ScreenToClient(m_ListView, &ptDrop);
4655 m_ptLastMousePos = ptDrop;
4656
4658 if (m_ListView.GetStyle() & LVS_AUTOARRANGE)
4659 {
4661 }
4662 else
4663 {
4664 POINT ptItem;
4665 INT iItem = -1;
4666 while ((iItem = m_ListView.GetNextItem(iItem, LVNI_SELECTED)) >= 0)
4667 {
4668 if (m_ListView.GetItemPosition(iItem, &ptItem))
4669 {
4672 m_ListView.SetItemPosition(iItem, &ptItem);
4673 }
4674 }
4675 }
4677 }
4678 else if (m_pCurDropTarget)
4679 {
4680 m_pCurDropTarget->Drop(pDataObject, grfKeyState, pt, pdwEffect);
4682 }
4683
4685 m_iDragOverItem = 0;
4686 return S_OK;
4687}
4688
4690{
4691 TRACE("(%p)\n", this);
4692
4693 if (fEscapePressed)
4694 return DRAGDROP_S_CANCEL;
4695 else if (!(grfKeyState & MK_LBUTTON) && !(grfKeyState & MK_RBUTTON))
4696 return DRAGDROP_S_DROP;
4697 else
4698 return S_OK;
4699}
4700
4702{
4703 TRACE("(%p)\n", this);
4704
4706}
4707
4708HRESULT 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)
4709{
4710 FIXME("Stub: this=%p\n", this);
4711 return E_NOTIMPL;
4712}
4713
4714HRESULT WINAPI CDefView::GetColorSet(DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd, HDC hicTargetDevice, LOGPALETTE **ppColorSet)
4715{
4716 FIXME("Stub: this=%p\n", this);
4717 return E_NOTIMPL;
4718}
4719
4720HRESULT WINAPI CDefView::Freeze(DWORD dwDrawAspect, LONG lindex, void *pvAspect, DWORD *pdwFreeze)
4721{
4722 FIXME("Stub: this=%p\n", this);
4723 return E_NOTIMPL;
4724}
4725
4727{
4728 FIXME("Stub: this=%p\n", this);
4729 return E_NOTIMPL;
4730}
4731
4733{
4734 FIXME("partial stub: %p 0x%08x 0x%08x %p\n", this, aspects, advf, pAdvSink);
4735
4736 // FIXME: we set the AdviseSink, but never use it to send any advice
4737 m_pAdvSink = pAdvSink;
4738 m_dwAspects = aspects;
4739 m_dwAdvf = advf;
4740
4741 return S_OK;
4742}
4743
4745{
4746 TRACE("this=%p pAspects=%p pAdvf=%p ppAdvSink=%p\n", this, pAspects, pAdvf, ppAdvSink);
4747
4748 if (ppAdvSink)
4749 {
4750 *ppAdvSink = m_pAdvSink;
4751 m_pAdvSink.p->AddRef();
4752 }
4753
4754 if (pAspects)
4755 *pAspects = m_dwAspects;
4756
4757 if (pAdvf)
4758 *pAdvf = m_dwAdvf;
4759
4760 return S_OK;
4761}
4762
4764{
4765 if (IsEqualIID(guidService, SID_SFolderView))
4766 return QueryInterface(riid, ppvObject);
4767 return m_pShellBrowser ? IUnknown_QueryService(m_pShellBrowser, guidService, riid, ppvObject) : E_NOINTERFACE;
4768}
4769
4771{
4773 HRESULT hr = S_OK;
4774
4775 hr = IUnknown_QueryService(m_pShellBrowser, IID_IExplorerToolbar, IID_PPV_ARG(IExplorerToolbar, &ptb));
4776 if (FAILED(hr))
4777 return hr;
4778
4779 m_Category = CGID_DefViewFrame;
4780
4781 hr = ptb->SetCommandTarget(static_cast<IOleCommandTarget*>(this), &m_Category, 0);
4782 if (FAILED(hr))
4783 return hr;
4784
4785 if (hr == S_FALSE)
4786 return S_OK;
4787
4788#if 0
4789 hr = ptb->AddButtons(&m_Category, buttonsCount, buttons);
4790 if (FAILED(hr))
4791 return hr;
4792#endif
4793
4794 return S_OK;
4795}
4796
4798{
4800
4802 {
4803 hr = m_pShellFolderViewCB->MessageSFVCB(uMsg, wParam, lParam);
4804 }
4805
4806 return hr;
4807}
4808
4810{
4811 return ShellObjectCreatorInit<CDefView>(pFolder, riid, ppvOut);
4812}
4813
4815{
4817 HRESULT hRes;
4818
4819 if (!ppsv)
4820 return E_INVALIDARG;
4821
4822 *ppsv = NULL;
4823
4824 if (!pcsfv || pcsfv->cbSize != sizeof(*pcsfv))
4825 return E_INVALIDARG;
4826
4827 TRACE("sf=%p outer=%p callback=%p\n",
4828 pcsfv->pshf, pcsfv->psvOuter, pcsfv->psfvcb);
4829
4830 hRes = CDefView_CreateInstance(pcsfv->pshf, IID_PPV_ARG(IShellView, &psv));
4831 if (FAILED(hRes))
4832 return hRes;
4833
4834 if (pcsfv->psfvcb)
4835 {
4837 if (SUCCEEDED(psv->QueryInterface(IID_PPV_ARG(IShellFolderView, &sfv))))
4838 {
4839 sfv->SetCallback(pcsfv->psfvcb, NULL);
4840 }
4841 }
4842
4843 *ppsv = psv.Detach();
4844 return hRes;
4845}
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:105
static BOOL AppendMenuItem(HMENU hMenu, UINT MF, UINT Id, LPCWSTR String, SIZE_T Data=0)
Definition: CDefView.cpp:158
#define GET_WM_COMMAND_HWND(wp, lp)
Definition: CDefView.cpp:590
static SIZE_T GetMenuItemDataById(HMENU hMenu, UINT Id)
Definition: CDefView.cpp:171
@ 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
CSimpleMap< LPARAM, INT > CLParamIndexMap
Definition: CDefView.cpp:4563
#define SCROLLAREAWIDTH
Definition: CDefView.cpp:4289
#define SHV_UPDATESTATUSBAR
Definition: CDefView.cpp:79
static BOOL ILIsParentOrSpecialParent(PCIDLIST_ABSOLUTE pidl1, PCIDLIST_ABSOLUTE pidl2)
Definition: CDefView.cpp:2912
void(CALLBACK * PFNSHGETSETTINGSPROC)(LPSHELLFLAGSTATE lpsfs, DWORD dwMask)
Definition: CDefView.cpp:593
#define SHV_CHANGE_NOTIFY
Definition: CDefView.cpp:78
static COLORREF GetViewColor(COLORREF Clr, UINT SysFallback)
Definition: CDefView.cpp:216
#define GET_WM_COMMAND_ID(wp, lp)
Definition: CDefView.cpp:589
#define CONTEXT_MENU_BASE_ID
Definition: CDefView.cpp:83
#define UPDATEFOLDERVIEWFLAGS(bits, bit, set)
Definition: CDefView.cpp:3476
HRESULT CDefView_CreateInstance(IShellFolder *pFolder, REFIID riid, LPVOID *ppvOut)
Definition: CDefView.cpp:4809
#define ID_LISTVIEW
Definition: CDefView.cpp:586
static HRESULT LoadColumnsStream(PERSISTCOLUMNS &cols, IStream *pS)
Definition: CDefView.cpp:3324
#define GET_WM_COMMAND_CMD(wp, lp)
Definition: CDefView.cpp:591
static UINT ReallyGetMenuItemID(HMENU hmenu, int i)
Definition: CDefView.cpp:193
static INT CALLBACK SelectionMoveCompareFunc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
Definition: CDefView.cpp:4566
HRESULT WINAPI SHCreateShellFolderView(const SFV_CREATE *pcsfv, IShellView **ppsv)
Definition: CDefView.cpp:4814
static DWORD ReadDWORD(IPropertyBag *pPB, LPCWSTR name, DWORD def)
Definition: CDefView.cpp:3302
static HMENU GetSubmenuByID(HMENU hmenu, UINT id)
Definition: CDefView.cpp:182
static VOID DrawTileBitmap(HDC hDC, LPCRECT prc, HBITMAP hbm, INT nWidth, INT nHeight, INT dx, INT dy)
Definition: CDefView.cpp:1691
static HRESULT SHGetLVColumnSubItem(HWND List, UINT Col)
Definition: CDefView.cpp:1017
static void ClientToListView(HWND hwndLV, POINT *ppt)
Definition: CDefView.cpp:120
static UINT CalculateCharWidth(HWND hwnd)
Definition: CDefView.cpp:202
static BOOL SelectExtOnRename(void)
Definition: CDefView.cpp:2641
PCSTR MapFcidmCmdToVerb(_In_ UINT_PTR CmdId)
static HRESULT WINAPI DisplayNameOfW(_In_ IShellFolder *psf, _In_ LPCITEMIDLIST pidl, _In_ DWORD dwFlags, _Out_ LPWSTR pszBuf, _In_ UINT cchBuf)
Definition: CFindFolder.cpp:15
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
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#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:4637
STDMETHOD() Unfreeze(DWORD dwFreeze) override
Definition: CDefView.cpp:4726
HMENU m_hMenu
Definition: CDefView.cpp:246
HRESULT LoadColumn(UINT FoldCol, UINT ListCol, BOOL Insert, UINT ForceWidth=0)
Definition: CDefView.cpp:1092
DWORD GetCommDlgViewFlags()
Definition: CDefView.cpp:364
LRESULT OnShowWindow(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:1641
CComPtr< IShellFolder > m_pSFParent
Definition: CDefView.cpp:234
LRESULT OnKillFocus(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:2537
STDMETHOD() GetAutoArrange() override
Definition: CDefView.cpp:3751
void RefreshGhostedState()
Definition: CDefView.cpp:3138
LRESULT OnChangeCBChain(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:3118
LRESULT OnSetFocus(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:2517
HRESULT OnStateChange(UINT uFlags)
Definition: CDefView.cpp:696
HDPA m_LoadColumnsList
Definition: CDefView.cpp:255
static INT CALLBACK fill_list(LPVOID ptr, LPVOID arg)
Definition: CDefView.cpp:1522
CComPtr< IShellDetails > m_pSDParent
Definition: CDefView.cpp:236
STDMETHOD() DestroyViewWindow() override
Definition: CDefView.cpp:3226
LRESULT OnSysColorChange(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:1739
LRESULT OnContextMenu(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:2251
int LV_AddItem(PCUITEMID_CHILD pidl)
Definition: CDefView.cpp:1383
STDMETHOD() SetItemPos(PCUITEMID_CHILD pidl, POINT *pt) override
Definition: CDefView.cpp:4109
UINT GetItemActivateFlags()
Definition: CDefView.cpp:3484
BOOL IsSpecialFolder(int &csidl) const
Definition: CDefView.cpp:299
bool m_ScheduledStatusbarUpdate
Definition: CDefView.cpp:279
HRESULT FillFileMenu()
Definition: CDefView.cpp:1851
STDMETHOD() RemoveObject(PITEMID_CHILD pidl, UINT *item) override
Definition: CDefView.cpp:3993
void UpdateStatusbar()
Definition: CDefView.cpp:734
BOOL IsDesktop() const
Definition: CDefView.cpp:297
HMENU m_hMenuArrangeModes
Definition: CDefView.cpp:247
CComPtr< IDataObject > m_pCurDataObject
Definition: CDefView.cpp:266
HRESULT FillEditMenu()
Definition: CDefView.cpp:1897
bool m_isFullStatusBar
Definition: CDefView.cpp:278
STDMETHOD() SetAutomationObject(IDispatch *disp) override
Definition: CDefView.cpp:4181
LRESULT OnMenuMessage(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:3026
CComPtr< IShellFolderViewDual > m_pShellFolderViewDual
Definition: CDefView.cpp:241
STDMETHOD() DragLeave() override
Definition: CDefView.cpp:4433
LRESULT OnNCCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:1753
STDMETHOD() AutoArrange() override
Definition: CDefView.cpp:3968
BOOL CreateList()
Definition: CDefView.cpp:843
void UpdateListColors()
Definition: CDefView.cpp:941
HWND m_hWndParent
Definition: CDefView.cpp:244
STDMETHOD() ContextSensitiveHelp(BOOL fEnterMode) override
Definition: CDefView.cpp:3155
STDMETHOD() AddPropertySheetPages(DWORD dwReserved, LPFNSVADDPROPSHEETPAGE pfn, LPARAM lparam) override
Definition: CDefView.cpp:3286
STDMETHOD() QueryService(REFGUID guidService, REFIID riid, void **ppvObject) override
Definition: CDefView.cpp:4763
BOOLEAN LV_DeleteItem(PCUITEMID_CHILD pidl)
Definition: CDefView.cpp:1407
STDMETHOD() GetItemObject(UINT uItem, REFIID riid, void **ppv) override
Definition: CDefView.cpp:3548
STDMETHOD() GetObjectCount(UINT *count) override
Definition: CDefView.cpp:4017
HRESULT _MergeToolbar()
Definition: CDefView.cpp:4770
STDMETHOD() SetCallback(IShellFolderViewCB *new_cb, IShellFolderViewCB **old_cb) override
Definition: CDefView.cpp:4157
HRESULT drag_notify_subitem(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
Definition: CDefView.cpp:4291
DWORD m_dwAdvf
Definition: CDefView.cpp:261
HRESULT _DoFolderViewCB(UINT uMsg, WPARAM wParam, LPARAM lParam)
Definition: CDefView.cpp:4797
STDMETHOD() Items(UINT uFlags, REFIID riid, void **ppv) override
Definition: CDefView.cpp:3685
STDMETHOD() CreateViewWindow2(LPSV2CVW2_PARAMS view_params) override
Definition: CDefView.cpp:3815
STDMETHOD() SelectItem(PCUITEMID_CHILD pidlItem, SVSIF uFlags) override
Definition: CDefView.cpp:3492
LRESULT OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:2418
STDMETHOD() GetAdvise(DWORD *pAspects, DWORD *pAdvf, IAdviseSink **ppAdvSink) override
Definition: CDefView.cpp:4744
LRESULT OnGetDlgCode(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:1649
void CheckToolbar()
Definition: CDefView.cpp:715
HRESULT IncludeObject(PCUITEMID_CHILD pidl)
Definition: CDefView.cpp:666
DWORD m_dwAspects
Definition: CDefView.cpp:260
STDMETHOD() SaveViewState() override
Definition: CDefView.cpp:3469
CComPtr< IContextMenu > m_pCM
Definition: CDefView.cpp:273
CComPtr< IShellBrowser > m_pShellBrowser
Definition: CDefView.cpp:238
void _DoCopyToMoveToFolder(BOOL bCopy)
Definition: CDefView.cpp:2488
HRESULT GetDetailsByListColumn(PCUITEMID_CHILD pidl, UINT ListCol, SHELLDETAILS &sd)
Definition: CDefView.cpp:1083
INT _FindInsertableIndexFromPoint(POINT pt)
Definition: CDefView.cpp:4453
LRESULT OnPrintClient(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:1712
LRESULT DoColumnContextMenu(LRESULT lParam)
Definition: CDefView.cpp:1999
UINT m_cScrollDelay
Definition: CDefView.cpp:268
LISTVIEW_SORT_INFO m_sortInfo
Definition: CDefView.cpp:257
CComPtr< IDataObject > m_pSourceDataObject
Definition: CDefView.cpp:264
HRESULT CheckViewMode(HMENU hmenuView)
Definition: CDefView.cpp:1986
CComPtr< IAdviseSink > m_pAdvSink
Definition: CDefView.cpp:262
void _HandleStatusBarResize(int width)
Definition: CDefView.cpp:4523
STDMETHOD() SetCurrentViewMode(UINT ViewMode) override
Definition: CDefView.cpp:3618
LRESULT OnInitMenuPopup(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:3058
LRESULT OnUpdateStatusbar(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:832
POINT m_ptFirstMousePos
Definition: CDefView.cpp:270
LRESULT OnExplorerCommand(UINT uCommand, BOOL bUseSelection)
Definition: CDefView.cpp:2368
LRESULT OnSettingChange(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:3039
ClipboardViewerChain m_ClipboardChain
Definition: CDefView.cpp:242
STDMETHOD() GetItemPosition(PCUITEMID_CHILD pidl, POINT *ppt) override
Definition: CDefView.cpp:3708
STDMETHOD() SetPoints(IDataObject *obj) override
Definition: CDefView.cpp:4145
STDMETHOD() IsDropOnSource(IDropTarget *drop_target) override
Definition: CDefView.cpp:4077
HRESULT FillList(BOOL IsRefreshCommand=TRUE)
Definition: CDefView.cpp:1539
CComPtr< IDropTarget > m_pCurDropTarget
Definition: CDefView.cpp:265
PIDLIST_ABSOLUTE m_pidlParent
Definition: CDefView.cpp:254
STDMETHOD() GetSelectionMarkedItem(int *piItem) override
Definition: CDefView.cpp:3690
STDMETHOD() TranslateAccelerator(MSG *pmsg) override
Definition: CDefView.cpp:3163
STDMETHOD() QueryContinueDrag(BOOL fEscapePressed, DWORD grfKeyState) override
Definition: CDefView.cpp:4689
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:4708
HMENU m_hContextMenu
Definition: CDefView.cpp:249
CComPtr< IShellFolderViewCB > m_pShellFolderViewCB
Definition: CDefView.cpp:237
STDMETHOD() GiveFeedback(DWORD dwEffect) override
Definition: CDefView.cpp:4701
STDMETHOD() ArrangeGrid() override
Definition: CDefView.cpp:3962
STDMETHOD() SetRedraw(BOOL redraw) override
Definition: CDefView.cpp:4042
void _ForceStatusBarResize()
Definition: CDefView.cpp:4549
BOOL m_Destroyed
Definition: CDefView.cpp:283
CComPtr< IContextMenu > m_pFileMenu
Definition: CDefView.cpp:274
HRESULT WINAPI Initialize(IShellFolder *shellFolder)
Definition: CDefView.cpp:655
PCUITEMID_CHILD * m_apidl
Definition: CDefView.cpp:253
CComPtr< IFolderFilter > m_pFolderFilter
Definition: CDefView.cpp:240
void LV_RefreshIcons()
Definition: CDefView.cpp:1508
LRESULT OnActivate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:2511
HRESULT InvokeContextMenuCommand(CComPtr< IContextMenu > &pCM, LPCSTR lpVerb, POINT *pt=NULL, bool TryMapVerb=false)
Definition: CDefView.cpp:2147
STDMETHOD() GetSelectedObjects(PCUITEMID_CHILD **pidl, UINT *items) override
Definition: CDefView.cpp:4056
HDPA m_ListToFolderColMap
Definition: CDefView.cpp:256
STDMETHOD() QuerySupport(UINT *support) override
Definition: CDefView.cpp:4175
void OnDeactivate()
Definition: CDefView.cpp:2443
LRESULT OnEraseBackground(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:1680
void _MoveSelectionOnAutoArrange(POINT pt)
Definition: CDefView.cpp:4577
static INT CALLBACK ListViewCompareItems(LPARAM lParam1, LPARAM lParam2, LPARAM lpData)
Definition: CDefView.cpp:1260
STDMETHOD() GetDefaultSpacing(POINT *ppt) override
Definition: CDefView.cpp:3746
CLSID m_Category
Definition: CDefView.cpp:282
HRESULT FillArrangeAsMenu(HMENU hmenuArrange)
Definition: CDefView.cpp:1930
signed char m_SpecialFolder
Definition: CDefView.cpp:277
STDMETHOD() UpdateObject(PITEMID_CHILD pidl_old, PITEMID_CHILD pidl_new, UINT *item) override
Definition: CDefView.cpp:4030
STDMETHOD() GetItemSpacing(ITEMSPACING *spacing) override
Definition: CDefView.cpp:4151
static ATL::CWndClassInfo & GetWndClassInfo()
Definition: CDefView.cpp:511
SFGAOF GetItemAttributes(PCUITEMID_CHILD pidl, UINT Query)
Definition: CDefView.cpp:1326
CComPtr< IShellFolder2 > m_pSF2Parent
Definition: CDefView.cpp:235
LRESULT OnCommand(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:2549
HRESULT OpenSelectedItems(PCSTR pszVerb=NULL)
Definition: CDefView.cpp:2209
STDMETHOD() AddObject(PITEMID_CHILD pidl, UINT *item) override
Definition: CDefView.cpp:3975
STDMETHOD() GetDropPoint(POINT *pt) override
Definition: CDefView.cpp:4097
HICON m_hMyComputerIcon
Definition: CDefView.cpp:286
STDMETHOD() GetSelectedCount(UINT *count) override
Definition: CDefView.cpp:4050
STDMETHOD() GetFocusedItem(int *piItem) override
Definition: CDefView.cpp:3699
LRESULT OnDrawClipboard(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:3124
STDMETHOD() GetSpacing(POINT *ppt) override
Definition: CDefView.cpp:3724
LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:1654
STDMETHOD() CreateViewWindow(IShellView *psvPrevious, LPCFOLDERSETTINGS pfs, IShellBrowser *psb, RECT *prcView, HWND *phWnd) override
Definition: CDefView.cpp:3220
FOLDERVIEWMODE GetDefaultViewMode()
Definition: CDefView.cpp:3598
STDMETHOD() GetDragPoint(POINT *pt) override
Definition: CDefView.cpp:4088
BOOL m_bmenuBarInitialized
Definition: CDefView.cpp:250
HRESULT MapFolderColumnToListColumn(UINT FoldCol)
Definition: CDefView.cpp:1027
SFGAOF GetSelectionAttributes(SFGAOF Query)
Definition: CDefView.cpp:2139
PCUITEMID_CHILD _PidlByItem(int i)
Definition: CDefView.cpp:1338
UINT m_cidl
Definition: CDefView.cpp:252
void ColumnListChanged()
Definition: CDefView.cpp:1194
STDMETHOD() GetFolder(REFIID riid, void **ppv) override
Definition: CDefView.cpp:3652
STDMETHOD() Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut) override
Definition: CDefView.cpp:4208
UINT m_uState
Definition: CDefView.cpp:251
STDMETHOD() DragOver(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect) override
Definition: CDefView.cpp:4425
STDMETHOD() Rearrange(LPARAM sort) override
Definition: CDefView.cpp:3949
DWORD m_grfKeyState
Definition: CDefView.cpp:271
STDMETHOD() GetView(SHELLVIEWID *view_guid, ULONG view_type) override
Definition: CDefView.cpp:3809
STDMETHOD() QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT *pCmdText) override
Definition: CDefView.cpp:4187
HRESULT _GetSnapToGrid()
Definition: CDefView.cpp:3756
void LV_RefreshIcon(INT iItem)
Definition: CDefView.cpp:1497
HRESULT GetDefaultViewStream(DWORD Stgm, IStream **ppStream)
Definition: CDefView.cpp:3309
UINT GetSelections()
Definition: CDefView.cpp:2106
BOOL m_isEditing
Definition: CDefView.cpp:276
BOOLEAN LV_RenameItem(PCUITEMID_CHILD pidlOld, PCUITEMID_CHILD pidlNew)
Definition: CDefView.cpp:1424
STDMETHOD() GetCurrentInfo(LPFOLDERSETTINGS pfs) override
Definition: CDefView.cpp:3274
CComPtr< ICommDlgBrowser > m_pCommDlgBrowser
Definition: CDefView.cpp:239
STDMETHOD() GetCurrentViewMode(UINT *pViewMode) override
Definition: CDefView.cpp:3607
POINT m_ptLastMousePos
Definition: CDefView.cpp:269
STDMETHOD() RefreshObject(PITEMID_CHILD pidl, UINT *item) override
Definition: CDefView.cpp:4036
BOOL InitList()
Definition: CDefView.cpp:988
ULONG m_hNotify
Definition: CDefView.cpp:258
STDMETHOD() IsBkDropTarget(IDropTarget *drop_target) override
Definition: CDefView.cpp:4115
HRESULT MapListColumnToFolderColumn(UINT ListCol)
Definition: CDefView.cpp:1040
STDMETHOD() Refresh() override
Definition: CDefView.cpp:3208
HRESULT LoadViewState()
Definition: CDefView.cpp:3334
bool m_HasCutItems
Definition: CDefView.cpp:280
HRESULT GetDetailsByFolderColumn(PCUITEMID_CHILD pidl, UINT FoldCol, SHELLDETAILS &sd)
Definition: CDefView.cpp:1061
STDMETHOD() SelectAndPositionItems(UINT cidl, PCUITEMID_CHILD_ARRAY apidl, POINT *apt, DWORD dwFlags) override
Definition: CDefView.cpp:3793
HRESULT OnDefaultCommand()
Definition: CDefView.cpp:682
STDMETHOD() SetClipboard(BOOL move) override
Definition: CDefView.cpp:4121
void UpdateFolderViewFlags()
Definition: CDefView.cpp:3477
HRESULT FillViewMenu()
Definition: CDefView.cpp:1914
LONG m_iDragOverItem
Definition: CDefView.cpp:267
STDMETHOD() ItemCount(UINT uFlags, int *pcItems) override
Definition: CDefView.cpp:3673
virtual VOID OnFinalMessage(HWND) override
Definition: CDefView.cpp:1760
LRESULT OnGetShellBrowser(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:1748
STDMETHOD() MoveIcons(IDataObject *obj) override
Definition: CDefView.cpp:4103
STDMETHOD() GetWindow(HWND *lphwnd) override
Definition: CDefView.cpp:3146
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:3822
HMENU m_hMenuViewModes
Definition: CDefView.cpp:248
HACCEL m_hAccel
Definition: CDefView.cpp:259
STDMETHOD() GetArrangeParam(LPARAM *sort) override
Definition: CDefView.cpp:3955
LRESULT OnChangeNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:2924
virtual WNDPROC GetWindowProc() override
Definition: CDefView.cpp:524
STDMETHOD() Freeze(DWORD dwDrawAspect, LONG lindex, void *pvAspect, DWORD *pdwFreeze) override
Definition: CDefView.cpp:4720
STDMETHOD() GetColorSet(DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd, HDC hicTargetDev, LOGPALETTE **ppColorSet) override
Definition: CDefView.cpp:4714
STDMETHOD() HandleRename(LPCITEMIDLIST pidl) override
Definition: CDefView.cpp:3916
FOLDERSETTINGS m_FolderSettings
Definition: CDefView.cpp:245
STDMETHOD() DragEnter(IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect) override
Definition: CDefView.cpp:4406
static LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
Definition: CDefView.cpp:529
STDMETHOD() SetObjectCount(UINT count, UINT flags) override
Definition: CDefView.cpp:4024
STDMETHOD() GetObject(PITEMID_CHILD *pidl, UINT item) override
Definition: CDefView.cpp:3987
void UpdateStatusbarLocation()
Definition: CDefView.cpp:806
LRESULT OnNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:2658
STDMETHOD() EnableModeless(BOOL fEnable) override
Definition: CDefView.cpp:3179
CListView m_ListView
Definition: CDefView.cpp:243
BOOL _Sort(int Col=-1)
Definition: CDefView.cpp:1274
STDMETHOD() SetAdvise(DWORD aspects, DWORD advf, IAdviseSink *pAdvSink) override
Definition: CDefView.cpp:4732
LRESULT OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: CDefView.cpp:1765
BOOL LV_UpdateItem(INT nItem, PCUITEMID_CHILD pidl)
Definition: CDefView.cpp:1463
STDMETHOD() UIActivate(UINT uState) override
Definition: CDefView.cpp:3185
int LV_FindItemByPidl(PCUITEMID_CHILD pidl)
Definition: CDefView.cpp:1352
STDMETHOD() Item(int iItemIndex, PITEMID_CHILD *ppidl) override
Definition: CDefView.cpp:3660
HRESULT SelectAndPositionItem(int Idx, UINT fSVSI, POINT *ppt)
Definition: CDefView.cpp:3930
HRESULT LoadColumns(SIZE_T *pColList=NULL, UINT ColListCount=0)
Definition: CDefView.cpp:1129
void DoActivate(UINT uState)
Definition: CDefView.cpp:2454
STDMETHOD() Select(UINT flags) override
Definition: CDefView.cpp:4169
SFVM_CUSTOMVIEWINFO_DATA m_viewinfo_data
Definition: CDefView.cpp:284
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
unsigned int idx
Definition: utils.c:41
#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
int WINAPI lstrcmpiW(LPCWSTR str1, LPCWSTR str2)
Definition: locale.c:4265
static struct @513 sort
LPWSTR WINAPI PathFindExtensionW(const WCHAR *path)
Definition: path.c:1274
INT WINAPI DECLSPEC_HOTPATCH LoadStringW(HINSTANCE instance, UINT resource_id, LPWSTR buffer, INT buflen)
Definition: string.c:1220
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:1453
DWORD SHGetAttributes(_In_ IShellFolder *psf, _In_ LPCITEMIDLIST pidl, _In_ DWORD dwAttributes)
Definition: utils.cpp:448
EXTERN_C HRESULT WINAPI SHGetRealIDL(_In_ IShellFolder *psf, _In_ PCUITEMID_CHILD pidlSimple, _Outptr_ PITEMID_CHILD *ppidlReal)
Definition: utils.cpp:1643
static BOOL IsEqualPersistClassID(IPersist *pPersist, REFCLSID clsid)
Definition: utils.h:36
void WINAPI SHFree(LPVOID pv)
Definition: shellole.c:370
LPVOID WINAPI SHAlloc(SIZE_T len)
Definition: shellole.c:348
BOOL WINAPI IsOS(DWORD feature)
Definition: ordinal.c:4226
#define EnableModeless(type)
Definition: ordinal.c:3659
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:4708
HRESULT WINAPI IUnknown_SetSite(IUnknown *obj, IUnknown *site)
Definition: ordinal.c:1411
DWORD WINAPI SHGetValueW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData)
Definition: reg.c:1236
DWORD WINAPI SHAnsiToUnicode(LPCSTR lpSrcStr, LPWSTR lpDstStr, int iLen)
Definition: string.c:2673
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
#define FAILED_UNEXPECTEDLY
Definition: utils.cpp:30
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
return ret
Definition: mutex.c:146
#define _(op)
Definition: opcodes.c:24
#define L(x)
Definition: resources.c:13
#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()
UINT SHELL_GetIconUnderlineFlags()
Definition: general.cpp:134
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
#define DbgPrint
Definition: hal.h:12
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:1390
#define ss
Definition: i386-dis.c:441
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
LPCWSTR LPCWSTR LPCWSTR DWORD dwFlags
Definition: env.c:37
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 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
unsigned __int3264 UINT_PTR
Definition: mstsclib_h.h:274
_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:331
#define UNICODE_NULL
_In_ HBITMAP hbm
Definition: ntgdi.h:2776
_Out_ LPRECT prc
Definition: ntgdi.h:1658
#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:318
#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:446
LPITEMIDLIST WINAPI ILClone(LPCITEMIDLIST pidl)
Definition: pidl.c:238
void WINAPI ILFree(LPITEMIDLIST pidl)
Definition: pidl.c:1045
LPITEMIDLIST WINAPI ILFindLastID(LPCITEMIDLIST pidl)
Definition: pidl.c:199
BOOL WINAPI ILIsParent(LPCITEMIDLIST pidlParent, LPCITEMIDLIST pidlChild, BOOL bImmediate)
Definition: pidl.c:698
LPITEMIDLIST WINAPI ILCombine(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
Definition: pidl.c:817
BOOL WINAPI ILRemoveLastID(LPITEMIDLIST pidl)
Definition: pidl.c:222
BOOL _ILIsSpecialFolder(LPCITEMIDLIST pidl)
Definition: pidl.c:2120
BOOL _ILIsFolder(LPCITEMIDLIST pidl)
Definition: pidl.c:2138
BOOL WINAPI SHGetPathFromIDListW(LPCITEMIDLIST pidl, LPWSTR pszPath)
Definition: pidl.c:1490
DWORD _ILGetFileSize(LPCITEMIDLIST pidl, LPWSTR pOut, UINT uOutSize)
Definition: pidl.c:2513
BOOL WINAPI ILIsEqual(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
Definition: pidl.c:583
#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:4977
#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 LVS_EX_UNDERLINECOLD
Definition: commctrl.h:2746
#define DPA_GetPtrPtr(hdpa)
Definition: commctrl.h:4974
#define SB_SETTEXT
Definition: commctrl.h:1954
#define DPA_AppendPtr(hdpa, pitem)
Definition: commctrl.h:4975
#define DPA_GetPtrCount(hdpa)
Definition: commctrl.h:4972
#define SB_SETPARTS
Definition: commctrl.h:1959
#define LVN_GETDISPINFOW
Definition: commctrl.h:3159
#define LVS_EX_DOUBLEBUFFER
Definition: commctrl.h:2750
#define LVS_EX_UNDERLINEHOT
Definition: commctrl.h:2745
#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 LVKF_ALT
Definition: commctrl.h:3060
#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 ListView_CancelEditLabel(hwnd)
Definition: commctrl.h:3018
#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 S_EQUAL
Definition: shellutils.h:676
#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:628
#define SHCNE_DRIVEREMOVED
Definition: shlobj.h:1902
#define SFVM_UPDATINGOBJECT
Definition: shlobj.h:1338
#define SHCNE_RMDIR
Definition: shlobj.h:1899
#define SFVM_DEFVIEWMODE
Definition: shlobj.h:1323
#define SHCNE_DELETE
Definition: shlobj.h:1897
#define SHCNE_MKDIR
Definition: shlobj.h:1898
#define SFVM_WINDOWCREATED
Definition: shlobj.h:1313
#define SHCNE_UPDATEITEM
Definition: shlobj.h:1908
#define SHCNE_RENAMEITEM
Definition: shlobj.h:1895
#define SSF_DOUBLECLICKINWEBVIEW
Definition: shlobj.h:1615
#define SHCNE_UPDATEDIR
Definition: shlobj.h:1907
#define SHCNE_MEDIAINSERTED
Definition: shlobj.h:1900
#define SHCNE_UPDATEIMAGE
Definition: shlobj.h:1910
#define SFVM_SIZE
Definition: shlobj.h:1344
#define SSF_WIN95CLASSIC
Definition: shlobj.h:1618
#define SHCNE_CREATE
Definition: shlobj.h:1896
#define FCIDM_MENU_VIEW_SEP_OPTIONS
Definition: shlobj.h:638
#define SHCNE_RENAMEFOLDER
Definition: shlobj.h:1912
#define SHCNRF_NewDelivery
Definition: shlobj.h:1944
#define MM_SUBMENUSHAVEIDS
Definition: shlobj.h:2535
#define MM_DONTREMOVESEPS
Definition: shlobj.h:2536
#define SHCNRF_ShellLevel
Definition: shlobj.h:1942
#define SHCNE_MEDIAREMOVED
Definition: shlobj.h:1901
#define FCIDM_MENU_FILE
Definition: shlobj.h:635
#define SHCNE_EXTENDED_EVENT
Definition: shlobj.h:1915
#define SHCNE_DRIVEADD
Definition: shlobj.h:1903
#define SHCNE_ASSOCCHANGED
Definition: shlobj.h:1916
#define CSIDL_DESKTOP
Definition: shlobj.h:2179
#define CSIDL_NETWORK
Definition: shlobj.h:2196
#define SFVM_COLUMNCLICK
Definition: shlobj.h:1320
#define SFVM_ADDPROPERTYPAGES
Definition: shlobj.h:1340
#define FCIDM_SHVIEWFIRST
Definition: shlobj.h:588
#define FCIDM_MENU_VIEW
Definition: shlobj.h:637
#define SHCNRF_InterruptLevel
Definition: shlobj.h:1941
#define SHCNE_ATTRIBUTES
Definition: shlobj.h:1906
#define SHCNE_ALLEVENTS
Definition: shlobj.h:1919
#define MM_ADDSEPARATOR
Definition: shlobj.h:2534
#define SSF_SHOWSUPERHIDDEN
Definition: shlobj.h:1626
#define SFVM_HWNDMAIN
Definition: shlobj.h:1339
#define SHCNE_FREESPACE
Definition: shlobj.h:1913
#define SFVM_FSNOTIFY
Definition: shlobj.h:1312
#define SSF_SHOWALLOBJECTS
Definition: shlobj.h:1610
#define FCIDM_MENU_EDIT
Definition: shlobj.h:636
@ REST_NOVIEWCONTEXTMENU
Definition: shlobj.h:1674
#define SFVM_QUERYFSNOTIFY
Definition: shlobj.h:1321
#define SFVM_GETNOTIFY
Definition: shlobj.h:1342
#define CSIDL_BITBUCKET
Definition: shlobj.h:2189
#define FCIDM_SHVIEWLAST
Definition: shlobj.h:619
#define FCIDM_SHVIEW_DESELECTALL
Definition: shlobj_undoc.h:66
#define DVCMDID_SET_DEFAULTFOLDER_SETTINGS
Definition: shlobj_undoc.h:115
#define DVCMDID_RESET_DEFAULTFOLDER_SETTINGS
Definition: shlobj_undoc.h:116
#define OS_SERVERADMINUI
Definition: shlwapi.h:2106
#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:166
#define FCIDM_SHVIEW_AUTOARRANGE
Definition: shresdef.h:879
#define FCIDM_SHVIEW_SELECTALL
Definition: shresdef.h:870
#define IDS_OBJECTS_SELECTED
Definition: shresdef.h:287
#define FCIDM_SHVIEW_CUT
Definition: shresdef.h:863
#define FCIDM_SHVIEW_LISTVIEW
Definition: shresdef.h:875
#define FCIDM_SHVIEW_UNDO
Definition: shresdef.h:866
#define FCIDM_SHVIEW_ALIGNTOGRID
Definition: shresdef.h:881
#define FCIDM_SHVIEW_COPY
Definition: shresdef.h:864
#define IDM_DVSELECT
Definition: shresdef.h:914
#define FCIDM_SHVIEW_TILEVIEW
Definition: shresdef.h:877
#define FCIDM_SHVIEW_BIGICON
Definition: shresdef.h:873
#define IDS_MYCOMPUTER
Definition: shresdef.h:283
#define FCIDM_SHVIEW_INSERTLINK
Definition: shresdef.h:867
#define FCIDM_SHVIEW_REFRESH
Definition: shresdef.h:889
#define IDI_SHELL_COMPUTER_DESKTOP
Definition: shresdef.h:680
#define FCIDM_SHVIEW_NEWFOLDER
Definition: shresdef.h:885
#define FCIDM_SHVIEW_SMALLICON
Definition: shresdef.h:874
#define FCIDM_TB_SMALLICON
Definition: shresdef.h:893
#define FCIDM_SHVIEW_PROPERTIES
Definition: shresdef.h:862
#define FCIDM_SHVIEW_SNAPTOGRID
Definition: shresdef.h:880
#define FCIDM_SHVIEW_VIEW
Definition: shresdef.h:858
#define FCIDM_SHVIEW_COPYTO
Definition: shresdef.h:868
#define FCIDM_SHVIEW_MOVETO
Definition: shresdef.h:869
#define FCIDM_SHVIEW_DELETE
Definition: shresdef.h:860
#define FCIDM_SHVIEW_RENAME
Definition: shresdef.h:861
#define IDS_OBJECTS
Definition: shresdef.h:286
#define FCIDM_TB_REPORTVIEW
Definition: shresdef.h:894
#define FCIDM_SHVIEW_CREATELINK
Definition: shresdef.h:859
#define FCIDM_SHVIEW_REPORTVIEW
Definition: shresdef.h:876
#define IDA_SHELLVIEW
Definition: shresdef.h:26
#define FCIDM_SHVIEW_INVERTSELECTION
Definition: shresdef.h:871
#define FCIDM_SHVIEW_ARRANGE
Definition: shresdef.h:857
#define FCIDM_SHVIEW_INSERT
Definition: shresdef.h:865
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:137
CComPtr< IContextMenu > & m_pCM
Definition: CDefView.cpp:136
MenuCleanup(CComPtr< IContextMenu > &pCM, HMENU &menu)
Definition: CDefView.cpp:139
FOLDERSETTINGS FolderSettings
Definition: CDefView.cpp:101
static const UINT SIG
Definition: CDefView.cpp:96
static const UINT VALIDFWF
Definition: CDefView.cpp:100
static const UINT SIG
Definition: CDefView.cpp:88
UINT Columns[MAXCOUNT]
Definition: CDefView.cpp:91
BOOL fShowSuperHidden
Definition: shlobj.h:1562
BOOL fShowAllObjects
Definition: shlobj.h:1546
Definition: bl.h:1331
Definition: dpa.c:49
Definition: scsiwmi.h:51
IShellFolderViewCB * psfvcb
Definition: shlobj.h:1365
IShellView * psvOuter
Definition: shlobj.h:1364
UINT cbSize
Definition: shlobj.h:1362
IShellFolder * pshf
Definition: shlobj.h:1363
PCIDLIST_ABSOLUTE pidl
Definition: shlobj.h:1891
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:3370
LPWSTR dwTypeData
Definition: winuser.h:3371
UINT message
Definition: winuser.h:3217
WPARAM wParam
Definition: winuser.h:3218
UINT code
Definition: winuser.h:3261
HWND hwndFrom
Definition: winuser.h:3259
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
uint16_t * PWSTR
Definition: typedefs.h:56
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
const char * PCSTR
Definition: typedefs.h:52
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:242
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
_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:1753
_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:4914
BOOL WINAPI DeleteDC(_In_ HDC)
#define HKEY_CURRENT_USER
Definition: winreg.h:11
HWND WINAPI GetFocus(void)
Definition: window.c:1863
int WINAPI ReleaseDC(_In_opt_ HWND, _In_ HDC)
#define WM_ERASEBKGND
Definition: winuser.h:1653
#define MK_RBUTTON
Definition: winuser.h:2404
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:1771
#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:1772
#define TPM_RIGHTBUTTON
Definition: winuser.h:2416
BOOL WINAPI GetWindowRect(_In_ HWND, _Out_ LPRECT)
#define WM_CREATE
Definition: winuser.h:1636
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:1897
#define WM_SIZE
Definition: winuser.h:1639
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:1768
#define MF_STRING
Definition: winuser.h:138
#define IDC_ARROW
Definition: winuser.h:695
#define WM_KEYFIRST
Definition: winuser.h:1742
#define VK_CONTROL
Definition: winuser.h:2239
#define MFS_DISABLED
Definition: winuser.h:760
#define WM_SETFOCUS
Definition: winuser.h:1641
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)
#define SPI_GETICONTITLELOGFONT
Definition: winuser.h:1391
BOOL WINAPI MessageBeep(_In_ UINT uType)
#define WM_SYSCOLORCHANGE
Definition: winuser.h:1654
BOOL WINAPI TrackPopupMenuEx(_In_ HMENU, _In_ UINT, _In_ int, _In_ int, _In_ HWND, _In_opt_ LPTPMPARAMS)
#define WM_CHANGECBCHAIN
Definition: winuser.h:1902
#define WM_GETFONT
Definition: winuser.h:1679
BOOL WINAPI ClientToScreen(_In_ HWND, _Inout_ LPPOINT)
#define MF_UNCHECKED
Definition: winuser.h:204
#define TPM_TOPALIGN
Definition: winuser.h:2419
#define WM_DRAWITEM
Definition: winuser.h:1673
DWORD WINAPI CheckMenuItem(_In_ HMENU, _In_ UINT, _In_ UINT)
#define WM_NCCREATE
Definition: winuser.h:1711
#define MIIM_STATE
Definition: winuser.h:732
#define WM_ACTIVATE
Definition: winuser.h:1640
#define WM_SHOWWINDOW
Definition: winuser.h:1656
#define WM_SETTINGCHANGE
Definition: winuser.h:1657
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:1774
#define MF_ENABLED
Definition: winuser.h:128
#define MF_SEPARATOR
Definition: winuser.h:137
#define EM_SETLIMITTEXT
Definition: winuser.h:2040
#define COLOR_DESKTOP
Definition: winuser.h:925
#define TPM_LEFTALIGN
Definition: winuser.h:2413
#define MF_BYPOSITION
Definition: winuser.h:203
BOOL WINAPI RemoveMenu(_In_ HMENU, _In_ UINT, _In_ UINT)
struct tagNMHDR * LPNMHDR
#define HTCLIENT
Definition: winuser.h:2511
#define SWP_SHOWWINDOW
Definition: winuser.h:1259
#define SendMessage
Definition: winuser.h:5954
#define LoadCursor
Definition: winuser.h:5923
WNDCLASSEXA WNDCLASSEX
Definition: winuser.h:5830
#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:2047
#define TPM_LEFTBUTTON
Definition: winuser.h:2415
#define WM_MEASUREITEM
Definition: winuser.h:1674
#define PostMessage
Definition: winuser.h:5943
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:1664
#define MK_LBUTTON
Definition: winuser.h:2403
#define VK_SHIFT
Definition: winuser.h:2238
#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:1637
#define WS_EX_CLIENTEDGE
Definition: winuser.h:384
#define SetWindowText
Definition: winuser.h:5968
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:3008
#define TPM_RETURNCMD
Definition: winuser.h:2423
#define GWL_STYLE
Definition: winuser.h:863
#define CS_PARENTDC
Definition: winuser.h:664
#define TranslateAccelerator
Definition: winuser.h:5971
#define WM_KEYLAST
Definition: winuser.h:1756
BOOL WINAPI EnableMenuItem(_In_ HMENU, _In_ UINT, _In_ UINT)
#define WM_KILLFOCUS
Definition: winuser.h:1642
HICON WINAPI LoadIconW(_In_opt_ HINSTANCE hInstance, _In_ LPCWSTR lpIconName)
Definition: cursoricon.c:2427
#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:1717
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