Mirrors/PowerToys
1
0
Fork 0
mirror of https://github.com/microsoft/PowerToys.git synced 2025-12-16 11:48:06 +01: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

2
src/modules/powerrename/dll/PowerRenameExt.cpp
View File

@@ -166,7 +166,7 @@ DWORD WINAPI CPowerRenameMenu::s_PowerRenameUIThreadProc(_In_ void* pData)
if (SUCCEEDED(hr)) if (SUCCEEDED(hr))
{ {
// Pass the factory to the manager // Pass the factory to the manager
hr = spsrm->put_renameItemFactory(spsrif); hr = spsrm->PutRenameItemFactory(spsrif);
if (SUCCEEDED(hr)) if (SUCCEEDED(hr))
{ {
// Create the rename UI instance and pass the rename manager // Create the rename UI instance and pass the rename manager

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))) while ((S_OK == pesi->Next(1, &spsi, &celtFetched)) && (SUCCEEDED(hr)))
{ {
CComPtr<IPowerRenameItemFactory> spsrif; CComPtr<IPowerRenameItemFactory> spsrif;
hr = psrm->get_renameItemFactory(&spsrif); hr = psrm->GetRenameItemFactory(&spsrif);
if (SUCCEEDED(hr)) if (SUCCEEDED(hr))
{ {
CComPtr<IPowerRenameItem> spNewItem; CComPtr<IPowerRenameItem> spNewItem;
hr = spsrif->Create(spsi, &spNewItem); hr = spsrif->Create(spsi, &spNewItem);
if (SUCCEEDED(hr)) if (SUCCEEDED(hr))
{ {
spNewItem->put_depth(depth); spNewItem->PutDepth(depth);
hr = psrm->AddItem(spNewItem); hr = psrm->AddItem(spNewItem);
} }
if (SUCCEEDED(hr)) if (SUCCEEDED(hr))
{ {
bool isFolder = false; bool isFolder = false;
if (SUCCEEDED(spNewItem->get_isFolder(&isFolder)) && isFolder) if (SUCCEEDED(spNewItem->GetIsFolder(&isFolder)) && isFolder)
{ {
// Bind to the IShellItem for the IEnumShellItems interface // Bind to the IShellItem for the IEnumShellItems interface
CComPtr<IEnumShellItems> spesiNext; CComPtr<IEnumShellItems> spesiNext;

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

@@ -17,6 +17,14 @@ enum PowerRenameFlags
Titlecase = 0x800 Titlecase = 0x800
}; };
enum PowerRenameFilters
{
None = 1,
Selected = 2,
FlagsApplicable = 3,
ShouldRename = 4,
};
interface __declspec(uuid("3ECBA62B-E0F0-4472-AA2E-DEE7A1AA46B9")) IPowerRenameRegExEvents : public IUnknown interface __declspec(uuid("3ECBA62B-E0F0-4472-AA2E-DEE7A1AA46B9")) IPowerRenameRegExEvents : public IUnknown
{ {
public: public:
@@ -30,33 +38,34 @@ interface __declspec(uuid("E3ED45B5-9CE0-47E2-A595-67EB950B9B72")) IPowerRenameR
public: public:
IFACEMETHOD(Advise)(_In_ IPowerRenameRegExEvents* regExEvents, _Out_ DWORD* cookie) = 0; IFACEMETHOD(Advise)(_In_ IPowerRenameRegExEvents* regExEvents, _Out_ DWORD* cookie) = 0;
IFACEMETHOD(UnAdvise)(_In_ DWORD cookie) = 0; IFACEMETHOD(UnAdvise)(_In_ DWORD cookie) = 0;
IFACEMETHOD(get_searchTerm)(_Outptr_ PWSTR* searchTerm) = 0; IFACEMETHOD(GetSearchTerm)(_Outptr_ PWSTR* searchTerm) = 0;
IFACEMETHOD(put_searchTerm)(_In_ PCWSTR searchTerm) = 0; IFACEMETHOD(PutSearchTerm)(_In_ PCWSTR searchTerm) = 0;
IFACEMETHOD(get_replaceTerm)(_Outptr_ PWSTR* replaceTerm) = 0; IFACEMETHOD(GetReplaceTerm)(_Outptr_ PWSTR* replaceTerm) = 0;
IFACEMETHOD(put_replaceTerm)(_In_ PCWSTR replaceTerm) = 0; IFACEMETHOD(PutReplaceTerm)(_In_ PCWSTR replaceTerm) = 0;
IFACEMETHOD(get_flags)(_Out_ DWORD* flags) = 0; IFACEMETHOD(GetFlags)(_Out_ DWORD* flags) = 0;
IFACEMETHOD(put_flags)(_In_ DWORD flags) = 0; IFACEMETHOD(PutFlags)(_In_ DWORD flags) = 0;
IFACEMETHOD(Replace)(_In_ PCWSTR source, _Outptr_ PWSTR* result) = 0; IFACEMETHOD(Replace)(_In_ PCWSTR source, _Outptr_ PWSTR* result) = 0;
}; };
interface __declspec(uuid("C7F59201-4DE1-4855-A3A2-26FC3279C8A5")) IPowerRenameItem : public IUnknown interface __declspec(uuid("C7F59201-4DE1-4855-A3A2-26FC3279C8A5")) IPowerRenameItem : public IUnknown
{ {
public: public:
IFACEMETHOD(get_path)(_Outptr_ PWSTR* path) = 0; IFACEMETHOD(GetPath)(_Outptr_ PWSTR* path) = 0;
IFACEMETHOD(get_date)(_Outptr_ SYSTEMTIME* date) = 0; IFACEMETHOD(GetDate)(_Outptr_ SYSTEMTIME* date) = 0;
IFACEMETHOD(get_shellItem)(_Outptr_ IShellItem** ppsi) = 0; IFACEMETHOD(GetShellItem)(_Outptr_ IShellItem** ppsi) = 0;
IFACEMETHOD(get_originalName)(_Outptr_ PWSTR* originalName) = 0; IFACEMETHOD(GetOriginalName)(_Outptr_ PWSTR* originalName) = 0;
IFACEMETHOD(get_newName)(_Outptr_ PWSTR* newName) = 0; IFACEMETHOD(GetNewName)(_Outptr_ PWSTR* newName) = 0;
IFACEMETHOD(put_newName)(_In_opt_ PCWSTR newName) = 0; IFACEMETHOD(PutNewName)(_In_opt_ PCWSTR newName) = 0;
IFACEMETHOD(get_isFolder)(_Out_ bool* isFolder) = 0; IFACEMETHOD(GetIsFolder)(_Out_ bool* isFolder) = 0;
IFACEMETHOD(get_isSubFolderContent)(_Out_ bool* isSubFolderContent) = 0; IFACEMETHOD(GetIsSubFolderContent)(_Out_ bool* isSubFolderContent) = 0;
IFACEMETHOD(get_selected)(_Out_ bool* selected) = 0; IFACEMETHOD(GetSelected)(_Out_ bool* selected) = 0;
IFACEMETHOD(put_selected)(_In_ bool selected) = 0; IFACEMETHOD(PutSelected)(_In_ bool selected) = 0;
IFACEMETHOD(get_id)(_Out_ int *id) = 0; IFACEMETHOD(GetId)(_Out_ int *id) = 0;
IFACEMETHOD(get_iconIndex)(_Out_ int* iconIndex) = 0; IFACEMETHOD(GetIconIndex)(_Out_ int* iconIndex) = 0;
IFACEMETHOD(get_depth)(_Out_ UINT* depth) = 0; IFACEMETHOD(GetDepth)(_Out_ UINT* depth) = 0;
IFACEMETHOD(put_depth)(_In_ int depth) = 0; IFACEMETHOD(PutDepth)(_In_ int depth) = 0;
IFACEMETHOD(ShouldRenameItem)(_In_ DWORD flags, _Out_ bool* shouldRename) = 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; IFACEMETHOD(Reset)() = 0;
}; };
@@ -91,16 +100,21 @@ public:
IFACEMETHOD(Rename)(_In_ HWND hwndParent) = 0; IFACEMETHOD(Rename)(_In_ HWND hwndParent) = 0;
IFACEMETHOD(AddItem)(_In_ IPowerRenameItem* pItem) = 0; IFACEMETHOD(AddItem)(_In_ IPowerRenameItem* pItem) = 0;
IFACEMETHOD(GetItemByIndex)(_In_ UINT index, _COM_Outptr_ IPowerRenameItem** ppItem) = 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(GetItemById)(_In_ int id, _COM_Outptr_ IPowerRenameItem** ppItem) = 0;
IFACEMETHOD(GetItemCount)(_Out_ UINT* count) = 0; IFACEMETHOD(GetItemCount)(_Out_ UINT* count) = 0;
IFACEMETHOD(GetVisibleItemCount)(_Out_ UINT* count) = 0;
IFACEMETHOD(GetSelectedItemCount)(_Out_ UINT* count) = 0; IFACEMETHOD(GetSelectedItemCount)(_Out_ UINT* count) = 0;
IFACEMETHOD(GetRenameItemCount)(_Out_ UINT* count) = 0; IFACEMETHOD(GetRenameItemCount)(_Out_ UINT* count) = 0;
IFACEMETHOD(get_flags)(_Out_ DWORD* flags) = 0; IFACEMETHOD(GetFlags)(_Out_ DWORD* flags) = 0;
IFACEMETHOD(put_flags)(_In_ DWORD flags) = 0; IFACEMETHOD(PutFlags)(_In_ DWORD flags) = 0;
IFACEMETHOD(get_renameRegEx)(_COM_Outptr_ IPowerRenameRegEx** ppRegEx) = 0; IFACEMETHOD(GetFilter)(_Out_ DWORD * filter) = 0;
IFACEMETHOD(put_renameRegEx)(_In_ IPowerRenameRegEx* pRegEx) = 0; IFACEMETHOD(SwitchFilter)(_In_ int columnNumber) = 0;
IFACEMETHOD(get_renameItemFactory)(_COM_Outptr_ IPowerRenameItemFactory** ppItemFactory) = 0; IFACEMETHOD(GetRenameRegEx)(_COM_Outptr_ IPowerRenameRegEx** ppRegEx) = 0;
IFACEMETHOD(put_renameItemFactory)(_In_ IPowerRenameItemFactory* pItemFactory) = 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 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); return QISearch(this, qit, riid, ppv);
} }
IFACEMETHODIMP CPowerRenameItem::get_path(_Outptr_ PWSTR* path) IFACEMETHODIMP CPowerRenameItem::GetPath(_Outptr_ PWSTR* path)
{ {
*path = nullptr; *path = nullptr;
CSRWSharedAutoLock lock(&m_lock); CSRWSharedAutoLock lock(&m_lock);
@@ -42,7 +42,7 @@ IFACEMETHODIMP CPowerRenameItem::get_path(_Outptr_ PWSTR* path)
return hr; return hr;
} }
IFACEMETHODIMP CPowerRenameItem::get_date(_Outptr_ SYSTEMTIME* date) IFACEMETHODIMP CPowerRenameItem::GetDate(_Outptr_ SYSTEMTIME* date)
{ {
CSRWSharedAutoLock lock(&m_lock); CSRWSharedAutoLock lock(&m_lock);
HRESULT hr = m_isDateParsed ? S_OK : E_FAIL ; HRESULT hr = m_isDateParsed ? S_OK : E_FAIL ;
@@ -72,12 +72,12 @@ IFACEMETHODIMP CPowerRenameItem::get_date(_Outptr_ SYSTEMTIME* date)
return hr; return hr;
} }
IFACEMETHODIMP CPowerRenameItem::get_shellItem(_Outptr_ IShellItem** ppsi) IFACEMETHODIMP CPowerRenameItem::GetShellItem(_Outptr_ IShellItem** ppsi)
{ {
return SHCreateItemFromParsingName(m_path, nullptr, IID_PPV_ARGS(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); CSRWSharedAutoLock lock(&m_lock);
HRESULT hr = m_originalName ? S_OK : E_FAIL; HRESULT hr = m_originalName ? S_OK : E_FAIL;
@@ -88,7 +88,7 @@ IFACEMETHODIMP CPowerRenameItem::get_originalName(_Outptr_ PWSTR* originalName)
return hr; return hr;
} }
IFACEMETHODIMP CPowerRenameItem::put_newName(_In_opt_ PCWSTR newName) IFACEMETHODIMP CPowerRenameItem::PutNewName(_In_opt_ PCWSTR newName)
{ {
CSRWSharedAutoLock lock(&m_lock); CSRWSharedAutoLock lock(&m_lock);
CoTaskMemFree(m_newName); CoTaskMemFree(m_newName);
@@ -101,7 +101,7 @@ IFACEMETHODIMP CPowerRenameItem::put_newName(_In_opt_ PCWSTR newName)
return hr; return hr;
} }
IFACEMETHODIMP CPowerRenameItem::get_newName(_Outptr_ PWSTR* newName) IFACEMETHODIMP CPowerRenameItem::GetNewName(_Outptr_ PWSTR* newName)
{ {
CSRWSharedAutoLock lock(&m_lock); CSRWSharedAutoLock lock(&m_lock);
HRESULT hr = m_newName ? S_OK : E_FAIL; HRESULT hr = m_newName ? S_OK : E_FAIL;
@@ -112,42 +112,42 @@ IFACEMETHODIMP CPowerRenameItem::get_newName(_Outptr_ PWSTR* newName)
return hr; return hr;
} }
IFACEMETHODIMP CPowerRenameItem::get_isFolder(_Out_ bool* isFolder) IFACEMETHODIMP CPowerRenameItem::GetIsFolder(_Out_ bool* isFolder)
{ {
CSRWSharedAutoLock lock(&m_lock); CSRWSharedAutoLock lock(&m_lock);
*isFolder = m_isFolder; *isFolder = m_isFolder;
return S_OK; return S_OK;
} }
IFACEMETHODIMP CPowerRenameItem::get_isSubFolderContent(_Out_ bool* isSubFolderContent) IFACEMETHODIMP CPowerRenameItem::GetIsSubFolderContent(_Out_ bool* isSubFolderContent)
{ {
CSRWSharedAutoLock lock(&m_lock); CSRWSharedAutoLock lock(&m_lock);
*isSubFolderContent = m_depth > 0; *isSubFolderContent = m_depth > 0;
return S_OK; return S_OK;
} }
IFACEMETHODIMP CPowerRenameItem::get_selected(_Out_ bool* selected) IFACEMETHODIMP CPowerRenameItem::GetSelected(_Out_ bool* selected)
{ {
CSRWSharedAutoLock lock(&m_lock); CSRWSharedAutoLock lock(&m_lock);
*selected = m_selected; *selected = m_selected;
return S_OK; return S_OK;
} }
IFACEMETHODIMP CPowerRenameItem::put_selected(_In_ bool selected) IFACEMETHODIMP CPowerRenameItem::PutSelected(_In_ bool selected)
{ {
CSRWSharedAutoLock lock(&m_lock); CSRWSharedAutoLock lock(&m_lock);
m_selected = selected; m_selected = selected;
return S_OK; return S_OK;
} }
IFACEMETHODIMP CPowerRenameItem::get_id(_Out_ int* id) IFACEMETHODIMP CPowerRenameItem::GetId(_Out_ int* id)
{ {
CSRWSharedAutoLock lock(&m_lock); CSRWSharedAutoLock lock(&m_lock);
*id = m_id; *id = m_id;
return S_OK; return S_OK;
} }
IFACEMETHODIMP CPowerRenameItem::get_iconIndex(_Out_ int* iconIndex) IFACEMETHODIMP CPowerRenameItem::GetIconIndex(_Out_ int* iconIndex)
{ {
if (m_iconIndex == -1) if (m_iconIndex == -1)
{ {
@@ -157,13 +157,13 @@ IFACEMETHODIMP CPowerRenameItem::get_iconIndex(_Out_ int* iconIndex)
return S_OK; return S_OK;
} }
IFACEMETHODIMP CPowerRenameItem::get_depth(_Out_ UINT* depth) IFACEMETHODIMP CPowerRenameItem::GetDepth(_Out_ UINT* depth)
{ {
*depth = m_depth; *depth = m_depth;
return S_OK; return S_OK;
} }
IFACEMETHODIMP CPowerRenameItem::put_depth(_In_ int depth) IFACEMETHODIMP CPowerRenameItem::PutDepth(_In_ int depth)
{ {
m_depth = depth; m_depth = depth;
return S_OK; return S_OK;
@@ -179,7 +179,29 @@ IFACEMETHODIMP CPowerRenameItem::ShouldRenameItem(_In_ DWORD flags, _Out_ bool*
bool excludeBecauseSubFolderContent = (m_depth > 0 && (flags & PowerRenameFlags::ExcludeSubfolders)); bool excludeBecauseSubFolderContent = (m_depth > 0 && (flags & PowerRenameFlags::ExcludeSubfolders));
*shouldRename = (m_selected && m_canRename && hasChanged && !excludeBecauseFile && *shouldRename = (m_selected && m_canRename && hasChanged && !excludeBecauseFile &&
!excludeBecauseFolder && !excludeBecauseSubFolderContent); !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; return S_OK;
} }

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

@@ -14,22 +14,23 @@ public:
IFACEMETHODIMP_(ULONG) Release(); IFACEMETHODIMP_(ULONG) Release();
// IPowerRenameItem // IPowerRenameItem
IFACEMETHODIMP get_path(_Outptr_ PWSTR* path); IFACEMETHODIMP GetPath(_Outptr_ PWSTR* path);
IFACEMETHODIMP get_date(_Outptr_ SYSTEMTIME* date); IFACEMETHODIMP GetDate(_Outptr_ SYSTEMTIME* date);
IFACEMETHODIMP get_shellItem(_Outptr_ IShellItem** ppsi); IFACEMETHODIMP GetShellItem(_Outptr_ IShellItem** ppsi);
IFACEMETHODIMP get_originalName(_Outptr_ PWSTR* originalName); IFACEMETHODIMP GetOriginalName(_Outptr_ PWSTR* originalName);
IFACEMETHODIMP put_newName(_In_opt_ PCWSTR newName); IFACEMETHODIMP PutNewName(_In_opt_ PCWSTR newName);
IFACEMETHODIMP get_newName(_Outptr_ PWSTR* newName); IFACEMETHODIMP GetNewName(_Outptr_ PWSTR* newName);
IFACEMETHODIMP get_isFolder(_Out_ bool* isFolder); IFACEMETHODIMP GetIsFolder(_Out_ bool* isFolder);
IFACEMETHODIMP get_isSubFolderContent(_Out_ bool* isSubFolderContent); IFACEMETHODIMP GetIsSubFolderContent(_Out_ bool* isSubFolderContent);
IFACEMETHODIMP get_selected(_Out_ bool* selected); IFACEMETHODIMP GetSelected(_Out_ bool* selected);
IFACEMETHODIMP put_selected(_In_ bool selected); IFACEMETHODIMP PutSelected(_In_ bool selected);
IFACEMETHODIMP get_id(_Out_ int* id); IFACEMETHODIMP GetId(_Out_ int* id);
IFACEMETHODIMP get_iconIndex(_Out_ int* iconIndex); IFACEMETHODIMP GetIconIndex(_Out_ int* iconIndex);
IFACEMETHODIMP get_depth(_Out_ UINT* depth); IFACEMETHODIMP GetDepth(_Out_ UINT* depth);
IFACEMETHODIMP put_depth(_In_ int depth); IFACEMETHODIMP PutDepth(_In_ int depth);
IFACEMETHODIMP Reset(); IFACEMETHODIMP Reset();
IFACEMETHODIMP ShouldRenameItem(_In_ DWORD flags, _Out_ bool* shouldRename); IFACEMETHODIMP ShouldRenameItem(_In_ DWORD flags, _Out_ bool* shouldRename);
IFACEMETHODIMP IsItemVisible(_In_ DWORD filter, _In_ DWORD flags, _Out_ bool* isItemVisible);
// IPowerRenameItemFactory // IPowerRenameItemFactory
IFACEMETHODIMP Create(_In_ IShellItem* psi, _Outptr_ IPowerRenameItem** ppItem) 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); CSRWExclusiveAutoLock lock(&m_lockItems);
int id = 0; int id = 0;
pItem->get_id(&id); pItem->GetId(&id);
// Verify the item isn't already added // Verify the item isn't already added
if (m_renameItems.find(id) == m_renameItems.end()) if (m_renameItems.find(id) == m_renameItems.end())
{ {
m_renameItems[id] = pItem; m_renameItems[id] = pItem;
m_isVisible.push_back(true);
pItem->AddRef(); pItem->AddRef();
hr = S_OK; hr = S_OK;
} }
@@ -152,6 +153,39 @@ IFACEMETHODIMP CPowerRenameManager::GetItemByIndex(_In_ UINT index, _COM_Outptr_
return hr; 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) IFACEMETHODIMP CPowerRenameManager::GetItemById(_In_ int id, _COM_Outptr_ IPowerRenameItem** ppItem)
{ {
*ppItem = nullptr; *ppItem = nullptr;
@@ -177,6 +211,72 @@ IFACEMETHODIMP CPowerRenameManager::GetItemCount(_Out_ UINT* count)
return S_OK; 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) IFACEMETHODIMP CPowerRenameManager::GetSelectedItemCount(_Out_ UINT* count)
{ {
*count = 0; *count = 0;
@@ -186,7 +286,7 @@ IFACEMETHODIMP CPowerRenameManager::GetSelectedItemCount(_Out_ UINT* count)
{ {
IPowerRenameItem* pItem = it.second; IPowerRenameItem* pItem = it.second;
bool selected = false; bool selected = false;
if (SUCCEEDED(pItem->get_selected(&selected)) && selected) if (SUCCEEDED(pItem->GetSelected(&selected)) && selected)
{ {
(*count)++; (*count)++;
} }
@@ -209,29 +309,56 @@ IFACEMETHODIMP CPowerRenameManager::GetRenameItemCount(_Out_ UINT* count)
(*count)++; (*count)++;
} }
} }
return S_OK; return S_OK;
} }
IFACEMETHODIMP CPowerRenameManager::get_flags(_Out_ DWORD* flags) IFACEMETHODIMP CPowerRenameManager::GetFlags(_Out_ DWORD* flags)
{ {
_EnsureRegEx(); _EnsureRegEx();
*flags = m_flags; *flags = m_flags;
return S_OK; return S_OK;
} }
IFACEMETHODIMP CPowerRenameManager::put_flags(_In_ DWORD flags) IFACEMETHODIMP CPowerRenameManager::PutFlags(_In_ DWORD flags)
{ {
if (flags != m_flags) if (flags != m_flags)
{ {
m_flags = flags; m_flags = flags;
_EnsureRegEx(); _EnsureRegEx();
m_spRegEx->put_flags(flags); m_spRegEx->PutFlags(flags);
} }
return S_OK; 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; *ppRegEx = nullptr;
HRESULT hr = _EnsureRegEx(); HRESULT hr = _EnsureRegEx();
@@ -243,14 +370,14 @@ IFACEMETHODIMP CPowerRenameManager::get_renameRegEx(_COM_Outptr_ IPowerRenameReg
return hr; return hr;
} }
IFACEMETHODIMP CPowerRenameManager::put_renameRegEx(_In_ IPowerRenameRegEx* pRegEx) IFACEMETHODIMP CPowerRenameManager::PutRenameRegEx(_In_ IPowerRenameRegEx* pRegEx)
{ {
_ClearRegEx(); _ClearRegEx();
m_spRegEx = pRegEx; m_spRegEx = pRegEx;
return S_OK; return S_OK;
} }
IFACEMETHODIMP CPowerRenameManager::get_renameItemFactory(_COM_Outptr_ IPowerRenameItemFactory** ppItemFactory) IFACEMETHODIMP CPowerRenameManager::GetRenameItemFactory(_COM_Outptr_ IPowerRenameItemFactory** ppItemFactory)
{ {
*ppItemFactory = nullptr; *ppItemFactory = nullptr;
HRESULT hr = E_FAIL; HRESULT hr = E_FAIL;
@@ -263,7 +390,7 @@ IFACEMETHODIMP CPowerRenameManager::get_renameItemFactory(_COM_Outptr_ IPowerRen
return hr; return hr;
} }
IFACEMETHODIMP CPowerRenameManager::put_renameItemFactory(_In_ IPowerRenameItemFactory* pItemFactory) IFACEMETHODIMP CPowerRenameManager::PutRenameItemFactory(_In_ IPowerRenameItemFactory* pItemFactory)
{ {
m_spItemFactory = pItemFactory; m_spItemFactory = pItemFactory;
return S_OK; return S_OK;
@@ -421,7 +548,7 @@ void CPowerRenameManager::_LogOperationTelemetry()
GetItemCount(&totalItemCount); GetItemCount(&totalItemCount);
GetSelectedItemCount(&selectedItemCount); GetSelectedItemCount(&selectedItemCount);
GetRenameItemCount(&renameItemCount); GetRenameItemCount(&renameItemCount);
get_flags(&flags); GetFlags(&flags);
// Enumerate extensions used into a map // Enumerate extensions used into a map
@@ -432,7 +559,7 @@ void CPowerRenameManager::_LogOperationTelemetry()
if (SUCCEEDED(GetItemByIndex(i, &spItem))) if (SUCCEEDED(GetItemByIndex(i, &spItem)))
{ {
PWSTR originalName; PWSTR originalName;
if (SUCCEEDED(spItem->get_originalName(&originalName))) if (SUCCEEDED(spItem->GetOriginalName(&originalName)))
{ {
std::wstring extension = fs::path(originalName).extension().wstring(); std::wstring extension = fs::path(originalName).extension().wstring();
std::map<std::wstring, int>::iterator it = extensionsMap.find(extension); 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) if (WaitForSingleObject(pwtd->startEvent, INFINITE) == WAIT_OBJECT_0)
{ {
CComPtr<IPowerRenameRegEx> spRenameRegEx; CComPtr<IPowerRenameRegEx> spRenameRegEx;
if (SUCCEEDED(pwtd->spsrm->get_renameRegEx(&spRenameRegEx))) if (SUCCEEDED(pwtd->spsrm->GetRenameRegEx(&spRenameRegEx)))
{ {
// Create IFileOperation interface // Create IFileOperation interface
CComPtr<IFileOperation> spFileOp; CComPtr<IFileOperation> spFileOp;
if (SUCCEEDED(CoCreateInstance(CLSID_FileOperation, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&spFileOp)))) if (SUCCEEDED(CoCreateInstance(CLSID_FileOperation, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&spFileOp))))
{ {
DWORD flags = 0; DWORD flags = 0;
spRenameRegEx->get_flags(&flags); spRenameRegEx->GetFlags(&flags);
UINT itemCount = 0; UINT itemCount = 0;
pwtd->spsrm->GetItemCount(&itemCount); pwtd->spsrm->GetItemCount(&itemCount);
@@ -572,7 +699,7 @@ DWORD WINAPI CPowerRenameManager::s_fileOpWorkerThread(_In_ void* pv)
if (SUCCEEDED(pwtd->spsrm->GetItemByIndex(u, &spItem))) if (SUCCEEDED(pwtd->spsrm->GetItemByIndex(u, &spItem)))
{ {
UINT depth = 0; UINT depth = 0;
spItem->get_depth(&depth); spItem->GetDepth(&depth);
matrix[depth].push_back(u); matrix[depth].push_back(u);
} }
} }
@@ -589,10 +716,10 @@ DWORD WINAPI CPowerRenameManager::s_fileOpWorkerThread(_In_ void* pv)
if (SUCCEEDED(spItem->ShouldRenameItem(flags, &shouldRename)) && shouldRename) if (SUCCEEDED(spItem->ShouldRenameItem(flags, &shouldRename)) && shouldRename)
{ {
PWSTR newName = nullptr; PWSTR newName = nullptr;
if (SUCCEEDED(spItem->get_newName(&newName))) if (SUCCEEDED(spItem->GetNewName(&newName)))
{ {
CComPtr<IShellItem> spShellItem; CComPtr<IShellItem> spShellItem;
if (SUCCEEDED(spItem->get_shellItem(&spShellItem))) if (SUCCEEDED(spItem->GetShellItem(&spShellItem)))
{ {
spFileOp->RenameItem(spShellItem, newName, nullptr); 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) if (WaitForSingleObject(pwtd->startEvent, INFINITE) == WAIT_OBJECT_0)
{ {
CComPtr<IPowerRenameRegEx> spRenameRegEx; CComPtr<IPowerRenameRegEx> spRenameRegEx;
if (SUCCEEDED(pwtd->spsrm->get_renameRegEx(&spRenameRegEx))) if (SUCCEEDED(pwtd->spsrm->GetRenameRegEx(&spRenameRegEx)))
{ {
DWORD flags = 0; DWORD flags = 0;
spRenameRegEx->get_flags(&flags); spRenameRegEx->GetFlags(&flags);
UINT itemCount = 0; UINT itemCount = 0;
unsigned long itemEnumIndex = 1; unsigned long itemEnumIndex = 1;
@@ -720,18 +847,18 @@ DWORD WINAPI CPowerRenameManager::s_regexWorkerThread(_In_ void* pv)
if (SUCCEEDED(pwtd->spsrm->GetItemByIndex(u, &spItem))) if (SUCCEEDED(pwtd->spsrm->GetItemByIndex(u, &spItem)))
{ {
int id = -1; int id = -1;
spItem->get_id(&id); spItem->GetId(&id);
bool isFolder = false; bool isFolder = false;
bool isSubFolderContent = false; bool isSubFolderContent = false;
spItem->get_isFolder(&isFolder); spItem->GetIsFolder(&isFolder);
spItem->get_isSubFolderContent(&isSubFolderContent); spItem->GetIsSubFolderContent(&isSubFolderContent);
if ((isFolder && (flags & PowerRenameFlags::ExcludeFolders)) || if ((isFolder && (flags & PowerRenameFlags::ExcludeFolders)) ||
(!isFolder && (flags & PowerRenameFlags::ExcludeFiles)) || (!isFolder && (flags & PowerRenameFlags::ExcludeFiles)) ||
(isSubFolderContent && (flags & PowerRenameFlags::ExcludeSubfolders))) (isSubFolderContent && (flags & PowerRenameFlags::ExcludeSubfolders)))
{ {
// Exclude this item from renaming. Ensure new name is cleared. // 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 // Send the manager thread the item processed message
PostMessage(pwtd->hwndManager, SRM_REGEX_ITEM_UPDATED, GetCurrentThreadId(), id); PostMessage(pwtd->hwndManager, SRM_REGEX_ITEM_UPDATED, GetCurrentThreadId(), id);
@@ -740,10 +867,10 @@ DWORD WINAPI CPowerRenameManager::s_regexWorkerThread(_In_ void* pv)
} }
PWSTR originalName = nullptr; PWSTR originalName = nullptr;
if (SUCCEEDED(spItem->get_originalName(&originalName))) if (SUCCEEDED(spItem->GetOriginalName(&originalName)))
{ {
PWSTR currentNewName = nullptr; PWSTR currentNewName = nullptr;
spItem->get_newName(&currentNewName); spItem->GetNewName(&currentNewName);
wchar_t sourceName[MAX_PATH] = { 0 }; wchar_t sourceName[MAX_PATH] = { 0 };
if (flags & NameOnly) if (flags & NameOnly)
@@ -768,13 +895,13 @@ DWORD WINAPI CPowerRenameManager::s_regexWorkerThread(_In_ void* pv)
PWSTR replaceTerm = nullptr; PWSTR replaceTerm = nullptr;
SYSTEMTIME LocalTime; 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))) 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 // Call put_newName with null in that case to reset it
spRenameRegEx->Replace(sourceName, &newName); spRenameRegEx->Replace(sourceName, &newName);
spRenameRegEx->put_replaceTerm(replaceTerm); spRenameRegEx->PutReplaceTerm(replaceTerm);
wchar_t resultName[MAX_PATH] = { 0 }; wchar_t resultName[MAX_PATH] = { 0 };
@@ -857,7 +984,7 @@ DWORD WINAPI CPowerRenameManager::s_regexWorkerThread(_In_ void* pv)
itemEnumIndex++; itemEnumIndex++;
} }
spItem->put_newName(newNameToUse); spItem->PutNewName(newNameToUse);
// Was there a change? // Was there a change?
if (lstrcmp(currentNewName, newNameToUse) != 0) if (lstrcmp(currentNewName, newNameToUse) != 0)
@@ -931,7 +1058,7 @@ HRESULT CPowerRenameManager::_EnsureRegEx()
// Get the flags // Get the flags
if (SUCCEEDED(hr)) 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 Rename(_In_ HWND hwndParent);
IFACEMETHODIMP AddItem(_In_ IPowerRenameItem* pItem); IFACEMETHODIMP AddItem(_In_ IPowerRenameItem* pItem);
IFACEMETHODIMP GetItemByIndex(_In_ UINT index, _COM_Outptr_ IPowerRenameItem** ppItem); 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 GetItemById(_In_ int id, _COM_Outptr_ IPowerRenameItem** ppItem);
IFACEMETHODIMP GetItemCount(_Out_ UINT* count); IFACEMETHODIMP GetItemCount(_Out_ UINT* count);
IFACEMETHODIMP SetVisible();
IFACEMETHODIMP GetVisibleItemCount(_Out_ UINT* count);
IFACEMETHODIMP GetSelectedItemCount(_Out_ UINT* count); IFACEMETHODIMP GetSelectedItemCount(_Out_ UINT* count);
IFACEMETHODIMP GetRenameItemCount(_Out_ UINT* count); IFACEMETHODIMP GetRenameItemCount(_Out_ UINT* count);
IFACEMETHODIMP get_flags(_Out_ DWORD* flags); IFACEMETHODIMP GetFlags(_Out_ DWORD* flags);
IFACEMETHODIMP put_flags(_In_ DWORD flags); IFACEMETHODIMP PutFlags(_In_ DWORD flags);
IFACEMETHODIMP get_renameRegEx(_COM_Outptr_ IPowerRenameRegEx** ppRegEx); IFACEMETHODIMP GetFilter(_Out_ DWORD* filter);
IFACEMETHODIMP put_renameRegEx(_In_ IPowerRenameRegEx* pRegEx); IFACEMETHODIMP SwitchFilter(_In_ int columnNumber);
IFACEMETHODIMP get_renameItemFactory(_COM_Outptr_ IPowerRenameItemFactory** ppItemFactory); IFACEMETHODIMP GetRenameRegEx(_COM_Outptr_ IPowerRenameRegEx** ppRegEx);
IFACEMETHODIMP put_renameItemFactory(_In_ IPowerRenameItemFactory* pItemFactory); IFACEMETHODIMP PutRenameRegEx(_In_ IPowerRenameRegEx* pRegEx);
IFACEMETHODIMP GetRenameItemFactory(_COM_Outptr_ IPowerRenameItemFactory** ppItemFactory);
IFACEMETHODIMP PutRenameItemFactory(_In_ IPowerRenameItemFactory* pItemFactory);
// IPowerRenameRegExEvents // IPowerRenameRegExEvents
IFACEMETHODIMP OnSearchTermChanged(_In_ PCWSTR searchTerm); IFACEMETHODIMP OnSearchTermChanged(_In_ PCWSTR searchTerm);
@@ -102,6 +107,8 @@ protected:
DWORD m_cookie = 0; DWORD m_cookie = 0;
DWORD m_regExAdviseCookie = 0; DWORD m_regExAdviseCookie = 0;
DWORD m_filter = PowerRenameFilters::None;
struct RENAME_MGR_EVENT struct RENAME_MGR_EVENT
{ {
IPowerRenameManagerEvents* pEvents; IPowerRenameManagerEvents* pEvents;
@@ -113,6 +120,7 @@ protected:
_Guarded_by_(m_lockEvents) std::vector<RENAME_MGR_EVENT> m_powerRenameManagerEvents; _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::map<int, IPowerRenameItem*> m_renameItems;
_Guarded_by_(m_lockItems) std::vector<bool> m_isVisible;
// Parent HWND used by IFileOperation // Parent HWND used by IFileOperation
HWND m_hwndParent = nullptr; 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; return hr;
} }
IFACEMETHODIMP CPowerRenameRegEx::get_searchTerm(_Outptr_ PWSTR* searchTerm) IFACEMETHODIMP CPowerRenameRegEx::GetSearchTerm(_Outptr_ PWSTR* searchTerm)
{ {
*searchTerm = nullptr; *searchTerm = nullptr;
HRESULT hr = m_searchTerm ? S_OK : E_FAIL; HRESULT hr = m_searchTerm ? S_OK : E_FAIL;
@@ -83,7 +83,7 @@ IFACEMETHODIMP CPowerRenameRegEx::get_searchTerm(_Outptr_ PWSTR* searchTerm)
return hr; return hr;
} }
IFACEMETHODIMP CPowerRenameRegEx::put_searchTerm(_In_ PCWSTR searchTerm) IFACEMETHODIMP CPowerRenameRegEx::PutSearchTerm(_In_ PCWSTR searchTerm)
{ {
bool changed = false; bool changed = false;
HRESULT hr = searchTerm ? S_OK : E_INVALIDARG; HRESULT hr = searchTerm ? S_OK : E_INVALIDARG;
@@ -106,7 +106,7 @@ IFACEMETHODIMP CPowerRenameRegEx::put_searchTerm(_In_ PCWSTR searchTerm)
return hr; return hr;
} }
IFACEMETHODIMP CPowerRenameRegEx::get_replaceTerm(_Outptr_ PWSTR* replaceTerm) IFACEMETHODIMP CPowerRenameRegEx::GetReplaceTerm(_Outptr_ PWSTR* replaceTerm)
{ {
*replaceTerm = nullptr; *replaceTerm = nullptr;
HRESULT hr = m_replaceTerm ? S_OK : E_FAIL; HRESULT hr = m_replaceTerm ? S_OK : E_FAIL;
@@ -118,7 +118,7 @@ IFACEMETHODIMP CPowerRenameRegEx::get_replaceTerm(_Outptr_ PWSTR* replaceTerm)
return hr; return hr;
} }
IFACEMETHODIMP CPowerRenameRegEx::put_replaceTerm(_In_ PCWSTR replaceTerm) IFACEMETHODIMP CPowerRenameRegEx::PutReplaceTerm(_In_ PCWSTR replaceTerm)
{ {
bool changed = false; bool changed = false;
HRESULT hr = replaceTerm ? S_OK : E_INVALIDARG; HRESULT hr = replaceTerm ? S_OK : E_INVALIDARG;
@@ -141,13 +141,13 @@ IFACEMETHODIMP CPowerRenameRegEx::put_replaceTerm(_In_ PCWSTR replaceTerm)
return hr; return hr;
} }
IFACEMETHODIMP CPowerRenameRegEx::get_flags(_Out_ DWORD* flags) IFACEMETHODIMP CPowerRenameRegEx::GetFlags(_Out_ DWORD* flags)
{ {
*flags = m_flags; *flags = m_flags;
return S_OK; return S_OK;
} }
IFACEMETHODIMP CPowerRenameRegEx::put_flags(_In_ DWORD flags) IFACEMETHODIMP CPowerRenameRegEx::PutFlags(_In_ DWORD flags)
{ {
if (m_flags != flags) if (m_flags != flags)
{ {

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

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

2
src/modules/powerrename/testapp/PowerRenameTest.cpp
View File

@@ -43,7 +43,7 @@ int APIENTRY wWinMain(
if (SUCCEEDED(CPowerRenameItem::s_CreateInstance(nullptr, IID_PPV_ARGS(&spsrif)))) if (SUCCEEDED(CPowerRenameItem::s_CreateInstance(nullptr, IID_PPV_ARGS(&spsrif))))
{ {
// Pass the factory to the manager // Pass the factory to the manager
if (SUCCEEDED(spsrm->put_renameItemFactory(spsrif))) if (SUCCEEDED(spsrm->PutRenameItemFactory(spsrif)))
{ {
// Create the rename UI instance and pass the manager // Create the rename UI instance and pass the manager
CComPtr<IPowerRenameUI> spsrui; CComPtr<IPowerRenameUI> spsrui;

159
src/modules/powerrename/ui/PowerRenameUI.cpp
View File

@@ -150,13 +150,13 @@ IFACEMETHODIMP CPowerRenameUI::Update()
return S_OK; return S_OK;
} }
IFACEMETHODIMP CPowerRenameUI::get_hwnd(_Out_ HWND* hwnd) IFACEMETHODIMP CPowerRenameUI::GetHwnd(_Out_ HWND* hwnd)
{ {
*hwnd = m_hwnd; *hwnd = m_hwnd;
return S_OK; return S_OK;
} }
IFACEMETHODIMP CPowerRenameUI::get_showUI(_Out_ bool* showUI) IFACEMETHODIMP CPowerRenameUI::GetShowUI(_Out_ bool* showUI)
{ {
// Let callers know that it is OK to show UI (ex: progress dialog, error dialog and conflict dialog UI) // Let callers know that it is OK to show UI (ex: progress dialog, error dialog and conflict dialog UI)
*showUI = true; *showUI = true;
@@ -171,12 +171,13 @@ IFACEMETHODIMP CPowerRenameUI::OnItemAdded(_In_ IPowerRenameItem*)
IFACEMETHODIMP CPowerRenameUI::OnUpdate(_In_ IPowerRenameItem*) IFACEMETHODIMP CPowerRenameUI::OnUpdate(_In_ IPowerRenameItem*)
{ {
UINT itemCount = 0; UINT visibleItemCount = 0;
if (m_spsrm) if (m_spsrm)
{ {
m_spsrm->GetItemCount(&itemCount); m_spsrm->GetVisibleItemCount(&visibleItemCount);
} }
m_listview.RedrawItems(0, itemCount); m_listview.SetItemCount(visibleItemCount);
m_listview.RedrawItems(0, visibleItemCount);
_UpdateCounts(); _UpdateCounts();
return S_OK; return S_OK;
} }
@@ -381,7 +382,7 @@ void CPowerRenameUI::_EnumerateItems(_In_ IUnknown* pdtobj)
m_disableCountUpdate = false; m_disableCountUpdate = false;
UINT itemCount = 0; UINT itemCount = 0;
m_spsrm->GetItemCount(&itemCount); m_spsrm->GetVisibleItemCount(&itemCount);
m_listview.SetItemCount(itemCount); m_listview.SetItemCount(itemCount);
_UpdateCounts(); _UpdateCounts();
@@ -396,14 +397,14 @@ HRESULT CPowerRenameUI::_ReadSettings()
if (CSettingsInstance().GetPersistState()) if (CSettingsInstance().GetPersistState())
{ {
flags = CSettingsInstance().GetFlags(); flags = CSettingsInstance().GetFlags();
m_spsrm->put_flags(flags); m_spsrm->PutFlags(flags);
SetDlgItemText(m_hwnd, IDC_EDIT_SEARCHFOR, CSettingsInstance().GetSearchText().c_str()); SetDlgItemText(m_hwnd, IDC_EDIT_SEARCHFOR, CSettingsInstance().GetSearchText().c_str());
SetDlgItemText(m_hwnd, IDC_EDIT_REPLACEWITH, CSettingsInstance().GetReplaceText().c_str()); SetDlgItemText(m_hwnd, IDC_EDIT_REPLACEWITH, CSettingsInstance().GetReplaceText().c_str());
} }
else else
{ {
m_spsrm->get_flags(&flags); m_spsrm->GetFlags(&flags);
} }
_SetCheckboxesFromFlags(flags); _SetCheckboxesFromFlags(flags);
@@ -417,7 +418,7 @@ HRESULT CPowerRenameUI::_WriteSettings()
if (CSettingsInstance().GetPersistState()) if (CSettingsInstance().GetPersistState())
{ {
DWORD flags = 0; DWORD flags = 0;
m_spsrm->get_flags(&flags); m_spsrm->GetFlags(&flags);
CSettingsInstance().SetFlags(flags); CSettingsInstance().SetFlags(flags);
wchar_t buffer[CSettings::MAX_INPUT_STRING_LEN]; wchar_t buffer[CSettings::MAX_INPUT_STRING_LEN];
@@ -736,12 +737,18 @@ BOOL CPowerRenameUI::_OnNotify(_In_ WPARAM wParam, _In_ LPARAM lParam)
LPNMHDR pnmdr = (LPNMHDR)lParam; LPNMHDR pnmdr = (LPNMHDR)lParam;
LPNMLISTVIEW pnmlv = (LPNMLISTVIEW)pnmdr; LPNMLISTVIEW pnmlv = (LPNMLISTVIEW)pnmdr;
NMLVEMPTYMARKUP* pnmMarkup = NULL; NMLVEMPTYMARKUP* pnmMarkup = NULL;
if (pnmdr) if (pnmdr)
{ {
BOOL checked = FALSE; BOOL checked = FALSE;
switch (pnmdr->code) switch (pnmdr->code)
{ {
case LVN_COLUMNCLICK:
if (m_spsrm)
{
m_listview.OnColumnClick(m_spsrm, ((LPNMLISTVIEW)lParam)->iSubItem);
}
break;
case HDN_ITEMSTATEICONCLICK: case HDN_ITEMSTATEICONCLICK:
if (m_spsrm) if (m_spsrm)
{ {
@@ -886,16 +893,16 @@ void CPowerRenameUI::_OnSearchReplaceChanged()
{ {
// Pass updated search and replace terms to the IPowerRenameRegEx handler // Pass updated search and replace terms to the IPowerRenameRegEx handler
CComPtr<IPowerRenameRegEx> spRegEx; CComPtr<IPowerRenameRegEx> spRegEx;
if (m_spsrm && SUCCEEDED(m_spsrm->get_renameRegEx(&spRegEx))) if (m_spsrm && SUCCEEDED(m_spsrm->GetRenameRegEx(&spRegEx)))
{ {
wchar_t buffer[CSettings::MAX_INPUT_STRING_LEN]; wchar_t buffer[CSettings::MAX_INPUT_STRING_LEN];
buffer[0] = L'\0'; buffer[0] = L'\0';
GetDlgItemText(m_hwnd, IDC_EDIT_SEARCHFOR, buffer, ARRAYSIZE(buffer)); GetDlgItemText(m_hwnd, IDC_EDIT_SEARCHFOR, buffer, ARRAYSIZE(buffer));
spRegEx->put_searchTerm(buffer); spRegEx->PutSearchTerm(buffer);
buffer[0] = L'\0'; buffer[0] = L'\0';
GetDlgItemText(m_hwnd, IDC_EDIT_REPLACEWITH, buffer, ARRAYSIZE(buffer)); GetDlgItemText(m_hwnd, IDC_EDIT_REPLACEWITH, buffer, ARRAYSIZE(buffer));
spRegEx->put_replaceTerm(buffer); spRegEx->PutReplaceTerm(buffer);
} }
} }
@@ -913,7 +920,7 @@ DWORD CPowerRenameUI::_GetFlagsFromCheckboxes()
// Ensure we update flags // Ensure we update flags
if (m_spsrm) if (m_spsrm)
{ {
m_spsrm->put_flags(flags); m_spsrm->PutFlags(flags);
} }
return flags; return flags;
@@ -1084,31 +1091,37 @@ void CPowerRenameListView::ToggleAll(_In_ IPowerRenameManager* psrm, _In_ bool s
{ {
if (m_hwndLV) if (m_hwndLV)
{ {
UINT itemCount = 0; UINT visibleItemCount = 0, itemCount = 0;
psrm->GetItemCount(&itemCount); psrm->GetItemCount(&itemCount);
for (UINT i = 0; i < itemCount; i++) for (UINT i = 0; i < itemCount; i++)
{ {
CComPtr<IPowerRenameItem> spItem; CComPtr<IPowerRenameItem> spItem;
if (SUCCEEDED(psrm->GetItemByIndex(i, &spItem))) if (SUCCEEDED(psrm->GetItemByIndex(i, &spItem)))
{ {
spItem->put_selected(selected); spItem->PutSelected(selected);
} }
} }
RedrawItems(0, itemCount); psrm->GetVisibleItemCount(&visibleItemCount);
SetItemCount(visibleItemCount);
RedrawItems(0, visibleItemCount);
} }
} }
void CPowerRenameListView::ToggleItem(_In_ IPowerRenameManager* psrm, _In_ int item) void CPowerRenameListView::ToggleItem(_In_ IPowerRenameManager* psrm, _In_ int item)
{ {
CComPtr<IPowerRenameItem> spItem; CComPtr<IPowerRenameItem> spItem;
if (SUCCEEDED(psrm->GetItemByIndex(item, &spItem))) if (SUCCEEDED(psrm->GetVisibleItemByIndex(item, &spItem)))
{ {
bool selected = false; bool selected = false;
spItem->get_selected(&selected); spItem->GetSelected(&selected);
spItem->put_selected(!selected); spItem->PutSelected(!selected);
RedrawItems(item, item);
UINT visibleItemCount = 0;
psrm->GetVisibleItemCount(&visibleItemCount);
SetItemCount(visibleItemCount);
RedrawItems(0, visibleItemCount);
} }
} }
@@ -1146,18 +1159,19 @@ void CPowerRenameListView::UpdateItemCheckState(_In_ IPowerRenameManager* psrm,
if (psrm && m_hwndLV && (iItem > -1)) if (psrm && m_hwndLV && (iItem > -1))
{ {
CComPtr<IPowerRenameItem> spItem; CComPtr<IPowerRenameItem> spItem;
if (SUCCEEDED(psrm->GetItemByIndex(iItem, &spItem))) if (SUCCEEDED(psrm->GetVisibleItemByIndex(iItem, &spItem)))
{ {
bool checked = ListView_GetCheckState(m_hwndLV, iItem); bool checked = ListView_GetCheckState(m_hwndLV, iItem);
spItem->put_selected(checked); spItem->PutSelected(checked);
UINT uSelected = (checked) ? LVIS_SELECTED : 0; UINT uSelected = (checked) ? LVIS_SELECTED : 0;
ListView_SetItemState(m_hwndLV, iItem, uSelected, LVIS_SELECTED); ListView_SetItemState(m_hwndLV, iItem, uSelected, LVIS_SELECTED);
// Update the rename column if necessary // Update the rename column if necessary
int id = 0; UINT visibleItemCount = 0;
spItem->get_id(&id); psrm->GetVisibleItemCount(&visibleItemCount);
RedrawItems(id, id); SetItemCount(visibleItemCount);
RedrawItems(0, visibleItemCount);
} }
// Get the total number of list items and compare it to what is selected // Get the total number of list items and compare it to what is selected
@@ -1174,7 +1188,7 @@ void CPowerRenameListView::UpdateItemCheckState(_In_ IPowerRenameManager* psrm,
void CPowerRenameListView::GetDisplayInfo(_In_ IPowerRenameManager* psrm, _Inout_ LV_DISPINFO* plvdi) void CPowerRenameListView::GetDisplayInfo(_In_ IPowerRenameManager* psrm, _Inout_ LV_DISPINFO* plvdi)
{ {
UINT count = 0; UINT count = 0;
psrm->GetItemCount(&count); psrm->GetVisibleItemCount(&count);
if (plvdi->item.iItem < 0 || plvdi->item.iItem > static_cast<int>(count)) if (plvdi->item.iItem < 0 || plvdi->item.iItem > static_cast<int>(count))
{ {
// Invalid index // Invalid index
@@ -1182,11 +1196,11 @@ void CPowerRenameListView::GetDisplayInfo(_In_ IPowerRenameManager* psrm, _Inout
} }
CComPtr<IPowerRenameItem> renameItem; CComPtr<IPowerRenameItem> renameItem;
if (SUCCEEDED(psrm->GetItemByIndex((int)plvdi->item.iItem, &renameItem))) if (SUCCEEDED(psrm->GetVisibleItemByIndex((int)plvdi->item.iItem, &renameItem)))
{ {
if (plvdi->item.mask & LVIF_IMAGE) if (plvdi->item.mask & LVIF_IMAGE)
{ {
renameItem->get_iconIndex(&plvdi->item.iImage); renameItem->GetIconIndex(&plvdi->item.iImage);
} }
if (plvdi->item.mask & LVIF_STATE) if (plvdi->item.mask & LVIF_STATE)
@@ -1194,7 +1208,7 @@ void CPowerRenameListView::GetDisplayInfo(_In_ IPowerRenameManager* psrm, _Inout
plvdi->item.stateMask = LVIS_STATEIMAGEMASK; plvdi->item.stateMask = LVIS_STATEIMAGEMASK;
bool isSelected = false; bool isSelected = false;
renameItem->get_selected(&isSelected); renameItem->GetSelected(&isSelected);
if (isSelected) if (isSelected)
{ {
// Turn check box on // Turn check box on
@@ -1210,14 +1224,14 @@ void CPowerRenameListView::GetDisplayInfo(_In_ IPowerRenameManager* psrm, _Inout
if (plvdi->item.mask & LVIF_PARAM) if (plvdi->item.mask & LVIF_PARAM)
{ {
int id = 0; int id = 0;
renameItem->get_id(&id); renameItem->GetId(&id);
plvdi->item.lParam = static_cast<LPARAM>(id); plvdi->item.lParam = static_cast<LPARAM>(id);
} }
if (plvdi->item.mask & LVIF_INDENT) if (plvdi->item.mask & LVIF_INDENT)
{ {
UINT depth = 0; UINT depth = 0;
renameItem->get_depth(&depth); renameItem->GetDepth(&depth);
plvdi->item.iIndent = static_cast<int>(depth); plvdi->item.iIndent = static_cast<int>(depth);
} }
@@ -1226,16 +1240,16 @@ void CPowerRenameListView::GetDisplayInfo(_In_ IPowerRenameManager* psrm, _Inout
PWSTR subItemText = nullptr; PWSTR subItemText = nullptr;
if (plvdi->item.iSubItem == COL_ORIGINAL_NAME) if (plvdi->item.iSubItem == COL_ORIGINAL_NAME)
{ {
renameItem->get_originalName(&subItemText); renameItem->GetOriginalName(&subItemText);
} }
else if (plvdi->item.iSubItem == COL_NEW_NAME) else if (plvdi->item.iSubItem == COL_NEW_NAME)
{ {
DWORD flags = 0; DWORD flags = 0;
psrm->get_flags(&flags); psrm->GetFlags(&flags);
bool shouldRename = false; bool shouldRename = false;
if (SUCCEEDED(renameItem->ShouldRenameItem(flags, &shouldRename)) && shouldRename) if (SUCCEEDED(renameItem->ShouldRenameItem(flags, &shouldRename)) && shouldRename)
{ {
renameItem->get_newName(&subItemText); renameItem->GetNewName(&subItemText);
} }
} }
@@ -1261,7 +1275,11 @@ void CPowerRenameListView::RedrawItems(_In_ int first, _In_ int last)
void CPowerRenameListView::SetItemCount(_In_ UINT itemCount) void CPowerRenameListView::SetItemCount(_In_ UINT itemCount)
{ {
ListView_SetItemCount(m_hwndLV, itemCount); if (m_itemCount != itemCount)
{
m_itemCount = itemCount;
ListView_SetItemCount(m_hwndLV, itemCount);
}
} }
void CPowerRenameListView::_UpdateColumns() void CPowerRenameListView::_UpdateColumns()
@@ -1344,3 +1362,72 @@ void CPowerRenameListView::_UpdateHeaderCheckState(_In_ bool check)
Header_SetItem(hwndHeader, 0, &hdi); Header_SetItem(hwndHeader, 0, &hdi);
} }
} }
void CPowerRenameListView::_UpdateHeaderFilterState(_In_ DWORD filter)
{
// Get a handle to the header of the columns
HWND hwndHeader = ListView_GetHeader(m_hwndLV);
if (hwndHeader)
{
wchar_t bufferOriginal[MAX_PATH] = { 0 };
bufferOriginal[0] = L'\0';
// Retrieve the existing header first so we
// don't trash the text already there
HDITEM hdiOriginal = { 0 };
hdiOriginal.mask = HDI_FORMAT | HDI_TEXT;
hdiOriginal.pszText = bufferOriginal;
hdiOriginal.cchTextMax = ARRAYSIZE(bufferOriginal);
Header_GetItem(hwndHeader, 0, &hdiOriginal);
if (filter == PowerRenameFilters::Selected || filter == PowerRenameFilters::FlagsApplicable)
{
hdiOriginal.fmt |= HDF_SORTDOWN;
}
else
{
hdiOriginal.fmt &= ~HDF_SORTDOWN;
}
Header_SetItem(hwndHeader, 0, &hdiOriginal);
wchar_t bufferRename[MAX_PATH] = { 0 };
bufferRename[0] = L'\0';
// Retrieve the existing header first so we
// don't trash the text already there
HDITEM hdiRename = { 0 };
hdiRename.mask = HDI_FORMAT | HDI_TEXT;
hdiRename.pszText = bufferRename;
hdiRename.cchTextMax = ARRAYSIZE(bufferRename);
Header_GetItem(hwndHeader, 1, &hdiRename);
if (filter == PowerRenameFilters::ShouldRename)
{
hdiRename.fmt |= HDF_SORTDOWN;
}
else
{
hdiRename.fmt &= ~HDF_SORTDOWN;
}
Header_SetItem(hwndHeader, 1, &hdiRename);
}
}
void CPowerRenameListView::OnColumnClick(_In_ IPowerRenameManager* psrm, _In_ int columnNumber)
{
DWORD filter = PowerRenameFilters::None;
psrm->SwitchFilter(columnNumber);
UINT visibleItemCount = 0;
psrm->GetVisibleItemCount(&visibleItemCount);
SetItemCount(visibleItemCount);
RedrawItems(0, visibleItemCount);
psrm->GetFilter(&filter);
_UpdateHeaderFilterState(filter);
}

7
src/modules/powerrename/ui/PowerRenameUI.h
View File

@@ -20,6 +20,7 @@ public:
void SetItemCount(_In_ UINT itemCount); void SetItemCount(_In_ UINT itemCount);
void OnKeyDown(_In_ IPowerRenameManager* psrm, _In_ LV_KEYDOWN* lvKeyDown); void OnKeyDown(_In_ IPowerRenameManager* psrm, _In_ LV_KEYDOWN* lvKeyDown);
void OnClickList(_In_ IPowerRenameManager* psrm, NM_LISTVIEW* pnmListView); void OnClickList(_In_ IPowerRenameManager* psrm, NM_LISTVIEW* pnmListView);
void OnColumnClick(_In_ IPowerRenameManager* psrm, _In_ int pnmListView);
void GetDisplayInfo(_In_ IPowerRenameManager* psrm, _Inout_ LV_DISPINFO* plvdi); void GetDisplayInfo(_In_ IPowerRenameManager* psrm, _Inout_ LV_DISPINFO* plvdi);
void OnSize(); void OnSize();
HWND GetHWND() { return m_hwndLV; } HWND GetHWND() { return m_hwndLV; }
@@ -28,7 +29,9 @@ private:
void _UpdateColumns(); void _UpdateColumns();
void _UpdateColumnSizes(); void _UpdateColumnSizes();
void _UpdateHeaderCheckState(_In_ bool check); void _UpdateHeaderCheckState(_In_ bool check);
void _UpdateHeaderFilterState(_In_ DWORD filter);
UINT m_itemCount = 0;
HWND m_hwndLV = nullptr; HWND m_hwndLV = nullptr;
}; };
@@ -51,8 +54,8 @@ public:
IFACEMETHODIMP Show(_In_opt_ HWND hwndParent); IFACEMETHODIMP Show(_In_opt_ HWND hwndParent);
IFACEMETHODIMP Close(); IFACEMETHODIMP Close();
IFACEMETHODIMP Update(); IFACEMETHODIMP Update();
IFACEMETHODIMP get_hwnd(_Out_ HWND* hwnd); IFACEMETHODIMP GetHwnd(_Out_ HWND* hwnd);
IFACEMETHODIMP get_showUI(_Out_ bool* showUI); IFACEMETHODIMP GetShowUI(_Out_ bool* showUI);
// IPowerRenameManagerEvents // IPowerRenameManagerEvents
IFACEMETHODIMP OnItemAdded(_In_ IPowerRenameItem* renameItem); IFACEMETHODIMP OnItemAdded(_In_ IPowerRenameItem* renameItem);

23
src/modules/powerrename/unittests/PowerRenameManagerTests.cpp
View File

@@ -68,31 +68,30 @@ namespace PowerRenameManagerTests
&item); &item);
int itemId = 0; int itemId = 0;
Assert::IsTrue(item->get_id(&itemId) == S_OK); Assert::IsTrue(item->GetId(&itemId) == S_OK);
mgr->AddItem(item); mgr->AddItem(item);
// Verify the item we added is the same from the event // Verify the item we added is the same from the event
Assert::IsTrue(mockMgrEvents->m_itemAdded != nullptr && mockMgrEvents->m_itemAdded == item); Assert::IsTrue(mockMgrEvents->m_itemAdded != nullptr && mockMgrEvents->m_itemAdded == item);
int eventItemId = 0; int eventItemId = 0;
Assert::IsTrue(mockMgrEvents->m_itemAdded->get_id(&eventItemId) == S_OK); Assert::IsTrue(mockMgrEvents->m_itemAdded->GetId(&eventItemId) == S_OK);
Assert::IsTrue(itemId == eventItemId); Assert::IsTrue(itemId == eventItemId);
} }
// TODO: Setup match and replace parameters // TODO: Setup match and replace parameters
wchar_t newReplaceTerm[MAX_PATH] = { 0 }; wchar_t newReplaceTerm[MAX_PATH] = { 0 };
CComPtr<IPowerRenameRegEx> renRegEx; CComPtr<IPowerRenameRegEx> renRegEx;
Assert::IsTrue(mgr->get_renameRegEx(&renRegEx) == S_OK); Assert::IsTrue(mgr->GetRenameRegEx(&renRegEx) == S_OK);
renRegEx->put_flags(flags); renRegEx->PutFlags(flags);
renRegEx->put_searchTerm(searchTerm.c_str()); renRegEx->PutSearchTerm(searchTerm.c_str());
if (isFileAttributesUsed(replaceTerm.c_str()) && SUCCEEDED(GetDatedFileName(newReplaceTerm, ARRAYSIZE(newReplaceTerm), replaceTerm.c_str(), LocalTime))) if (isFileAttributesUsed(replaceTerm.c_str()) && SUCCEEDED(GetDatedFileName(newReplaceTerm, ARRAYSIZE(newReplaceTerm), replaceTerm.c_str(), LocalTime)))
{ {
renRegEx->put_replaceTerm(newReplaceTerm); renRegEx->PutReplaceTerm(newReplaceTerm);
} }
else else
{ {
renRegEx->put_replaceTerm(replaceTerm.c_str()); renRegEx->PutReplaceTerm(replaceTerm.c_str());
} }
Sleep(1000); Sleep(1000);
// Perform the rename // Perform the rename
@@ -146,13 +145,13 @@ namespace PowerRenameManagerTests
CComPtr<IPowerRenameItem> item; CComPtr<IPowerRenameItem> item;
CMockPowerRenameItem::CreateInstance(L"foo", L"foo", 0, false, &item); CMockPowerRenameItem::CreateInstance(L"foo", L"foo", 0, false, &item);
int itemId = 0; int itemId = 0;
Assert::IsTrue(item->get_id(&itemId) == S_OK); Assert::IsTrue(item->GetId(&itemId) == S_OK);
mgr->AddItem(item); mgr->AddItem(item);
// Verify the item we added is the same from the event // Verify the item we added is the same from the event
Assert::IsTrue(mockMgrEvents->m_itemAdded != nullptr && mockMgrEvents->m_itemAdded == item); Assert::IsTrue(mockMgrEvents->m_itemAdded != nullptr && mockMgrEvents->m_itemAdded == item);
int eventItemId = 0; int eventItemId = 0;
Assert::IsTrue(mockMgrEvents->m_itemAdded->get_id(&eventItemId) == S_OK); Assert::IsTrue(mockMgrEvents->m_itemAdded->GetId(&eventItemId) == S_OK);
Assert::IsTrue(itemId == eventItemId); Assert::IsTrue(itemId == eventItemId);
Assert::IsTrue(mgr->Shutdown() == S_OK); Assert::IsTrue(mgr->Shutdown() == S_OK);
@@ -285,7 +284,7 @@ namespace PowerRenameManagerTests
{ {
rename_pairs renamePairs[] = { rename_pairs renamePairs[] = {
{ L"foo.FOO", L"foo.bar", false, true, 0 }, { L"foo.FOO", L"foo.bar", false, true, 0 },
{ L"foo.bar", L"foo.bar_rename", false, false, 0 } { L"foo.bar", L"foo.bar_norename", false, false, 0 }
}; };
RenameHelper(renamePairs, ARRAYSIZE(renamePairs), L"foo", L"bar", SYSTEMTIME{ 2020, 7, 3, 22, 15, 6, 42, 453 }, DEFAULT_FLAGS | Lowercase | ExtensionOnly); RenameHelper(renamePairs, ARRAYSIZE(renamePairs), L"foo", L"bar", SYSTEMTIME{ 2020, 7, 3, 22, 15, 6, 42, 453 }, DEFAULT_FLAGS | Lowercase | ExtensionOnly);

82
src/modules/powerrename/unittests/PowerRenameRegExTests.cpp
View File

@@ -22,8 +22,8 @@ namespace PowerRenameRegExTests
CComPtr<IPowerRenameRegEx> renameRegEx; CComPtr<IPowerRenameRegEx> renameRegEx;
Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK); Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
PWSTR result = nullptr; PWSTR result = nullptr;
Assert::IsTrue(renameRegEx->put_searchTerm(L"foo") == S_OK); Assert::IsTrue(renameRegEx->PutSearchTerm(L"foo") == S_OK);
Assert::IsTrue(renameRegEx->put_replaceTerm(L"big") == S_OK); Assert::IsTrue(renameRegEx->PutReplaceTerm(L"big") == S_OK);
Assert::IsTrue(renameRegEx->Replace(L"foobar", &result) == S_OK); Assert::IsTrue(renameRegEx->Replace(L"foobar", &result) == S_OK);
Assert::IsTrue(wcscmp(result, L"bigbar") == 0); Assert::IsTrue(wcscmp(result, L"bigbar") == 0);
CoTaskMemFree(result); CoTaskMemFree(result);
@@ -34,8 +34,8 @@ TEST_METHOD(ReplaceNoMatch)
CComPtr<IPowerRenameRegEx> renameRegEx; CComPtr<IPowerRenameRegEx> renameRegEx;
Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK); Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
PWSTR result = nullptr; PWSTR result = nullptr;
Assert::IsTrue(renameRegEx->put_searchTerm(L"notfound") == S_OK); Assert::IsTrue(renameRegEx->PutSearchTerm(L"notfound") == S_OK);
Assert::IsTrue(renameRegEx->put_replaceTerm(L"big") == S_OK); Assert::IsTrue(renameRegEx->PutReplaceTerm(L"big") == S_OK);
Assert::IsTrue(renameRegEx->Replace(L"foobar", &result) == S_OK); Assert::IsTrue(renameRegEx->Replace(L"foobar", &result) == S_OK);
Assert::IsTrue(wcscmp(result, L"foobar") == 0); Assert::IsTrue(wcscmp(result, L"foobar") == 0);
CoTaskMemFree(result); CoTaskMemFree(result);
@@ -56,7 +56,7 @@ TEST_METHOD(ReplaceNoReplaceTerm)
CComPtr<IPowerRenameRegEx> renameRegEx; CComPtr<IPowerRenameRegEx> renameRegEx;
Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK); Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
PWSTR result = nullptr; PWSTR result = nullptr;
Assert::IsTrue(renameRegEx->put_searchTerm(L"foo") == S_OK); Assert::IsTrue(renameRegEx->PutSearchTerm(L"foo") == S_OK);
Assert::IsTrue(renameRegEx->Replace(L"foobar", &result) == S_OK); Assert::IsTrue(renameRegEx->Replace(L"foobar", &result) == S_OK);
Assert::IsTrue(wcscmp(result, L"bar") == 0); Assert::IsTrue(wcscmp(result, L"bar") == 0);
CoTaskMemFree(result); CoTaskMemFree(result);
@@ -67,8 +67,8 @@ TEST_METHOD(ReplaceEmptyStringReplaceTerm)
CComPtr<IPowerRenameRegEx> renameRegEx; CComPtr<IPowerRenameRegEx> renameRegEx;
Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK); Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
PWSTR result = nullptr; PWSTR result = nullptr;
Assert::IsTrue(renameRegEx->put_searchTerm(L"foo") == S_OK); Assert::IsTrue(renameRegEx->PutSearchTerm(L"foo") == S_OK);
Assert::IsTrue(renameRegEx->put_replaceTerm(L"") == S_OK); Assert::IsTrue(renameRegEx->PutReplaceTerm(L"") == S_OK);
Assert::IsTrue(renameRegEx->Replace(L"foobar", &result) == S_OK); Assert::IsTrue(renameRegEx->Replace(L"foobar", &result) == S_OK);
Assert::IsTrue(wcscmp(result, L"bar") == 0); Assert::IsTrue(wcscmp(result, L"bar") == 0);
CoTaskMemFree(result); CoTaskMemFree(result);
@@ -79,7 +79,7 @@ TEST_METHOD(VerifyDefaultFlags)
CComPtr<IPowerRenameRegEx> renameRegEx; CComPtr<IPowerRenameRegEx> renameRegEx;
Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK); Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
DWORD flags = 0; DWORD flags = 0;
Assert::IsTrue(renameRegEx->get_flags(&flags) == S_OK); Assert::IsTrue(renameRegEx->GetFlags(&flags) == S_OK);
Assert::IsTrue(flags == MatchAllOccurences); Assert::IsTrue(flags == MatchAllOccurences);
} }
@@ -88,7 +88,7 @@ TEST_METHOD(VerifyCaseSensitiveSearch)
CComPtr<IPowerRenameRegEx> renameRegEx; CComPtr<IPowerRenameRegEx> renameRegEx;
Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK); Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
DWORD flags = CaseSensitive; DWORD flags = CaseSensitive;
Assert::IsTrue(renameRegEx->put_flags(flags) == S_OK); Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
SearchReplaceExpected sreTable[] = { SearchReplaceExpected sreTable[] = {
{ L"Foo", L"Foo", L"FooBar", L"FooBar" }, { L"Foo", L"Foo", L"FooBar", L"FooBar" },
@@ -100,8 +100,8 @@ TEST_METHOD(VerifyCaseSensitiveSearch)
for (int i = 0; i < ARRAYSIZE(sreTable); i++) for (int i = 0; i < ARRAYSIZE(sreTable); i++)
{ {
PWSTR result = nullptr; PWSTR result = nullptr;
Assert::IsTrue(renameRegEx->put_searchTerm(sreTable[i].search) == S_OK); Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
Assert::IsTrue(renameRegEx->put_replaceTerm(sreTable[i].replace) == S_OK); Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK); Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0); Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
CoTaskMemFree(result); CoTaskMemFree(result);
@@ -113,7 +113,7 @@ TEST_METHOD(VerifyReplaceFirstOnly)
CComPtr<IPowerRenameRegEx> renameRegEx; CComPtr<IPowerRenameRegEx> renameRegEx;
Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK); Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
DWORD flags = 0; DWORD flags = 0;
Assert::IsTrue(renameRegEx->put_flags(flags) == S_OK); Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
SearchReplaceExpected sreTable[] = { SearchReplaceExpected sreTable[] = {
{ L"B", L"BB", L"ABA", L"ABBA" }, { L"B", L"BB", L"ABA", L"ABBA" },
@@ -124,8 +124,8 @@ TEST_METHOD(VerifyReplaceFirstOnly)
for (int i = 0; i < ARRAYSIZE(sreTable); i++) for (int i = 0; i < ARRAYSIZE(sreTable); i++)
{ {
PWSTR result = nullptr; PWSTR result = nullptr;
Assert::IsTrue(renameRegEx->put_searchTerm(sreTable[i].search) == S_OK); Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
Assert::IsTrue(renameRegEx->put_replaceTerm(sreTable[i].replace) == S_OK); Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK); Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0); Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
CoTaskMemFree(result); CoTaskMemFree(result);
@@ -137,7 +137,7 @@ TEST_METHOD(VerifyReplaceAll)
CComPtr<IPowerRenameRegEx> renameRegEx; CComPtr<IPowerRenameRegEx> renameRegEx;
Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK); Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
DWORD flags = MatchAllOccurences; DWORD flags = MatchAllOccurences;
Assert::IsTrue(renameRegEx->put_flags(flags) == S_OK); Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
SearchReplaceExpected sreTable[] = { SearchReplaceExpected sreTable[] = {
{ L"B", L"BB", L"ABA", L"ABBA" }, { L"B", L"BB", L"ABA", L"ABBA" },
@@ -148,8 +148,8 @@ TEST_METHOD(VerifyReplaceAll)
for (int i = 0; i < ARRAYSIZE(sreTable); i++) for (int i = 0; i < ARRAYSIZE(sreTable); i++)
{ {
PWSTR result = nullptr; PWSTR result = nullptr;
Assert::IsTrue(renameRegEx->put_searchTerm(sreTable[i].search) == S_OK); Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
Assert::IsTrue(renameRegEx->put_replaceTerm(sreTable[i].replace) == S_OK); Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK); Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0); Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
CoTaskMemFree(result); CoTaskMemFree(result);
@@ -161,7 +161,7 @@ TEST_METHOD(VerifyReplaceAllCaseInsensitive)
CComPtr<IPowerRenameRegEx> renameRegEx; CComPtr<IPowerRenameRegEx> renameRegEx;
Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK); Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
DWORD flags = MatchAllOccurences | CaseSensitive; DWORD flags = MatchAllOccurences | CaseSensitive;
Assert::IsTrue(renameRegEx->put_flags(flags) == S_OK); Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
SearchReplaceExpected sreTable[] = { SearchReplaceExpected sreTable[] = {
{ L"B", L"BB", L"ABA", L"ABBA" }, { L"B", L"BB", L"ABA", L"ABBA" },
@@ -173,8 +173,8 @@ TEST_METHOD(VerifyReplaceAllCaseInsensitive)
for (int i = 0; i < ARRAYSIZE(sreTable); i++) for (int i = 0; i < ARRAYSIZE(sreTable); i++)
{ {
PWSTR result = nullptr; PWSTR result = nullptr;
Assert::IsTrue(renameRegEx->put_searchTerm(sreTable[i].search) == S_OK); Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
Assert::IsTrue(renameRegEx->put_replaceTerm(sreTable[i].replace) == S_OK); Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK); Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0); Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
CoTaskMemFree(result); CoTaskMemFree(result);
@@ -186,7 +186,7 @@ TEST_METHOD(VerifyReplaceFirstOnlyUseRegEx)
CComPtr<IPowerRenameRegEx> renameRegEx; CComPtr<IPowerRenameRegEx> renameRegEx;
Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK); Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
DWORD flags = UseRegularExpressions; DWORD flags = UseRegularExpressions;
Assert::IsTrue(renameRegEx->put_flags(flags) == S_OK); Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
SearchReplaceExpected sreTable[] = { SearchReplaceExpected sreTable[] = {
{ L"B", L"BB", L"ABA", L"ABBA" }, { L"B", L"BB", L"ABA", L"ABBA" },
@@ -197,8 +197,8 @@ TEST_METHOD(VerifyReplaceFirstOnlyUseRegEx)
for (int i = 0; i < ARRAYSIZE(sreTable); i++) for (int i = 0; i < ARRAYSIZE(sreTable); i++)
{ {
PWSTR result = nullptr; PWSTR result = nullptr;
Assert::IsTrue(renameRegEx->put_searchTerm(sreTable[i].search) == S_OK); Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
Assert::IsTrue(renameRegEx->put_replaceTerm(sreTable[i].replace) == S_OK); Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK); Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0); Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
CoTaskMemFree(result); CoTaskMemFree(result);
@@ -210,7 +210,7 @@ TEST_METHOD(VerifyReplaceAllUseRegEx)
CComPtr<IPowerRenameRegEx> renameRegEx; CComPtr<IPowerRenameRegEx> renameRegEx;
Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK); Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
DWORD flags = MatchAllOccurences | UseRegularExpressions; DWORD flags = MatchAllOccurences | UseRegularExpressions;
Assert::IsTrue(renameRegEx->put_flags(flags) == S_OK); Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
SearchReplaceExpected sreTable[] = { SearchReplaceExpected sreTable[] = {
{ L"B", L"BB", L"ABA", L"ABBA" }, { L"B", L"BB", L"ABA", L"ABBA" },
@@ -221,8 +221,8 @@ TEST_METHOD(VerifyReplaceAllUseRegEx)
for (int i = 0; i < ARRAYSIZE(sreTable); i++) for (int i = 0; i < ARRAYSIZE(sreTable); i++)
{ {
PWSTR result = nullptr; PWSTR result = nullptr;
Assert::IsTrue(renameRegEx->put_searchTerm(sreTable[i].search) == S_OK); Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
Assert::IsTrue(renameRegEx->put_replaceTerm(sreTable[i].replace) == S_OK); Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK); Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0); Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
CoTaskMemFree(result); CoTaskMemFree(result);
@@ -234,7 +234,7 @@ TEST_METHOD(VerifyReplaceAllUseRegExCaseSensitive)
CComPtr<IPowerRenameRegEx> renameRegEx; CComPtr<IPowerRenameRegEx> renameRegEx;
Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK); Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
DWORD flags = MatchAllOccurences | UseRegularExpressions | CaseSensitive; DWORD flags = MatchAllOccurences | UseRegularExpressions | CaseSensitive;
Assert::IsTrue(renameRegEx->put_flags(flags) == S_OK); Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
SearchReplaceExpected sreTable[] = { SearchReplaceExpected sreTable[] = {
{ L"B", L"BB", L"ABA", L"ABBA" }, { L"B", L"BB", L"ABA", L"ABBA" },
@@ -245,8 +245,8 @@ TEST_METHOD(VerifyReplaceAllUseRegExCaseSensitive)
for (int i = 0; i < ARRAYSIZE(sreTable); i++) for (int i = 0; i < ARRAYSIZE(sreTable); i++)
{ {
PWSTR result = nullptr; PWSTR result = nullptr;
Assert::IsTrue(renameRegEx->put_searchTerm(sreTable[i].search) == S_OK); Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
Assert::IsTrue(renameRegEx->put_replaceTerm(sreTable[i].replace) == S_OK); Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK); Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0); Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
CoTaskMemFree(result); CoTaskMemFree(result);
@@ -258,7 +258,7 @@ TEST_METHOD(VerifyMatchAllWildcardUseRegEx)
CComPtr<IPowerRenameRegEx> renameRegEx; CComPtr<IPowerRenameRegEx> renameRegEx;
Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK); Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
DWORD flags = MatchAllOccurences | UseRegularExpressions; DWORD flags = MatchAllOccurences | UseRegularExpressions;
Assert::IsTrue(renameRegEx->put_flags(flags) == S_OK); Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
SearchReplaceExpected sreTable[] = { SearchReplaceExpected sreTable[] = {
{ L".*", L"Foo", L"AAAAAA", L"Foo" }, { L".*", L"Foo", L"AAAAAA", L"Foo" },
@@ -267,8 +267,8 @@ TEST_METHOD(VerifyMatchAllWildcardUseRegEx)
for (int i = 0; i < ARRAYSIZE(sreTable); i++) for (int i = 0; i < ARRAYSIZE(sreTable); i++)
{ {
PWSTR result = nullptr; PWSTR result = nullptr;
Assert::IsTrue(renameRegEx->put_searchTerm(sreTable[i].search) == S_OK); Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
Assert::IsTrue(renameRegEx->put_replaceTerm(sreTable[i].replace) == S_OK); Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK); Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0); Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
CoTaskMemFree(result); CoTaskMemFree(result);
@@ -279,13 +279,13 @@ void VerifyReplaceFirstWildcard(SearchReplaceExpected sreTable[], int tableSize,
{ {
CComPtr<IPowerRenameRegEx> renameRegEx; CComPtr<IPowerRenameRegEx> renameRegEx;
Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK); Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
Assert::IsTrue(renameRegEx->put_flags(flags) == S_OK); Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
for (int i = 0; i < tableSize; i++) for (int i = 0; i < tableSize; i++)
{ {
PWSTR result = nullptr; PWSTR result = nullptr;
Assert::IsTrue(renameRegEx->put_searchTerm(sreTable[i].search) == S_OK); Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
Assert::IsTrue(renameRegEx->put_replaceTerm(sreTable[i].replace) == S_OK); Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK); Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
Assert::AreEqual(sreTable[i].expected, result); Assert::AreEqual(sreTable[i].expected, result);
CoTaskMemFree(result); CoTaskMemFree(result);
@@ -336,7 +336,7 @@ TEST_METHOD(VerifyHandleCapturingGroups)
CComPtr<IPowerRenameRegEx> renameRegEx; CComPtr<IPowerRenameRegEx> renameRegEx;
Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK); Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
DWORD flags = MatchAllOccurences | UseRegularExpressions | CaseSensitive; DWORD flags = MatchAllOccurences | UseRegularExpressions | CaseSensitive;
Assert::IsTrue(renameRegEx->put_flags(flags) == S_OK); Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
SearchReplaceExpected sreTable[] = { SearchReplaceExpected sreTable[] = {
//search, replace, test, result //search, replace, test, result
@@ -354,8 +354,8 @@ TEST_METHOD(VerifyHandleCapturingGroups)
for (int i = 0; i < ARRAYSIZE(sreTable); i++) for (int i = 0; i < ARRAYSIZE(sreTable); i++)
{ {
PWSTR result = nullptr; PWSTR result = nullptr;
Assert::IsTrue(renameRegEx->put_searchTerm(sreTable[i].search) == S_OK); Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
Assert::IsTrue(renameRegEx->put_replaceTerm(sreTable[i].replace) == S_OK); Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK); Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0); Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
CoTaskMemFree(result); CoTaskMemFree(result);
@@ -372,9 +372,9 @@ TEST_METHOD(VerifyEventsFire)
DWORD cookie = 0; DWORD cookie = 0;
Assert::IsTrue(renameRegEx->Advise(regExEvents, &cookie) == S_OK); Assert::IsTrue(renameRegEx->Advise(regExEvents, &cookie) == S_OK);
DWORD flags = MatchAllOccurences | UseRegularExpressions | CaseSensitive; DWORD flags = MatchAllOccurences | UseRegularExpressions | CaseSensitive;
Assert::IsTrue(renameRegEx->put_flags(flags) == S_OK); Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
Assert::IsTrue(renameRegEx->put_searchTerm(L"FOO") == S_OK); Assert::IsTrue(renameRegEx->PutSearchTerm(L"FOO") == S_OK);
Assert::IsTrue(renameRegEx->put_replaceTerm(L"BAR") == S_OK); Assert::IsTrue(renameRegEx->PutReplaceTerm(L"BAR") == S_OK);
Assert::IsTrue(lstrcmpi(L"FOO", mockEvents->m_searchTerm) == 0); Assert::IsTrue(lstrcmpi(L"FOO", mockEvents->m_searchTerm) == 0);
Assert::IsTrue(lstrcmpi(L"BAR", mockEvents->m_replaceTerm) == 0); Assert::IsTrue(lstrcmpi(L"BAR", mockEvents->m_replaceTerm) == 0);
Assert::IsTrue(flags == mockEvents->m_flags); Assert::IsTrue(flags == mockEvents->m_flags);