Mirrors/PowerToys
1
0
Fork 0
mirror of https://github.com/microsoft/PowerToys.git synced 2026-04-09 12:46:47 +02:00
Code Issues Packages Projects Releases Wiki Activity

[PowerRename] Add Filtering Feature (#6017)

Browse Source 
* Implement basic functionality

* Change approach.
move filter controls to manager
edit redrawing to always work with new GetVisibleItemCount() and GetVisibleItemByIndex() calls

* Fix performance issues. Some refactoring.

* Handle toggleAll correctly

* Handle dangling elements when filter is on

Make an item visible if it has at least one visible subitem

* Support filtering for selected and shouldRename

* Refactor for readability, remove useless member from PowerRenameUI

* Change variable names in PowerRenameUI for clarity

Use wrapper function RedrawItems() and SetItemCount() for consistency

* Handle result value properly in getVisibleItemByIndex()

* Add FlagsApplicable filter

* Add visual indication of filters

* Improve performance

Check if no filter is selected
Call SetItemCount() only when necessary

* Refactor for readability

* Get lock in setVisible()

* Change function names to camel case

* Change function names to start with uppercase

* Change filter behaviour when search area is empty

Show all elements when search area is empty and ShouldRename filter is selected
Avoid warnings

* Resolve conflicts
This commit is contained in:
Mehmet Murat Akburak
2020-08-25 08:22:05 +03:00
committed by GitHub
parent 3ede1a0b53
commit d3b80b26e3
14 changed files with 460 additions and 199 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/modules/powerrename/lib/Helpers.cpp
View File

@@ -307,21 +307,21 @@ HRESULT _ParseEnumItems(_In_ IEnumShellItems* pesi, _In_ IPowerRenameManager* ps
while ((S_OK == pesi->Next(1, &spsi, &celtFetched)) && (SUCCEEDED(hr)))
{
CComPtr<IPowerRenameItemFactory> spsrif;
hr = psrm->get_renameItemFactory(&spsrif);
hr = psrm->GetRenameItemFactory(&spsrif);
if (SUCCEEDED(hr))
{
CComPtr<IPowerRenameItem> spNewItem;
hr = spsrif->Create(spsi, &spNewItem);
if (SUCCEEDED(hr))
{
spNewItem->put_depth(depth);
spNewItem->PutDepth(depth);
hr = psrm->AddItem(spNewItem);
}
if (SUCCEEDED(hr))
{
bool isFolder = false;
if (SUCCEEDED(spNewItem->get_isFolder(&isFolder)) && isFolder)
if (SUCCEEDED(spNewItem->GetIsFolder(&isFolder)) && isFolder)
{
// Bind to the IShellItem for the IEnumShellItems interface
CComPtr<IEnumShellItems> spesiNext;

66
src/modules/powerrename/lib/PowerRenameInterfaces.h
View File

@@ -17,6 +17,14 @@ enum PowerRenameFlags
Titlecase = 0x800
};
enum PowerRenameFilters
{
None = 1,
Selected = 2,
FlagsApplicable = 3,
ShouldRename = 4,
};
interface __declspec(uuid("3ECBA62B-E0F0-4472-AA2E-DEE7A1AA46B9")) IPowerRenameRegExEvents : public IUnknown
{
public:
@@ -30,33 +38,34 @@ interface __declspec(uuid("E3ED45B5-9CE0-47E2-A595-67EB950B9B72")) IPowerRenameR
public:
IFACEMETHOD(Advise)(_In_ IPowerRenameRegExEvents* regExEvents, _Out_ DWORD* cookie) = 0;
IFACEMETHOD(UnAdvise)(_In_ DWORD cookie) = 0;
IFACEMETHOD(get_searchTerm)(_Outptr_ PWSTR* searchTerm) = 0;
IFACEMETHOD(put_searchTerm)(_In_ PCWSTR searchTerm) = 0;
IFACEMETHOD(get_replaceTerm)(_Outptr_ PWSTR* replaceTerm) = 0;
IFACEMETHOD(put_replaceTerm)(_In_ PCWSTR replaceTerm) = 0;
IFACEMETHOD(get_flags)(_Out_ DWORD* flags) = 0;
IFACEMETHOD(put_flags)(_In_ DWORD flags) = 0;
IFACEMETHOD(GetSearchTerm)(_Outptr_ PWSTR* searchTerm) = 0;
IFACEMETHOD(PutSearchTerm)(_In_ PCWSTR searchTerm) = 0;
IFACEMETHOD(GetReplaceTerm)(_Outptr_ PWSTR* replaceTerm) = 0;
IFACEMETHOD(PutReplaceTerm)(_In_ PCWSTR replaceTerm) = 0;
IFACEMETHOD(GetFlags)(_Out_ DWORD* flags) = 0;
IFACEMETHOD(PutFlags)(_In_ DWORD flags) = 0;
IFACEMETHOD(Replace)(_In_ PCWSTR source, _Outptr_ PWSTR* result) = 0;
};
interface __declspec(uuid("C7F59201-4DE1-4855-A3A2-26FC3279C8A5")) IPowerRenameItem : public IUnknown
{
public:
IFACEMETHOD(get_path)(_Outptr_ PWSTR* path) = 0;
IFACEMETHOD(get_date)(_Outptr_ SYSTEMTIME* date) = 0;
IFACEMETHOD(get_shellItem)(_Outptr_ IShellItem** ppsi) = 0;
IFACEMETHOD(get_originalName)(_Outptr_ PWSTR* originalName) = 0;
IFACEMETHOD(get_newName)(_Outptr_ PWSTR* newName) = 0;
IFACEMETHOD(put_newName)(_In_opt_ PCWSTR newName) = 0;
IFACEMETHOD(get_isFolder)(_Out_ bool* isFolder) = 0;
IFACEMETHOD(get_isSubFolderContent)(_Out_ bool* isSubFolderContent) = 0;
IFACEMETHOD(get_selected)(_Out_ bool* selected) = 0;
IFACEMETHOD(put_selected)(_In_ bool selected) = 0;
IFACEMETHOD(get_id)(_Out_ int *id) = 0;
IFACEMETHOD(get_iconIndex)(_Out_ int* iconIndex) = 0;
IFACEMETHOD(get_depth)(_Out_ UINT* depth) = 0;
IFACEMETHOD(put_depth)(_In_ int depth) = 0;
IFACEMETHOD(GetPath)(_Outptr_ PWSTR* path) = 0;
IFACEMETHOD(GetDate)(_Outptr_ SYSTEMTIME* date) = 0;
IFACEMETHOD(GetShellItem)(_Outptr_ IShellItem** ppsi) = 0;
IFACEMETHOD(GetOriginalName)(_Outptr_ PWSTR* originalName) = 0;
IFACEMETHOD(GetNewName)(_Outptr_ PWSTR* newName) = 0;
IFACEMETHOD(PutNewName)(_In_opt_ PCWSTR newName) = 0;
IFACEMETHOD(GetIsFolder)(_Out_ bool* isFolder) = 0;
IFACEMETHOD(GetIsSubFolderContent)(_Out_ bool* isSubFolderContent) = 0;
IFACEMETHOD(GetSelected)(_Out_ bool* selected) = 0;
IFACEMETHOD(PutSelected)(_In_ bool selected) = 0;
IFACEMETHOD(GetId)(_Out_ int *id) = 0;
IFACEMETHOD(GetIconIndex)(_Out_ int* iconIndex) = 0;
IFACEMETHOD(GetDepth)(_Out_ UINT* depth) = 0;
IFACEMETHOD(PutDepth)(_In_ int depth) = 0;
IFACEMETHOD(ShouldRenameItem)(_In_ DWORD flags, _Out_ bool* shouldRename) = 0;
IFACEMETHOD(IsItemVisible)(_In_ DWORD filter, _In_ DWORD flags, _Out_ bool* isItemVisible) = 0;
IFACEMETHOD(Reset)() = 0;
};
@@ -91,16 +100,21 @@ public:
IFACEMETHOD(Rename)(_In_ HWND hwndParent) = 0;
IFACEMETHOD(AddItem)(_In_ IPowerRenameItem* pItem) = 0;
IFACEMETHOD(GetItemByIndex)(_In_ UINT index, _COM_Outptr_ IPowerRenameItem** ppItem) = 0;
IFACEMETHOD(GetVisibleItemByIndex)(_In_ UINT index, _COM_Outptr_ IPowerRenameItem ** ppItem) = 0;
IFACEMETHOD(SetVisible)() = 0;
IFACEMETHOD(GetItemById)(_In_ int id, _COM_Outptr_ IPowerRenameItem** ppItem) = 0;
IFACEMETHOD(GetItemCount)(_Out_ UINT* count) = 0;
IFACEMETHOD(GetVisibleItemCount)(_Out_ UINT* count) = 0;
IFACEMETHOD(GetSelectedItemCount)(_Out_ UINT* count) = 0;
IFACEMETHOD(GetRenameItemCount)(_Out_ UINT* count) = 0;
IFACEMETHOD(get_flags)(_Out_ DWORD* flags) = 0;
IFACEMETHOD(put_flags)(_In_ DWORD flags) = 0;
IFACEMETHOD(get_renameRegEx)(_COM_Outptr_ IPowerRenameRegEx** ppRegEx) = 0;
IFACEMETHOD(put_renameRegEx)(_In_ IPowerRenameRegEx* pRegEx) = 0;
IFACEMETHOD(get_renameItemFactory)(_COM_Outptr_ IPowerRenameItemFactory** ppItemFactory) = 0;
IFACEMETHOD(put_renameItemFactory)(_In_ IPowerRenameItemFactory* pItemFactory) = 0;
IFACEMETHOD(GetFlags)(_Out_ DWORD* flags) = 0;
IFACEMETHOD(PutFlags)(_In_ DWORD flags) = 0;
IFACEMETHOD(GetFilter)(_Out_ DWORD * filter) = 0;
IFACEMETHOD(SwitchFilter)(_In_ int columnNumber) = 0;
IFACEMETHOD(GetRenameRegEx)(_COM_Outptr_ IPowerRenameRegEx** ppRegEx) = 0;
IFACEMETHOD(PutRenameRegEx)(_In_ IPowerRenameRegEx* pRegEx) = 0;
IFACEMETHOD(GetRenameItemFactory)(_COM_Outptr_ IPowerRenameItemFactory** ppItemFactory) = 0;
IFACEMETHOD(PutRenameItemFactory)(_In_ IPowerRenameItemFactory* pItemFactory) = 0;
};
interface __declspec(uuid("E6679DEB-460D-42C1-A7A8-E25897061C99")) IPowerRenameUI : public IUnknown

50
src/modules/powerrename/lib/PowerRenameItem.cpp
View File

@@ -30,7 +30,7 @@ IFACEMETHODIMP CPowerRenameItem::QueryInterface(_In_ REFIID riid, _Outptr_ void*
return QISearch(this, qit, riid, ppv);
}
IFACEMETHODIMP CPowerRenameItem::get_path(_Outptr_ PWSTR* path)
IFACEMETHODIMP CPowerRenameItem::GetPath(_Outptr_ PWSTR* path)
{
*path = nullptr;
CSRWSharedAutoLock lock(&m_lock);
@@ -42,7 +42,7 @@ IFACEMETHODIMP CPowerRenameItem::get_path(_Outptr_ PWSTR* path)
return hr;
}
IFACEMETHODIMP CPowerRenameItem::get_date(_Outptr_ SYSTEMTIME* date)
IFACEMETHODIMP CPowerRenameItem::GetDate(_Outptr_ SYSTEMTIME* date)
{
CSRWSharedAutoLock lock(&m_lock);
HRESULT hr = m_isDateParsed ? S_OK : E_FAIL ;
@@ -72,12 +72,12 @@ IFACEMETHODIMP CPowerRenameItem::get_date(_Outptr_ SYSTEMTIME* date)
return hr;
}
IFACEMETHODIMP CPowerRenameItem::get_shellItem(_Outptr_ IShellItem** ppsi)
IFACEMETHODIMP CPowerRenameItem::GetShellItem(_Outptr_ IShellItem** ppsi)
{
return SHCreateItemFromParsingName(m_path, nullptr, IID_PPV_ARGS(ppsi));
}
IFACEMETHODIMP CPowerRenameItem::get_originalName(_Outptr_ PWSTR* originalName)
IFACEMETHODIMP CPowerRenameItem::GetOriginalName(_Outptr_ PWSTR* originalName)
{
CSRWSharedAutoLock lock(&m_lock);
HRESULT hr = m_originalName ? S_OK : E_FAIL;
@@ -88,7 +88,7 @@ IFACEMETHODIMP CPowerRenameItem::get_originalName(_Outptr_ PWSTR* originalName)
return hr;
}
IFACEMETHODIMP CPowerRenameItem::put_newName(_In_opt_ PCWSTR newName)
IFACEMETHODIMP CPowerRenameItem::PutNewName(_In_opt_ PCWSTR newName)
{
CSRWSharedAutoLock lock(&m_lock);
CoTaskMemFree(m_newName);
@@ -101,7 +101,7 @@ IFACEMETHODIMP CPowerRenameItem::put_newName(_In_opt_ PCWSTR newName)
return hr;
}
IFACEMETHODIMP CPowerRenameItem::get_newName(_Outptr_ PWSTR* newName)
IFACEMETHODIMP CPowerRenameItem::GetNewName(_Outptr_ PWSTR* newName)
{
CSRWSharedAutoLock lock(&m_lock);
HRESULT hr = m_newName ? S_OK : E_FAIL;
@@ -112,42 +112,42 @@ IFACEMETHODIMP CPowerRenameItem::get_newName(_Outptr_ PWSTR* newName)
return hr;
}
IFACEMETHODIMP CPowerRenameItem::get_isFolder(_Out_ bool* isFolder)
IFACEMETHODIMP CPowerRenameItem::GetIsFolder(_Out_ bool* isFolder)
{
CSRWSharedAutoLock lock(&m_lock);
*isFolder = m_isFolder;
return S_OK;
}
IFACEMETHODIMP CPowerRenameItem::get_isSubFolderContent(_Out_ bool* isSubFolderContent)
IFACEMETHODIMP CPowerRenameItem::GetIsSubFolderContent(_Out_ bool* isSubFolderContent)
{
CSRWSharedAutoLock lock(&m_lock);
*isSubFolderContent = m_depth > 0;
return S_OK;
}
IFACEMETHODIMP CPowerRenameItem::get_selected(_Out_ bool* selected)
IFACEMETHODIMP CPowerRenameItem::GetSelected(_Out_ bool* selected)
{
CSRWSharedAutoLock lock(&m_lock);
*selected = m_selected;
return S_OK;
}
IFACEMETHODIMP CPowerRenameItem::put_selected(_In_ bool selected)
IFACEMETHODIMP CPowerRenameItem::PutSelected(_In_ bool selected)
{
CSRWSharedAutoLock lock(&m_lock);
m_selected = selected;
return S_OK;
}
IFACEMETHODIMP CPowerRenameItem::get_id(_Out_ int* id)
IFACEMETHODIMP CPowerRenameItem::GetId(_Out_ int* id)
{
CSRWSharedAutoLock lock(&m_lock);
*id = m_id;
return S_OK;
}
IFACEMETHODIMP CPowerRenameItem::get_iconIndex(_Out_ int* iconIndex)
IFACEMETHODIMP CPowerRenameItem::GetIconIndex(_Out_ int* iconIndex)
{
if (m_iconIndex == -1)
{
@@ -157,13 +157,13 @@ IFACEMETHODIMP CPowerRenameItem::get_iconIndex(_Out_ int* iconIndex)
return S_OK;
}
IFACEMETHODIMP CPowerRenameItem::get_depth(_Out_ UINT* depth)
IFACEMETHODIMP CPowerRenameItem::GetDepth(_Out_ UINT* depth)
{
*depth = m_depth;
return S_OK;
}
IFACEMETHODIMP CPowerRenameItem::put_depth(_In_ int depth)
IFACEMETHODIMP CPowerRenameItem::PutDepth(_In_ int depth)
{
m_depth = depth;
return S_OK;
@@ -179,7 +179,29 @@ IFACEMETHODIMP CPowerRenameItem::ShouldRenameItem(_In_ DWORD flags, _Out_ bool*
bool excludeBecauseSubFolderContent = (m_depth > 0 && (flags & PowerRenameFlags::ExcludeSubfolders));
*shouldRename = (m_selected && m_canRename && hasChanged && !excludeBecauseFile &&
!excludeBecauseFolder && !excludeBecauseSubFolderContent);
return S_OK;
}
IFACEMETHODIMP CPowerRenameItem::IsItemVisible(_In_ DWORD filter, _In_ DWORD flags, _Out_ bool* isItemVisible)
{
bool shouldRenameItem = false;
switch (filter)
{
case PowerRenameFilters::None:
*isItemVisible = true;
break;
case PowerRenameFilters::Selected:
GetSelected(isItemVisible);
break;
case PowerRenameFilters::FlagsApplicable:
*isItemVisible = !((m_isFolder && (flags & PowerRenameFlags::ExcludeFolders)) ||
(!m_isFolder && (flags & PowerRenameFlags::ExcludeFiles)) ||
(m_depth > 0 && (flags & PowerRenameFlags::ExcludeSubfolders)));
break;
case PowerRenameFilters::ShouldRename:
ShouldRenameItem(flags, isItemVisible);
break;
}
return S_OK;
}

29
src/modules/powerrename/lib/PowerRenameItem.h
View File

@@ -14,22 +14,23 @@ public:
IFACEMETHODIMP_(ULONG) Release();
// IPowerRenameItem
IFACEMETHODIMP get_path(_Outptr_ PWSTR* path);
IFACEMETHODIMP get_date(_Outptr_ SYSTEMTIME* date);
IFACEMETHODIMP get_shellItem(_Outptr_ IShellItem** ppsi);
IFACEMETHODIMP get_originalName(_Outptr_ PWSTR* originalName);
IFACEMETHODIMP put_newName(_In_opt_ PCWSTR newName);
IFACEMETHODIMP get_newName(_Outptr_ PWSTR* newName);
IFACEMETHODIMP get_isFolder(_Out_ bool* isFolder);
IFACEMETHODIMP get_isSubFolderContent(_Out_ bool* isSubFolderContent);
IFACEMETHODIMP get_selected(_Out_ bool* selected);
IFACEMETHODIMP put_selected(_In_ bool selected);
IFACEMETHODIMP get_id(_Out_ int* id);
IFACEMETHODIMP get_iconIndex(_Out_ int* iconIndex);
IFACEMETHODIMP get_depth(_Out_ UINT* depth);
IFACEMETHODIMP put_depth(_In_ int depth);
IFACEMETHODIMP GetPath(_Outptr_ PWSTR* path);
IFACEMETHODIMP GetDate(_Outptr_ SYSTEMTIME* date);
IFACEMETHODIMP GetShellItem(_Outptr_ IShellItem** ppsi);
IFACEMETHODIMP GetOriginalName(_Outptr_ PWSTR* originalName);
IFACEMETHODIMP PutNewName(_In_opt_ PCWSTR newName);
IFACEMETHODIMP GetNewName(_Outptr_ PWSTR* newName);
IFACEMETHODIMP GetIsFolder(_Out_ bool* isFolder);
IFACEMETHODIMP GetIsSubFolderContent(_Out_ bool* isSubFolderContent);
IFACEMETHODIMP GetSelected(_Out_ bool* selected);
IFACEMETHODIMP PutSelected(_In_ bool selected);
IFACEMETHODIMP GetId(_Out_ int* id);
IFACEMETHODIMP GetIconIndex(_Out_ int* iconIndex);
IFACEMETHODIMP GetDepth(_Out_ UINT* depth);
IFACEMETHODIMP PutDepth(_In_ int depth);
IFACEMETHODIMP Reset();
IFACEMETHODIMP ShouldRenameItem(_In_ DWORD flags, _Out_ bool* shouldRename);
IFACEMETHODIMP IsItemVisible(_In_ DWORD filter, _In_ DWORD flags, _Out_ bool* isItemVisible);
// IPowerRenameItemFactory
IFACEMETHODIMP Create(_In_ IShellItem* psi, _Outptr_ IPowerRenameItem** ppItem)

189
src/modules/powerrename/lib/PowerRenameManager.cpp
View File

@@ -117,11 +117,12 @@ IFACEMETHODIMP CPowerRenameManager::AddItem(_In_ IPowerRenameItem* pItem)
{
CSRWExclusiveAutoLock lock(&m_lockItems);
int id = 0;
pItem->get_id(&id);
pItem->GetId(&id);
// Verify the item isn't already added
if (m_renameItems.find(id) == m_renameItems.end())
{
m_renameItems[id] = pItem;
m_isVisible.push_back(true);
pItem->AddRef();
hr = S_OK;
}
@@ -152,6 +153,39 @@ IFACEMETHODIMP CPowerRenameManager::GetItemByIndex(_In_ UINT index, _COM_Outptr_
return hr;
}
IFACEMETHODIMP CPowerRenameManager::GetVisibleItemByIndex(_In_ UINT index, _COM_Outptr_ IPowerRenameItem** ppItem)
{
*ppItem = nullptr;
CSRWSharedAutoLock lock(&m_lockItems);
UINT count = 0;
HRESULT hr = E_FAIL;
if (m_filter == PowerRenameFilters::None)
{
hr = GetItemByIndex(index, ppItem);
}
else if (SUCCEEDED(GetVisibleItemCount(&count)) && index < count)
{
UINT realIndex = 0;
int visibleIndex = -1;
for (size_t i = 0; i < m_isVisible.size(); i++)
{
if (m_isVisible[i])
{
visibleIndex++;
}
if (visibleIndex == index)
{
realIndex = static_cast<UINT>(i);
break;
}
}
hr = GetItemByIndex(realIndex, ppItem);
}
return hr;
}
IFACEMETHODIMP CPowerRenameManager::GetItemById(_In_ int id, _COM_Outptr_ IPowerRenameItem** ppItem)
{
*ppItem = nullptr;
@@ -177,6 +211,72 @@ IFACEMETHODIMP CPowerRenameManager::GetItemCount(_Out_ UINT* count)
return S_OK;
}
IFACEMETHODIMP CPowerRenameManager::SetVisible()
{
CSRWSharedAutoLock lock(&m_lockItems);
HRESULT hr = E_FAIL;
UINT lastVisibleDepth = 0;
size_t i = m_isVisible.size() - 1;
PWSTR searchTerm = nullptr;
for (auto rit = m_renameItems.rbegin(); rit != m_renameItems.rend(); ++rit, --i)
{
bool isVisible = false;
if (m_filter == PowerRenameFilters::ShouldRename &&
(FAILED(m_spRegEx->GetSearchTerm(&searchTerm)) || searchTerm && wcslen(searchTerm) == 0))
{
isVisible = true;
}
else
{
rit->second->IsItemVisible(m_filter, m_flags, &isVisible);
}
UINT itemDepth = 0;
rit->second->GetDepth(&itemDepth);
//Make an item visible if it has a least one visible subitem
if (isVisible)
{
lastVisibleDepth = itemDepth;
}
else if (lastVisibleDepth == itemDepth+1)
{
isVisible = true;
lastVisibleDepth = itemDepth;
}
m_isVisible[i] = isVisible;
hr = S_OK;
}
return hr;
}
IFACEMETHODIMP CPowerRenameManager::GetVisibleItemCount(_Out_ UINT* count)
{
*count = 0;
CSRWSharedAutoLock lock(&m_lockItems);
if (m_filter != PowerRenameFilters::None)
{
SetVisible();
for (size_t i = 0; i < m_isVisible.size(); i++)
{
if (m_isVisible[i])
{
(*count)++;
}
}
}
else
{
GetItemCount(count);
}
return S_OK;
}
IFACEMETHODIMP CPowerRenameManager::GetSelectedItemCount(_Out_ UINT* count)
{
*count = 0;
@@ -186,7 +286,7 @@ IFACEMETHODIMP CPowerRenameManager::GetSelectedItemCount(_Out_ UINT* count)
{
IPowerRenameItem* pItem = it.second;
bool selected = false;
if (SUCCEEDED(pItem->get_selected(&selected)) && selected)
if (SUCCEEDED(pItem->GetSelected(&selected)) && selected)
{
(*count)++;
}
@@ -209,29 +309,56 @@ IFACEMETHODIMP CPowerRenameManager::GetRenameItemCount(_Out_ UINT* count)
(*count)++;
}
}
return S_OK;
}
IFACEMETHODIMP CPowerRenameManager::get_flags(_Out_ DWORD* flags)
IFACEMETHODIMP CPowerRenameManager::GetFlags(_Out_ DWORD* flags)
{
_EnsureRegEx();
*flags = m_flags;
return S_OK;
}
IFACEMETHODIMP CPowerRenameManager::put_flags(_In_ DWORD flags)
IFACEMETHODIMP CPowerRenameManager::PutFlags(_In_ DWORD flags)
{
if (flags != m_flags)
{
m_flags = flags;
_EnsureRegEx();
m_spRegEx->put_flags(flags);
m_spRegEx->PutFlags(flags);
}
return S_OK;
}
IFACEMETHODIMP CPowerRenameManager::get_renameRegEx(_COM_Outptr_ IPowerRenameRegEx** ppRegEx)
IFACEMETHODIMP CPowerRenameManager::GetFilter(_Out_ DWORD* filter)
{
*filter = m_filter;
return S_OK;
}
IFACEMETHODIMP CPowerRenameManager::SwitchFilter(_In_ int columnNumber)
{
switch (m_filter)
{
case PowerRenameFilters::None:
m_filter = (columnNumber == 0) ? PowerRenameFilters::Selected : PowerRenameFilters::ShouldRename;
break;
case PowerRenameFilters::Selected:
m_filter = (columnNumber == 0) ? PowerRenameFilters::FlagsApplicable : PowerRenameFilters::ShouldRename;
break;
case PowerRenameFilters::FlagsApplicable:
m_filter = (columnNumber == 0) ? PowerRenameFilters::None : PowerRenameFilters::ShouldRename;
break;
case PowerRenameFilters::ShouldRename:
m_filter = (columnNumber == 0) ? PowerRenameFilters::Selected : PowerRenameFilters::None;
break;
}
return S_OK;
}
IFACEMETHODIMP CPowerRenameManager::GetRenameRegEx(_COM_Outptr_ IPowerRenameRegEx** ppRegEx)
{
*ppRegEx = nullptr;
HRESULT hr = _EnsureRegEx();
@@ -243,14 +370,14 @@ IFACEMETHODIMP CPowerRenameManager::get_renameRegEx(_COM_Outptr_ IPowerRenameReg
return hr;
}
IFACEMETHODIMP CPowerRenameManager::put_renameRegEx(_In_ IPowerRenameRegEx* pRegEx)
IFACEMETHODIMP CPowerRenameManager::PutRenameRegEx(_In_ IPowerRenameRegEx* pRegEx)
{
_ClearRegEx();
m_spRegEx = pRegEx;
return S_OK;
}
IFACEMETHODIMP CPowerRenameManager::get_renameItemFactory(_COM_Outptr_ IPowerRenameItemFactory** ppItemFactory)
IFACEMETHODIMP CPowerRenameManager::GetRenameItemFactory(_COM_Outptr_ IPowerRenameItemFactory** ppItemFactory)
{
*ppItemFactory = nullptr;
HRESULT hr = E_FAIL;
@@ -263,7 +390,7 @@ IFACEMETHODIMP CPowerRenameManager::get_renameItemFactory(_COM_Outptr_ IPowerRen
return hr;
}
IFACEMETHODIMP CPowerRenameManager::put_renameItemFactory(_In_ IPowerRenameItemFactory* pItemFactory)
IFACEMETHODIMP CPowerRenameManager::PutRenameItemFactory(_In_ IPowerRenameItemFactory* pItemFactory)
{
m_spItemFactory = pItemFactory;
return S_OK;
@@ -421,7 +548,7 @@ void CPowerRenameManager::_LogOperationTelemetry()
GetItemCount(&totalItemCount);
GetSelectedItemCount(&selectedItemCount);
GetRenameItemCount(&renameItemCount);
get_flags(&flags);
GetFlags(&flags);
// Enumerate extensions used into a map
@@ -432,7 +559,7 @@ void CPowerRenameManager::_LogOperationTelemetry()
if (SUCCEEDED(GetItemByIndex(i, &spItem)))
{
PWSTR originalName;
if (SUCCEEDED(spItem->get_originalName(&originalName)))
if (SUCCEEDED(spItem->GetOriginalName(&originalName)))
{
std::wstring extension = fs::path(originalName).extension().wstring();
std::map<std::wstring, int>::iterator it = extensionsMap.find(extension);
@@ -548,14 +675,14 @@ DWORD WINAPI CPowerRenameManager::s_fileOpWorkerThread(_In_ void* pv)
if (WaitForSingleObject(pwtd->startEvent, INFINITE) == WAIT_OBJECT_0)
{
CComPtr<IPowerRenameRegEx> spRenameRegEx;
if (SUCCEEDED(pwtd->spsrm->get_renameRegEx(&spRenameRegEx)))
if (SUCCEEDED(pwtd->spsrm->GetRenameRegEx(&spRenameRegEx)))
{
// Create IFileOperation interface
CComPtr<IFileOperation> spFileOp;
if (SUCCEEDED(CoCreateInstance(CLSID_FileOperation, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&spFileOp))))
{
DWORD flags = 0;
spRenameRegEx->get_flags(&flags);
spRenameRegEx->GetFlags(&flags);
UINT itemCount = 0;
pwtd->spsrm->GetItemCount(&itemCount);
@@ -572,7 +699,7 @@ DWORD WINAPI CPowerRenameManager::s_fileOpWorkerThread(_In_ void* pv)
if (SUCCEEDED(pwtd->spsrm->GetItemByIndex(u, &spItem)))
{
UINT depth = 0;
spItem->get_depth(&depth);
spItem->GetDepth(&depth);
matrix[depth].push_back(u);
}
}
@@ -589,10 +716,10 @@ DWORD WINAPI CPowerRenameManager::s_fileOpWorkerThread(_In_ void* pv)
if (SUCCEEDED(spItem->ShouldRenameItem(flags, &shouldRename)) && shouldRename)
{
PWSTR newName = nullptr;
if (SUCCEEDED(spItem->get_newName(&newName)))
if (SUCCEEDED(spItem->GetNewName(&newName)))
{
CComPtr<IShellItem> spShellItem;
if (SUCCEEDED(spItem->get_shellItem(&spShellItem)))
if (SUCCEEDED(spItem->GetShellItem(&spShellItem)))
{
spFileOp->RenameItem(spShellItem, newName, nullptr);
}
@@ -697,10 +824,10 @@ DWORD WINAPI CPowerRenameManager::s_regexWorkerThread(_In_ void* pv)
if (WaitForSingleObject(pwtd->startEvent, INFINITE) == WAIT_OBJECT_0)
{
CComPtr<IPowerRenameRegEx> spRenameRegEx;
if (SUCCEEDED(pwtd->spsrm->get_renameRegEx(&spRenameRegEx)))
if (SUCCEEDED(pwtd->spsrm->GetRenameRegEx(&spRenameRegEx)))
{
DWORD flags = 0;
spRenameRegEx->get_flags(&flags);
spRenameRegEx->GetFlags(&flags);
UINT itemCount = 0;
unsigned long itemEnumIndex = 1;
@@ -720,18 +847,18 @@ DWORD WINAPI CPowerRenameManager::s_regexWorkerThread(_In_ void* pv)
if (SUCCEEDED(pwtd->spsrm->GetItemByIndex(u, &spItem)))
{
int id = -1;
spItem->get_id(&id);
spItem->GetId(&id);
bool isFolder = false;
bool isSubFolderContent = false;
spItem->get_isFolder(&isFolder);
spItem->get_isSubFolderContent(&isSubFolderContent);
spItem->GetIsFolder(&isFolder);
spItem->GetIsSubFolderContent(&isSubFolderContent);
if ((isFolder && (flags & PowerRenameFlags::ExcludeFolders)) ||
(!isFolder && (flags & PowerRenameFlags::ExcludeFiles)) ||
(isSubFolderContent && (flags & PowerRenameFlags::ExcludeSubfolders)))
{
// Exclude this item from renaming. Ensure new name is cleared.
spItem->put_newName(nullptr);
spItem->PutNewName(nullptr);
// Send the manager thread the item processed message
PostMessage(pwtd->hwndManager, SRM_REGEX_ITEM_UPDATED, GetCurrentThreadId(), id);
@@ -740,10 +867,10 @@ DWORD WINAPI CPowerRenameManager::s_regexWorkerThread(_In_ void* pv)
}
PWSTR originalName = nullptr;
if (SUCCEEDED(spItem->get_originalName(&originalName)))
if (SUCCEEDED(spItem->GetOriginalName(&originalName)))
{
PWSTR currentNewName = nullptr;
spItem->get_newName(&currentNewName);
spItem->GetNewName(&currentNewName);
wchar_t sourceName[MAX_PATH] = { 0 };
if (flags & NameOnly)
@@ -768,13 +895,13 @@ DWORD WINAPI CPowerRenameManager::s_regexWorkerThread(_In_ void* pv)
PWSTR replaceTerm = nullptr;
SYSTEMTIME LocalTime;
if (SUCCEEDED(spRenameRegEx->get_replaceTerm(&replaceTerm)) && isFileAttributesUsed(replaceTerm))
if (SUCCEEDED(spRenameRegEx->GetReplaceTerm(&replaceTerm)) && isFileAttributesUsed(replaceTerm))
{
if (SUCCEEDED(spItem->get_date(&LocalTime)))
if (SUCCEEDED(spItem->GetDate(&LocalTime)))
{
if (SUCCEEDED(GetDatedFileName(newReplaceTerm, ARRAYSIZE(newReplaceTerm), replaceTerm, LocalTime)))
{
spRenameRegEx->put_replaceTerm(newReplaceTerm);
spRenameRegEx->PutReplaceTerm(newReplaceTerm);
}
}
}
@@ -784,7 +911,7 @@ DWORD WINAPI CPowerRenameManager::s_regexWorkerThread(_In_ void* pv)
// Call put_newName with null in that case to reset it
spRenameRegEx->Replace(sourceName, &newName);
spRenameRegEx->put_replaceTerm(replaceTerm);
spRenameRegEx->PutReplaceTerm(replaceTerm);
wchar_t resultName[MAX_PATH] = { 0 };
@@ -857,7 +984,7 @@ DWORD WINAPI CPowerRenameManager::s_regexWorkerThread(_In_ void* pv)
itemEnumIndex++;
}
spItem->put_newName(newNameToUse);
spItem->PutNewName(newNameToUse);
// Was there a change?
if (lstrcmp(currentNewName, newNameToUse) != 0)
@@ -931,7 +1058,7 @@ HRESULT CPowerRenameManager::_EnsureRegEx()
// Get the flags
if (SUCCEEDED(hr))
{
m_spRegEx->get_flags(&m_flags);
m_spRegEx->GetFlags(&m_flags);
}
}
}

20
src/modules/powerrename/lib/PowerRenameManager.h
View File

@@ -26,16 +26,21 @@ public:
IFACEMETHODIMP Rename(_In_ HWND hwndParent);
IFACEMETHODIMP AddItem(_In_ IPowerRenameItem* pItem);
IFACEMETHODIMP GetItemByIndex(_In_ UINT index, _COM_Outptr_ IPowerRenameItem** ppItem);
IFACEMETHODIMP GetVisibleItemByIndex(_In_ UINT index, _COM_Outptr_ IPowerRenameItem** ppItem);
IFACEMETHODIMP GetItemById(_In_ int id, _COM_Outptr_ IPowerRenameItem** ppItem);
IFACEMETHODIMP GetItemCount(_Out_ UINT* count);
IFACEMETHODIMP SetVisible();
IFACEMETHODIMP GetVisibleItemCount(_Out_ UINT* count);
IFACEMETHODIMP GetSelectedItemCount(_Out_ UINT* count);
IFACEMETHODIMP GetRenameItemCount(_Out_ UINT* count);
IFACEMETHODIMP get_flags(_Out_ DWORD* flags);
IFACEMETHODIMP put_flags(_In_ DWORD flags);
IFACEMETHODIMP get_renameRegEx(_COM_Outptr_ IPowerRenameRegEx** ppRegEx);
IFACEMETHODIMP put_renameRegEx(_In_ IPowerRenameRegEx* pRegEx);
IFACEMETHODIMP get_renameItemFactory(_COM_Outptr_ IPowerRenameItemFactory** ppItemFactory);
IFACEMETHODIMP put_renameItemFactory(_In_ IPowerRenameItemFactory* pItemFactory);
IFACEMETHODIMP GetFlags(_Out_ DWORD* flags);
IFACEMETHODIMP PutFlags(_In_ DWORD flags);
IFACEMETHODIMP GetFilter(_Out_ DWORD* filter);
IFACEMETHODIMP SwitchFilter(_In_ int columnNumber);
IFACEMETHODIMP GetRenameRegEx(_COM_Outptr_ IPowerRenameRegEx** ppRegEx);
IFACEMETHODIMP PutRenameRegEx(_In_ IPowerRenameRegEx* pRegEx);
IFACEMETHODIMP GetRenameItemFactory(_COM_Outptr_ IPowerRenameItemFactory** ppItemFactory);
IFACEMETHODIMP PutRenameItemFactory(_In_ IPowerRenameItemFactory* pItemFactory);
// IPowerRenameRegExEvents
IFACEMETHODIMP OnSearchTermChanged(_In_ PCWSTR searchTerm);
@@ -102,6 +107,8 @@ protected:
DWORD m_cookie = 0;
DWORD m_regExAdviseCookie = 0;
DWORD m_filter = PowerRenameFilters::None;
struct RENAME_MGR_EVENT
{
IPowerRenameManagerEvents* pEvents;
@@ -113,6 +120,7 @@ protected:
_Guarded_by_(m_lockEvents) std::vector<RENAME_MGR_EVENT> m_powerRenameManagerEvents;
_Guarded_by_(m_lockItems) std::map<int, IPowerRenameItem*> m_renameItems;
_Guarded_by_(m_lockItems) std::vector<bool> m_isVisible;
// Parent HWND used by IFileOperation
HWND m_hwndParent = nullptr;

12
src/modules/powerrename/lib/PowerRenameRegEx.cpp
View File

@@ -71,7 +71,7 @@ IFACEMETHODIMP CPowerRenameRegEx::UnAdvise(_In_ DWORD cookie)
return hr;
}
IFACEMETHODIMP CPowerRenameRegEx::get_searchTerm(_Outptr_ PWSTR* searchTerm)
IFACEMETHODIMP CPowerRenameRegEx::GetSearchTerm(_Outptr_ PWSTR* searchTerm)
{
*searchTerm = nullptr;
HRESULT hr = m_searchTerm ? S_OK : E_FAIL;
@@ -83,7 +83,7 @@ IFACEMETHODIMP CPowerRenameRegEx::get_searchTerm(_Outptr_ PWSTR* searchTerm)
return hr;
}
IFACEMETHODIMP CPowerRenameRegEx::put_searchTerm(_In_ PCWSTR searchTerm)
IFACEMETHODIMP CPowerRenameRegEx::PutSearchTerm(_In_ PCWSTR searchTerm)
{
bool changed = false;
HRESULT hr = searchTerm ? S_OK : E_INVALIDARG;
@@ -106,7 +106,7 @@ IFACEMETHODIMP CPowerRenameRegEx::put_searchTerm(_In_ PCWSTR searchTerm)
return hr;
}
IFACEMETHODIMP CPowerRenameRegEx::get_replaceTerm(_Outptr_ PWSTR* replaceTerm)
IFACEMETHODIMP CPowerRenameRegEx::GetReplaceTerm(_Outptr_ PWSTR* replaceTerm)
{
*replaceTerm = nullptr;
HRESULT hr = m_replaceTerm ? S_OK : E_FAIL;
@@ -118,7 +118,7 @@ IFACEMETHODIMP CPowerRenameRegEx::get_replaceTerm(_Outptr_ PWSTR* replaceTerm)
return hr;
}
IFACEMETHODIMP CPowerRenameRegEx::put_replaceTerm(_In_ PCWSTR replaceTerm)
IFACEMETHODIMP CPowerRenameRegEx::PutReplaceTerm(_In_ PCWSTR replaceTerm)
{
bool changed = false;
HRESULT hr = replaceTerm ? S_OK : E_INVALIDARG;
@@ -141,13 +141,13 @@ IFACEMETHODIMP CPowerRenameRegEx::put_replaceTerm(_In_ PCWSTR replaceTerm)
return hr;
}
IFACEMETHODIMP CPowerRenameRegEx::get_flags(_Out_ DWORD* flags)
IFACEMETHODIMP CPowerRenameRegEx::GetFlags(_Out_ DWORD* flags)
{
*flags = m_flags;
return S_OK;
}
IFACEMETHODIMP CPowerRenameRegEx::put_flags(_In_ DWORD flags)
IFACEMETHODIMP CPowerRenameRegEx::PutFlags(_In_ DWORD flags)
{
if (m_flags != flags)
{

12
src/modules/powerrename/lib/PowerRenameRegEx.h
View File

@@ -19,12 +19,12 @@ public:
// IPowerRenameRegEx
IFACEMETHODIMP Advise(_In_ IPowerRenameRegExEvents* regExEvents, _Out_ DWORD* cookie);
IFACEMETHODIMP UnAdvise(_In_ DWORD cookie);
IFACEMETHODIMP get_searchTerm(_Outptr_ PWSTR* searchTerm);
IFACEMETHODIMP put_searchTerm(_In_ PCWSTR searchTerm);
IFACEMETHODIMP get_replaceTerm(_Outptr_ PWSTR* replaceTerm);
IFACEMETHODIMP put_replaceTerm(_In_ PCWSTR replaceTerm);
IFACEMETHODIMP get_flags(_Out_ DWORD* flags);
IFACEMETHODIMP put_flags(_In_ DWORD flags);
IFACEMETHODIMP GetSearchTerm(_Outptr_ PWSTR* searchTerm);
IFACEMETHODIMP PutSearchTerm(_In_ PCWSTR searchTerm);
IFACEMETHODIMP GetReplaceTerm(_Outptr_ PWSTR* replaceTerm);
IFACEMETHODIMP PutReplaceTerm(_In_ PCWSTR replaceTerm);
IFACEMETHODIMP GetFlags(_Out_ DWORD* flags);
IFACEMETHODIMP PutFlags(_In_ DWORD flags);
IFACEMETHODIMP Replace(_In_ PCWSTR source, _Outptr_ PWSTR* result);
static HRESULT s_CreateInstance(_Outptr_ IPowerRenameRegEx **renameRegEx);