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