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