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

[PowerRename] Fluent UX (#13678)

Browse Source 
* PowerRename new UI

* Add scrollviewer

* Don't deploy PowerRenameUI_new

* Visual updates

* Visual updates

* Updates

* Update Resources.resw

* Added docs button

* Update MainWindow.xaml

* Wire Docs button

* RegEx -> regular expressions

* Update Show only renamed list on search/replace text changed

* Update Show only renamed list on search/replace text changed - proper fix
Set searchTerm to NULL when cleared - fix Show only renamed files on clear searchTerm

* Files/folders input error handling

* Fix renaming with keeping UI window opened

After renaming folder, all of it's children need path update.
Without path update, further renaming of children items would
fail.

* Update only children, not all items with greater depth

* Fix dictionary false positives

* Remove .NET dep

* Rename PowerRenameUI_new to PowerRenameUILib
Rename executable PowerRenameUIHost to PowerRename

Co-authored-by: Laute <Niels.Laute@philips.com>
This commit is contained in:
Stefan Markovic
2021-10-25 15:40:19 +02:00
committed by GitHub
parent ce942b0585
commit 5cfbd72fa8
128 changed files with 5759 additions and 8196 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -7,6 +7,13 @@
namespace fs = std::filesystem;
namespace
{
const int MAX_INPUT_STRING_LEN = 1024;
const wchar_t c_rootRegPath[] = L"Software\\Microsoft\\PowerRename";
}
HRESULT GetTrimmedFileName(_Out_ PWSTR result, UINT cchMax, _In_ PCWSTR source)
{
HRESULT hr = E_INVALIDARG;
@@ -545,3 +552,56 @@ HWND CreateMsgWindow(_In_ HINSTANCE hInst, _In_ WNDPROC pfnWndProc, _In_ void* p
return hwnd;
}
std::wstring GetRegString(const std::wstring& valueName, const std::wstring& subPath)
{
wchar_t value[MAX_INPUT_STRING_LEN];
value[0] = L'\0';
DWORD type = REG_SZ;
DWORD size = MAX_INPUT_STRING_LEN * sizeof(wchar_t);
std::wstring completePath = std::wstring(c_rootRegPath) + subPath;
if (SHGetValue(HKEY_CURRENT_USER, completePath.c_str(), valueName.c_str(), &type, value, &size) == ERROR_SUCCESS)
{
return std::wstring(value);
}
return std::wstring{};
}
unsigned int GetRegNumber(const std::wstring& valueName, unsigned int defaultValue)
{
DWORD type = REG_DWORD;
DWORD data = 0;
DWORD size = sizeof(DWORD);
if (SHGetValue(HKEY_CURRENT_USER, c_rootRegPath, valueName.c_str(), &type, &data, &size) == ERROR_SUCCESS)
{
return data;
}
return defaultValue;
}
void SetRegNumber(const std::wstring& valueName, unsigned int value)
{
SHSetValue(HKEY_CURRENT_USER, c_rootRegPath, valueName.c_str(), REG_DWORD, &value, sizeof(value));
}
bool GetRegBoolean(const std::wstring& valueName, bool defaultValue)
{
DWORD value = GetRegNumber(valueName.c_str(), defaultValue ? 1 : 0);
return (value == 0) ? false : true;
}
void SetRegBoolean(const std::wstring& valueName, bool value)
{
SetRegNumber(valueName, value ? 1 : 0);
}
bool LastModifiedTime(const std::wstring& filePath, FILETIME* lpFileTime)
{
WIN32_FILE_ATTRIBUTE_DATA attr{};
if (GetFileAttributesExW(filePath.c_str(), GetFileExInfoStandard, &attr))
{
*lpFileTime = attr.ftLastWriteTime;
return true;
}
return false;
}

11
src/modules/powerrename/lib/Helpers.h
View File

@@ -1,6 +1,8 @@
#pragma once
#include <lib/PowerRenameInterfaces.h>
#include "PowerRenameInterfaces.h"
#include <string>
HRESULT GetTrimmedFileName(_Out_ PWSTR result, UINT cchMax, _In_ PCWSTR source);
HRESULT GetTransformedFileName(_Out_ PWSTR result, UINT cchMax, _In_ PCWSTR source, DWORD flags);
@@ -16,3 +18,10 @@ BOOL GetEnumeratedFileName(
unsigned long ulMinLong,
__inout unsigned long* pulNumUsed);
HWND CreateMsgWindow(_In_ HINSTANCE hInst, _In_ WNDPROC pfnWndProc, _In_ void* p);
std::wstring GetRegString(const std::wstring& valueName, const std::wstring& subPath);
unsigned int GetRegNumber(const std::wstring& valueName, unsigned int defaultValue);
void SetRegNumber(const std::wstring& valueName, unsigned int value);
bool GetRegBoolean(const std::wstring& valueName, bool defaultValue);
void SetRegBoolean(const std::wstring& valueName, bool value);
bool LastModifiedTime(const std::wstring& filePath, FILETIME* lpFileTime);

181
src/modules/powerrename/lib/MRUListHandler.cpp Normal file
View File

@@ -0,0 +1,181 @@
#include "pch.h"
#include "MRUListHandler.h"
#include "Helpers.h"
#include <dll/PowerRenameConstants.h>
#include <common/SettingsAPI/settings_helpers.h>
namespace
{
const wchar_t c_mruList[] = L"MRUList";
const wchar_t c_insertionIdx[] = L"InsertionIdx";
const wchar_t c_maxMRUSize[] = L"MaxMRUSize";
}
MRUListHandler::MRUListHandler(unsigned int size, const std::wstring& filePath, const std::wstring& regPath) :
pushIdx(0),
nextIdx(1),
size(size),
jsonFilePath(PTSettingsHelper::get_module_save_folder_location(PowerRenameConstants::ModuleKey) + filePath),
registryFilePath(regPath)
{
items.resize(size);
Load();
}
void MRUListHandler::Push(const std::wstring& data)
{
if (Exists(data))
{
// TODO: Already existing item should be put on top of MRU list.
return;
}
items[pushIdx] = data;
pushIdx = (pushIdx + 1) % size;
Save();
}
bool MRUListHandler::Next(std::wstring& data)
{
if (nextIdx == size + 1)
{
Reset();
return false;
}
// Go backwards to consume latest items first.
unsigned int idx = (pushIdx + size - nextIdx) % size;
if (items[idx].empty())
{
Reset();
return false;
}
data = items[idx];
++nextIdx;
return true;
}
void MRUListHandler::Reset()
{
nextIdx = 1;
}
const std::vector<std::wstring>& MRUListHandler::GetItems()
{
return items;
}
void MRUListHandler::Load()
{
if (!std::filesystem::exists(jsonFilePath))
{
MigrateFromRegistry();
Save();
}
else
{
ParseJson();
}
}
void MRUListHandler::Save()
{
json::JsonObject jsonData;
jsonData.SetNamedValue(c_maxMRUSize, json::value(size));
jsonData.SetNamedValue(c_insertionIdx, json::value(pushIdx));
jsonData.SetNamedValue(c_mruList, Serialize());
json::to_file(jsonFilePath, jsonData);
}
json::JsonArray MRUListHandler::Serialize()
{
json::JsonArray searchMRU{};
std::wstring data{};
for (const std::wstring& item : items)
{
searchMRU.Append(json::value(item));
}
return searchMRU;
}
void MRUListHandler::MigrateFromRegistry()
{
std::wstring searchListKeys = GetRegString(c_mruList, registryFilePath);
std::sort(std::begin(searchListKeys), std::end(searchListKeys));
for (const wchar_t& key : searchListKeys)
{
Push(GetRegString(std::wstring(1, key), registryFilePath));
}
}
void MRUListHandler::ParseJson()
{
auto json = json::from_file(jsonFilePath);
if (json)
{
const json::JsonObject& jsonObject = json.value();
try
{
unsigned int oldSize{ size };
if (json::has(jsonObject, c_maxMRUSize, json::JsonValueType::Number))
{
oldSize = (unsigned int)jsonObject.GetNamedNumber(c_maxMRUSize);
}
unsigned int oldPushIdx{ 0 };
if (json::has(jsonObject, c_insertionIdx, json::JsonValueType::Number))
{
oldPushIdx = (unsigned int)jsonObject.GetNamedNumber(c_insertionIdx);
if (oldPushIdx < 0 || oldPushIdx >= oldSize)
{
oldPushIdx = 0;
}
}
if (json::has(jsonObject, c_mruList, json::JsonValueType::Array))
{
auto jsonArray = jsonObject.GetNamedArray(c_mruList);
if (oldSize == size)
{
for (uint32_t i = 0; i < jsonArray.Size(); ++i)
{
items[i] = std::wstring(jsonArray.GetStringAt(i));
}
pushIdx = oldPushIdx;
}
else
{
std::vector<std::wstring> temp;
for (unsigned int i = 0; i < min(jsonArray.Size(), size); ++i)
{
int idx = (oldPushIdx + oldSize - (i + 1)) % oldSize;
temp.push_back(std::wstring(jsonArray.GetStringAt(idx)));
}
if (size > oldSize)
{
std::reverse(std::begin(temp), std::end(temp));
pushIdx = (unsigned int)temp.size();
temp.resize(size);
}
else
{
temp.resize(size);
std::reverse(std::begin(temp), std::end(temp));
}
items = std::move(temp);
Save();
}
}
}
catch (const winrt::hresult_error&)
{
}
}
}
bool MRUListHandler::Exists(const std::wstring& data)
{
return std::find(std::begin(items), std::end(items), data) != std::end(items);
}

35
src/modules/powerrename/lib/MRUListHandler.h Normal file
View File

@@ -0,0 +1,35 @@
#pragma once
#include "pch.h"
#include <filesystem>
#include <string>
#include <common/utils/json.h>
class MRUListHandler
{
public:
MRUListHandler(unsigned int size, const std::wstring& filePath, const std::wstring& regPath);
void Push(const std::wstring& data);
bool Next(std::wstring& data);
void Reset();
const std::vector<std::wstring>& GetItems();
private:
void Load();
void Save();
void MigrateFromRegistry();
json::JsonArray Serialize();
void ParseJson();
bool Exists(const std::wstring& data);
std::vector<std::wstring> items;
unsigned int pushIdx;
unsigned int nextIdx;
unsigned int size;
const std::wstring jsonFilePath;
const std::wstring registryFilePath;
};

14
src/modules/powerrename/lib/PowerRenameEnum.cpp
View File

@@ -28,20 +28,10 @@ IFACEMETHODIMP CPowerRenameEnum::QueryInterface(_In_ REFIID riid, _Outptr_ void*
return QISearch(this, qit, riid, ppv);
}
IFACEMETHODIMP CPowerRenameEnum::Start()
IFACEMETHODIMP CPowerRenameEnum::Start(_In_ IEnumShellItems* enumShellItems)
{
m_canceled = false;
CComPtr<IShellItemArray> spsia;
HRESULT hr = GetShellItemArrayFromDataObject(m_spdo, &spsia);
if (SUCCEEDED(hr))
{
CComPtr<IEnumShellItems> spesi;
hr = spsia->EnumItems(&spesi);
if (SUCCEEDED(hr))
{
hr = _ParseEnumItems(spesi);
}
}
HRESULT hr = _ParseEnumItems(enumShellItems);
return hr;
}

2
src/modules/powerrename/lib/PowerRenameEnum.h
View File

@@ -14,7 +14,7 @@ public:
IFACEMETHODIMP_(ULONG) Release();
// ISmartRenameEnum
IFACEMETHODIMP Start();
IFACEMETHODIMP Start(_In_ IEnumShellItems* enumShellItems);
IFACEMETHODIMP Cancel();
public:

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

@@ -1,5 +1,7 @@
#pragma once
#include "pch.h"
#include <string>
#include <vector>
enum PowerRenameFlags
{
@@ -41,9 +43,9 @@ public:
IFACEMETHOD(Advise)(_In_ IPowerRenameRegExEvents* regExEvents, _Out_ DWORD* cookie) = 0;
IFACEMETHOD(UnAdvise)(_In_ DWORD cookie) = 0;
IFACEMETHOD(GetSearchTerm)(_Outptr_ PWSTR* searchTerm) = 0;
IFACEMETHOD(PutSearchTerm)(_In_ PCWSTR searchTerm) = 0;
IFACEMETHOD(PutSearchTerm)(_In_ PCWSTR searchTerm, bool forceRenaming = false) = 0;
IFACEMETHOD(GetReplaceTerm)(_Outptr_ PWSTR* replaceTerm) = 0;
IFACEMETHOD(PutReplaceTerm)(_In_ PCWSTR replaceTerm) = 0;
IFACEMETHOD(PutReplaceTerm)(_In_ PCWSTR replaceTerm, bool forceRenaming = false) = 0;
IFACEMETHOD(GetFlags)(_Out_ DWORD* flags) = 0;
IFACEMETHOD(PutFlags)(_In_ DWORD flags) = 0;
IFACEMETHOD(PutFileTime)(_In_ SYSTEMTIME fileTime) = 0;
@@ -54,11 +56,13 @@ public:
interface __declspec(uuid("C7F59201-4DE1-4855-A3A2-26FC3279C8A5")) IPowerRenameItem : public IUnknown
{
public:
IFACEMETHOD(GetPath)(_Outptr_ PWSTR* path) = 0;
IFACEMETHOD(PutPath)(_In_opt_ PCWSTR newPath) = 0;
IFACEMETHOD(GetPath)(_Outptr_ PWSTR * path) = 0;
IFACEMETHOD(GetTime)(_Outptr_ SYSTEMTIME* time) = 0;
IFACEMETHOD(GetShellItem)(_Outptr_ IShellItem** ppsi) = 0;
IFACEMETHOD(GetOriginalName)(_Outptr_ PWSTR* originalName) = 0;
IFACEMETHOD(GetNewName)(_Outptr_ PWSTR* newName) = 0;
IFACEMETHOD(GetOriginalName)(_Outptr_ PWSTR * originalName) = 0;
IFACEMETHOD(PutOriginalName)(_In_opt_ PCWSTR 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;
@@ -83,13 +87,14 @@ interface __declspec(uuid("87FC43F9-7634-43D9-99A5-20876AFCE4AD")) IPowerRenameM
{
public:
IFACEMETHOD(OnItemAdded)(_In_ IPowerRenameItem* renameItem) = 0;
IFACEMETHOD(OnUpdate)(_In_ IPowerRenameItem* renameItem) = 0;
IFACEMETHOD(OnError)(_In_ IPowerRenameItem* renameItem) = 0;
IFACEMETHOD(OnUpdate)(_In_ IPowerRenameItem * renameItem) = 0;
IFACEMETHOD(OnRename)(_In_ IPowerRenameItem * renameItem) = 0;
IFACEMETHOD(OnError)(_In_ IPowerRenameItem * renameItem) = 0;
IFACEMETHOD(OnRegExStarted)(_In_ DWORD threadId) = 0;
IFACEMETHOD(OnRegExCanceled)(_In_ DWORD threadId) = 0;
IFACEMETHOD(OnRegExCompleted)(_In_ DWORD threadId) = 0;
IFACEMETHOD(OnRenameStarted)() = 0;
IFACEMETHOD(OnRenameCompleted)() = 0;
IFACEMETHOD(OnRenameCompleted)(_In_ bool closeUIWindowAfterRenaming) = 0;
};
interface __declspec(uuid("001BBD88-53D2-4FA6-95D2-F9A9FA4F9F70")) IPowerRenameManager : public IUnknown
@@ -101,8 +106,10 @@ public:
IFACEMETHOD(Stop)() = 0;
IFACEMETHOD(Reset)() = 0;
IFACEMETHOD(Shutdown)() = 0;
IFACEMETHOD(Rename)(_In_ HWND hwndParent) = 0;
IFACEMETHOD(AddItem)(_In_ IPowerRenameItem* pItem) = 0;
IFACEMETHOD(Rename)(_In_ HWND hwndParent, _In_ bool closeWindow) = 0;
IFACEMETHOD(UpdateChildrenPath)(_In_ int parentId, _In_ size_t oldParentPathSize) = 0;
IFACEMETHOD(GetCloseUIWindowAfterRenaming)(_Out_ bool* closeUIWindowAfterRenaming) = 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;
@@ -113,7 +120,7 @@ public:
IFACEMETHOD(GetRenameItemCount)(_Out_ UINT* count) = 0;
IFACEMETHOD(GetFlags)(_Out_ DWORD* flags) = 0;
IFACEMETHOD(PutFlags)(_In_ DWORD flags) = 0;
IFACEMETHOD(GetFilter)(_Out_ DWORD * filter) = 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;
@@ -121,23 +128,17 @@ public:
IFACEMETHOD(PutRenameItemFactory)(_In_ IPowerRenameItemFactory* pItemFactory) = 0;
};
interface __declspec(uuid("E6679DEB-460D-42C1-A7A8-E25897061C99")) IPowerRenameUI : public IUnknown
{
public:
IFACEMETHOD(Show)(_In_opt_ HWND hwndParent) = 0;
IFACEMETHOD(Close)() = 0;
IFACEMETHOD(Update)() = 0;
};
interface __declspec(uuid("04AAFABE-B76E-4E13-993A-B5941F52B139")) IPowerRenameMRU : public IUnknown
{
public:
IFACEMETHOD(AddMRUString)(_In_ PCWSTR entry) = 0;
IFACEMETHOD_(const std::vector<std::wstring>&, GetMRUStrings)() = 0;
};
interface __declspec(uuid("CE8C8616-C1A8-457A-9601-10570F5B9F1F")) IPowerRenameEnum : public IUnknown
{
public:
IFACEMETHOD(Start)() = 0;
IFACEMETHOD(Start)
(_In_ IEnumShellItems * enumShellItems) = 0;
IFACEMETHOD(Cancel)() = 0;
};

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

@@ -32,6 +32,19 @@ IFACEMETHODIMP CPowerRenameItem::QueryInterface(_In_ REFIID riid, _Outptr_ void*
return QISearch(this, qit, riid, ppv);
}
IFACEMETHODIMP CPowerRenameItem::PutPath(_In_opt_ PCWSTR newPath)
{
CSRWSharedAutoLock lock(&m_lock);
CoTaskMemFree(m_path);
m_path = nullptr;
HRESULT hr = S_OK;
if (newPath != nullptr)
{
hr = SHStrDup(newPath, &m_path);
}
return hr;
}
IFACEMETHODIMP CPowerRenameItem::GetPath(_Outptr_ PWSTR* path)
{
*path = nullptr;
@@ -47,7 +60,7 @@ IFACEMETHODIMP CPowerRenameItem::GetPath(_Outptr_ PWSTR* path)
IFACEMETHODIMP CPowerRenameItem::GetTime(_Outptr_ SYSTEMTIME* time)
{
CSRWSharedAutoLock lock(&m_lock);
HRESULT hr = E_FAIL ;
HRESULT hr = E_FAIL;
if (m_isTimeParsed)
{
@@ -84,6 +97,19 @@ IFACEMETHODIMP CPowerRenameItem::GetShellItem(_Outptr_ IShellItem** ppsi)
return SHCreateItemFromParsingName(m_path, nullptr, IID_PPV_ARGS(ppsi));
}
IFACEMETHODIMP CPowerRenameItem::PutOriginalName(_In_opt_ PCWSTR originalName)
{
CSRWSharedAutoLock lock(&m_lock);
CoTaskMemFree(m_originalName);
m_originalName = nullptr;
HRESULT hr = S_OK;
if (originalName != nullptr)
{
hr = SHStrDup(originalName, &m_originalName);
}
return hr;
}
IFACEMETHODIMP CPowerRenameItem::GetOriginalName(_Outptr_ PWSTR* originalName)
{
CSRWSharedAutoLock lock(&m_lock);
@@ -223,11 +249,11 @@ HRESULT CPowerRenameItem::s_CreateInstance(_In_opt_ IShellItem* psi, _In_ REFIID
{
*resultInterface = nullptr;
CPowerRenameItem *newRenameItem = new CPowerRenameItem();
CPowerRenameItem* newRenameItem = new CPowerRenameItem();
HRESULT hr = E_OUTOFMEMORY;
if (newRenameItem)
{
hr = S_OK ;
hr = S_OK;
if (psi != nullptr)
{
hr = newRenameItem->_Init(psi);

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

@@ -14,9 +14,11 @@ public:
IFACEMETHODIMP_(ULONG) Release();
// IPowerRenameItem
IFACEMETHODIMP PutPath(_In_opt_ PCWSTR newPath);
IFACEMETHODIMP GetPath(_Outptr_ PWSTR* path);
IFACEMETHODIMP GetTime(_Outptr_ SYSTEMTIME* time);
IFACEMETHODIMP GetShellItem(_Outptr_ IShellItem** ppsi);
IFACEMETHODIMP PutOriginalName(_In_opt_ PCWSTR originalName);
IFACEMETHODIMP GetOriginalName(_Outptr_ PWSTR* originalName);
IFACEMETHODIMP PutNewName(_In_opt_ PCWSTR newName);
IFACEMETHODIMP GetNewName(_Outptr_ PWSTR* newName);

7
src/modules/powerrename/lib/PowerRenameLib.vcxproj
View File

@@ -40,10 +40,12 @@
</ItemDefinitionGroup>
<ItemGroup>
<ClInclude Include="Helpers.h" />
<ClInclude Include="MRUListHandler.h" />
<ClInclude Include="PowerRenameEnum.h" />
<ClInclude Include="PowerRenameItem.h" />
<ClInclude Include="PowerRenameInterfaces.h" />
<ClInclude Include="PowerRenameManager.h" />
<ClInclude Include="PowerRenameMRU.h" />
<ClInclude Include="PowerRenameRegEx.h" />
<ClInclude Include="Settings.h" />
<ClInclude Include="srwlock.h" />
@@ -53,9 +55,11 @@
</ItemGroup>
<ItemGroup>
<ClCompile Include="Helpers.cpp" />
<ClCompile Include="MRUListHandler.cpp" />
<ClCompile Include="PowerRenameEnum.cpp" />
<ClCompile Include="PowerRenameItem.cpp" />
<ClCompile Include="PowerRenameManager.cpp" />
<ClCompile Include="PowerRenameMRU.cpp" />
<ClCompile Include="PowerRenameRegEx.cpp" />
<ClCompile Include="Settings.cpp" />
<ClCompile Include="pch.cpp">
@@ -70,6 +74,9 @@
<ProjectReference Include="..\..\..\common\SettingsAPI\SetttingsAPI.vcxproj">
<Project>{6955446d-23f7-4023-9bb3-8657f904af99}</Project>
</ProjectReference>
<ProjectReference Include="..\..\..\common\Themes\Themes.vcxproj">
<Project>{98537082-0fdb-40de-abd8-0dc5a4269bab}</Project>
</ProjectReference>
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">

87
src/modules/powerrename/lib/PowerRenameMRU.cpp Normal file
View File

@@ -0,0 +1,87 @@
#include "pch.h"
#include "PowerRenameMRU.h"
#include "Settings.h"
namespace
{
const wchar_t c_searchMRUListFilePath[] = L"\\search-mru.json";
const wchar_t c_replaceMRUListFilePath[] = L"\\replace-mru.json";
const wchar_t c_mruSearchRegPath[] = L"\\SearchMRU";
const wchar_t c_mruReplaceRegPath[] = L"\\ReplaceMRU";
}
CPowerRenameMRU::CPowerRenameMRU(int size, const std::wstring& filePath, const std::wstring& regPath) :
refCount(1)
{
mruList = std::make_unique<MRUListHandler>(size, filePath, regPath);
}
HRESULT CPowerRenameMRU::CreateInstance(_In_ const std::wstring& filePath, _In_ const std::wstring& regPath, _In_ REFIID iid, _Outptr_ void** resultInterface)
{
*resultInterface = nullptr;
unsigned int maxMRUSize = CSettingsInstance().GetMaxMRUSize();
HRESULT hr = E_FAIL;
if (maxMRUSize > 0)
{
CPowerRenameMRU* renameMRU = new CPowerRenameMRU(maxMRUSize, filePath, regPath);
hr = E_OUTOFMEMORY;
if (renameMRU)
{
renameMRU->QueryInterface(iid, resultInterface);
renameMRU->Release();
hr = S_OK;
}
}
return hr;
}
IFACEMETHODIMP_(ULONG)
CPowerRenameMRU::AddRef()
{
return InterlockedIncrement(&refCount);
}
IFACEMETHODIMP_(ULONG)
CPowerRenameMRU::Release()
{
unsigned int cnt = InterlockedDecrement(&refCount);
if (cnt == 0)
{
delete this;
}
return cnt;
}
IFACEMETHODIMP CPowerRenameMRU::QueryInterface(_In_ REFIID riid, _Outptr_ void** ppv)
{
static const QITAB qit[] = {
QITABENT(CPowerRenameMRU, IEnumString),
QITABENT(CPowerRenameMRU, IPowerRenameMRU),
{ 0 }
};
return QISearch(this, qit, riid, ppv);
}
IFACEMETHODIMP_(const std::vector<std::wstring>&) CPowerRenameMRU::GetMRUStrings()
{
return mruList->GetItems();
}
IFACEMETHODIMP CPowerRenameMRU::AddMRUString(_In_ PCWSTR entry)
{
mruList->Push(entry);
return S_OK;
}
HRESULT CPowerRenameMRU::CPowerRenameMRUSearch_CreateInstance(_Outptr_ IPowerRenameMRU** ppUnk)
{
return CPowerRenameMRU::CreateInstance(c_searchMRUListFilePath, c_mruSearchRegPath, IID_PPV_ARGS(ppUnk));
}
HRESULT CPowerRenameMRU::CPowerRenameMRUReplace_CreateInstance(_Outptr_ IPowerRenameMRU** ppUnk)
{
return CPowerRenameMRU::CreateInstance(c_replaceMRUListFilePath, c_mruReplaceRegPath, IID_PPV_ARGS(ppUnk));
}

34
src/modules/powerrename/lib/PowerRenameMRU.h Normal file
View File

@@ -0,0 +1,34 @@
#pragma once
#include "pch.h"
#include "PowerRenameInterfaces.h"
#include "MRUListHandler.h"
#include <string>
#include <memory>
#include <vector>
class CPowerRenameMRU :
public IPowerRenameMRU
{
public:
// IUnknown
IFACEMETHODIMP_(ULONG)
AddRef();
IFACEMETHODIMP_(ULONG)
Release();
IFACEMETHODIMP QueryInterface(_In_ REFIID riid, _Outptr_ void** ppv);
// IPowerRenameMRU
IFACEMETHODIMP AddMRUString(_In_ PCWSTR entry);
IFACEMETHODIMP_(const std::vector<std::wstring>&) GetMRUStrings();
static HRESULT CPowerRenameMRUSearch_CreateInstance(_Outptr_ IPowerRenameMRU** ppUnk);
static HRESULT CPowerRenameMRUReplace_CreateInstance(_Outptr_ IPowerRenameMRU** ppUnk);
private:
static HRESULT CreateInstance(_In_ const std::wstring& filePath, _In_ const std::wstring& regPath, _In_ REFIID iid, _Outptr_ void** resultInterface);
CPowerRenameMRU(int size, const std::wstring& filePath, const std::wstring& regPath);
std::unique_ptr<MRUListHandler> mruList;
unsigned int refCount = 0;
};

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

@@ -11,7 +11,7 @@
namespace fs = std::filesystem;
extern HINSTANCE g_hInst;
extern HINSTANCE g_hostHInst;
// The default FOF flags to use in the rename operations
#define FOF_DEFAULTFLAGS (FOF_ALLOWUNDO | FOFX_ADDUNDORECORD | FOFX_SHOWELEVATIONPROMPT | FOF_RENAMEONCOLLISION)
@@ -92,12 +92,56 @@ IFACEMETHODIMP CPowerRenameManager::Stop()
return E_NOTIMPL;
}
IFACEMETHODIMP CPowerRenameManager::Rename(_In_ HWND hwndParent)
IFACEMETHODIMP CPowerRenameManager::Rename(_In_ HWND hwndParent, bool closeWindow)
{
m_hwndParent = hwndParent;
m_closeUIWindowAfterRenaming = closeWindow;
return _PerformFileOperation();
}
IFACEMETHODIMP CPowerRenameManager::UpdateChildrenPath(_In_ int parentId, _In_ size_t oldParentPathSize)
{
auto parentIt = m_renameItems.find(parentId);
if (parentIt != m_renameItems.end())
{
UINT depth = 0;
winrt::check_hresult(parentIt->second->GetDepth(&depth));
PWSTR renamedPath = nullptr;
winrt::check_hresult(parentIt->second->GetPath(&renamedPath));
std::wstring renamedPathStr{ renamedPath };
for (auto it = ++parentIt; it != m_renameItems.end(); ++it)
{
UINT nextDepth = 0;
winrt::check_hresult(it->second->GetDepth(&nextDepth));
if (nextDepth > depth)
{
// This is child, update path
PWSTR path = nullptr;
winrt::check_hresult(it->second->GetPath(&path));
std::wstring pathStr{ path };
std::wstring newPath = pathStr.replace(0, oldParentPathSize, renamedPath);
it->second->PutPath(newPath.c_str());
}
else
{
break;
}
}
}
return S_OK;
}
IFACEMETHODIMP CPowerRenameManager::GetCloseUIWindowAfterRenaming(_Out_ bool* closeUIWindowAfterRenaming)
{
*closeUIWindowAfterRenaming = m_closeUIWindowAfterRenaming;
return S_OK;
}
IFACEMETHODIMP CPowerRenameManager::Reset()
{
// Stop all threads and wait
@@ -338,21 +382,15 @@ IFACEMETHODIMP CPowerRenameManager::GetFilter(_Out_ DWORD* filter)
return S_OK;
}
IFACEMETHODIMP CPowerRenameManager::SwitchFilter(_In_ int columnNumber)
IFACEMETHODIMP CPowerRenameManager::SwitchFilter(_In_ int)
{
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;
m_filter = PowerRenameFilters::ShouldRename;
break;
case PowerRenameFilters::ShouldRename:
m_filter = (columnNumber == 0) ? PowerRenameFilters::Selected : PowerRenameFilters::None;
m_filter = PowerRenameFilters::None;
break;
}
@@ -458,7 +496,7 @@ HRESULT CPowerRenameManager::_Init()
m_startRegExWorkerEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
m_cancelRegExWorkerEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
m_hwndMessage = CreateMsgWindow(g_hInst, s_msgWndProc, this);
m_hwndMessage = CreateMsgWindow(g_hostHInst, s_msgWndProc, this);
return S_OK;
}
@@ -467,6 +505,7 @@ HRESULT CPowerRenameManager::_Init()
enum
{
SRM_REGEX_ITEM_UPDATED = (WM_APP + 1), // Single rename item processed by regex worker thread
SRM_REGEX_ITEM_RENAMED_KEEP_UI, // Single rename item processed by rename worker thread in case UI remains opened
SRM_REGEX_STARTED, // RegEx operation was started
SRM_REGEX_CANCELED, // Regex operation was canceled
SRM_REGEX_COMPLETE, // Regex worker thread completed
@@ -523,6 +562,16 @@ LRESULT CPowerRenameManager::_WndProc(_In_ HWND hwnd, _In_ UINT msg, _In_ WPARAM
}
break;
}
case SRM_REGEX_ITEM_RENAMED_KEEP_UI:
{
int id = static_cast<int>(lParam);
CComPtr<IPowerRenameItem> spItem;
if (SUCCEEDED(GetItemById(id, &spItem)))
{
_OnRename(spItem);
}
break;
}
case SRM_REGEX_STARTED:
_OnRegExStarted(static_cast<DWORD>(wParam));
break;
@@ -681,6 +730,9 @@ DWORD WINAPI CPowerRenameManager::s_fileOpWorkerThread(_In_ void* pv)
WorkerThreadData* pwtd = reinterpret_cast<WorkerThreadData*>(pv);
if (pwtd)
{
bool closeUIWindowAfterRenaming = true;
pwtd->spsrm->GetCloseUIWindowAfterRenaming(&closeUIWindowAfterRenaming);
// Wait to be told we can begin
if (WaitForSingleObject(pwtd->startEvent, INFINITE) == WAIT_OBJECT_0)
{
@@ -732,6 +784,38 @@ DWORD WINAPI CPowerRenameManager::s_fileOpWorkerThread(_In_ void* pv)
if (SUCCEEDED(spItem->GetShellItem(&spShellItem)))
{
spFileOp->RenameItem(spShellItem, newName, nullptr);
if (!closeUIWindowAfterRenaming)
{
// Update item data
PWSTR originalName = nullptr;
winrt::check_hresult(spItem->GetOriginalName(&originalName));
std::wstring originalNameStr{ originalName };
PWSTR path = nullptr;
winrt::check_hresult(spItem->GetPath(&path));
std::wstring pathStr{ path };
size_t oldPathSize = pathStr.size();
auto fileNamePos = pathStr.find_last_of(L"\\");
pathStr.replace(fileNamePos + 1, originalNameStr.length(), std::wstring{ newName });
spItem->PutPath(pathStr.c_str());
spItem->PutOriginalName(newName);
spItem->PutNewName(nullptr);
// if folder, update children path
bool isFolder = false;
winrt::check_hresult(spItem->GetIsFolder(&isFolder));
if (isFolder)
{
int id = -1;
winrt::check_hresult(spItem->GetId(&id));
pwtd->spsrm->UpdateChildrenPath(id, oldPathSize);
}
int id = -1;
winrt::check_hresult(spItem->GetId(&id));
PostMessage(pwtd->hwndManager, SRM_REGEX_ITEM_RENAMED_KEEP_UI, GetCurrentThreadId(), id);
}
}
CoTaskMemFree(newName);
}
@@ -1137,6 +1221,19 @@ void CPowerRenameManager::_OnUpdate(_In_ IPowerRenameItem* renameItem)
}
}
void CPowerRenameManager::_OnRename(_In_ IPowerRenameItem* renameItem)
{
CSRWSharedAutoLock lock(&m_lockEvents);
for (auto it : m_powerRenameManagerEvents)
{
if (it.pEvents)
{
it.pEvents->OnRename(renameItem);
}
}
}
void CPowerRenameManager::_OnError(_In_ IPowerRenameItem* renameItem)
{
CSRWSharedAutoLock lock(&m_lockEvents);
@@ -1210,7 +1307,7 @@ void CPowerRenameManager::_OnRenameCompleted()
{
if (it.pEvents)
{
it.pEvents->OnRenameCompleted();
it.pEvents->OnRenameCompleted(m_closeUIWindowAfterRenaming);
}
}
}

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

@@ -3,8 +3,7 @@
#include <map>
#include "srwlock.h"
#include <lib/PowerRenameManager.h>
#include <lib/PowerRenameInterfaces.h>
#include <PowerRenameInterfaces.h>
class CPowerRenameManager :
public IPowerRenameManager,
@@ -23,7 +22,9 @@ public:
IFACEMETHODIMP Stop();
IFACEMETHODIMP Reset();
IFACEMETHODIMP Shutdown();
IFACEMETHODIMP Rename(_In_ HWND hwndParent);
IFACEMETHODIMP Rename(_In_ HWND hwndParent, bool closeWindow);
IFACEMETHODIMP UpdateChildrenPath(_In_ int parentId, _In_ size_t oldParentPathSize);
IFACEMETHODIMP GetCloseUIWindowAfterRenaming(_Out_ bool* closeUIWindowAfterRenaming);
IFACEMETHODIMP AddItem(_In_ IPowerRenameItem* pItem);
IFACEMETHODIMP GetItemByIndex(_In_ UINT index, _COM_Outptr_ IPowerRenameItem** ppItem);
IFACEMETHODIMP GetVisibleItemByIndex(_In_ UINT index, _COM_Outptr_ IPowerRenameItem** ppItem);
@@ -61,6 +62,7 @@ protected:
void _OnItemAdded(_In_ IPowerRenameItem* renameItem);
void _OnUpdate(_In_ IPowerRenameItem* renameItem);
void _OnRename(_In_ IPowerRenameItem* renameItem);
void _OnError(_In_ IPowerRenameItem* renameItem);
void _OnRegExStarted(_In_ DWORD threadId);
void _OnRegExCanceled(_In_ DWORD threadId);
@@ -125,6 +127,7 @@ protected:
// Parent HWND used by IFileOperation
HWND m_hwndParent = nullptr;
bool m_closeUIWindowAfterRenaming = true;
HWND m_hwndMessage = nullptr;

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

@@ -85,9 +85,9 @@ IFACEMETHODIMP CPowerRenameRegEx::GetSearchTerm(_Outptr_ PWSTR* searchTerm)
return hr;
}
IFACEMETHODIMP CPowerRenameRegEx::PutSearchTerm(_In_ PCWSTR searchTerm)
IFACEMETHODIMP CPowerRenameRegEx::PutSearchTerm(_In_ PCWSTR searchTerm, bool forceRenaming)
{
bool changed = false;
bool changed = false || forceRenaming;
HRESULT hr = S_OK;
if (searchTerm)
{
@@ -96,7 +96,14 @@ IFACEMETHODIMP CPowerRenameRegEx::PutSearchTerm(_In_ PCWSTR searchTerm)
{
changed = true;
CoTaskMemFree(m_searchTerm);
hr = SHStrDup(searchTerm, &m_searchTerm);
if (lstrcmp(searchTerm, L"") == 0)
{
m_searchTerm = NULL;
}
else
{
hr = SHStrDup(searchTerm, &m_searchTerm);
}
}
}
@@ -120,9 +127,9 @@ IFACEMETHODIMP CPowerRenameRegEx::GetReplaceTerm(_Outptr_ PWSTR* replaceTerm)
return hr;
}
IFACEMETHODIMP CPowerRenameRegEx::PutReplaceTerm(_In_ PCWSTR replaceTerm)
IFACEMETHODIMP CPowerRenameRegEx::PutReplaceTerm(_In_ PCWSTR replaceTerm, bool forceRenaming)
{
bool changed = false;
bool changed = false || forceRenaming;
HRESULT hr = S_OK;
if (replaceTerm)
{

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

@@ -20,9 +20,9 @@ public:
IFACEMETHODIMP Advise(_In_ IPowerRenameRegExEvents* regExEvents, _Out_ DWORD* cookie);
IFACEMETHODIMP UnAdvise(_In_ DWORD cookie);
IFACEMETHODIMP GetSearchTerm(_Outptr_ PWSTR* searchTerm);
IFACEMETHODIMP PutSearchTerm(_In_ PCWSTR searchTerm);
IFACEMETHODIMP PutSearchTerm(_In_ PCWSTR searchTerm, bool forceRenaming);
IFACEMETHODIMP GetReplaceTerm(_Outptr_ PWSTR* replaceTerm);
IFACEMETHODIMP PutReplaceTerm(_In_ PCWSTR replaceTerm);
IFACEMETHODIMP PutReplaceTerm(_In_ PCWSTR replaceTerm, bool forceRenaming);
IFACEMETHODIMP GetFlags(_Out_ DWORD* flags);
IFACEMETHODIMP PutFlags(_In_ DWORD flags);
IFACEMETHODIMP PutFileTime(_In_ SYSTEMTIME fileTime);

389
src/modules/powerrename/lib/Settings.cpp
View File

@@ -1,6 +1,7 @@
#include "pch.h"
#include "Settings.h"
#include "PowerRenameInterfaces.h"
#include "Helpers.h"
#include <common/SettingsAPI/settings_helpers.h>
#include <filesystem>
@@ -13,12 +14,6 @@ namespace
{
const wchar_t c_powerRenameDataFilePath[] = L"\\power-rename-settings.json";
const wchar_t c_powerRenameUIFlagsFilePath[] = L"\\power-rename-ui-flags";
const wchar_t c_searchMRUListFilePath[] = L"\\search-mru.json";
const wchar_t c_replaceMRUListFilePath[] = L"\\replace-mru.json";
const wchar_t c_rootRegPath[] = L"Software\\Microsoft\\PowerRename";
const wchar_t c_mruSearchRegPath[] = L"\\SearchMRU";
const wchar_t c_mruReplaceRegPath[] = L"\\ReplaceMRU";
const wchar_t c_enabled[] = L"Enabled";
const wchar_t c_showIconOnMenu[] = L"ShowIcon";
@@ -29,380 +24,8 @@ namespace
const wchar_t c_searchText[] = L"SearchText";
const wchar_t c_replaceText[] = L"ReplaceText";
const wchar_t c_mruEnabled[] = L"MRUEnabled";
const wchar_t c_mruList[] = L"MRUList";
const wchar_t c_insertionIdx[] = L"InsertionIdx";
const wchar_t c_useBoostLib[] = L"UseBoostLib";
unsigned int GetRegNumber(const std::wstring& valueName, unsigned int defaultValue)
{
DWORD type = REG_DWORD;
DWORD data = 0;
DWORD size = sizeof(DWORD);
if (SHGetValue(HKEY_CURRENT_USER, c_rootRegPath, valueName.c_str(), &type, &data, &size) == ERROR_SUCCESS)
{
return data;
}
return defaultValue;
}
void SetRegNumber(const std::wstring& valueName, unsigned int value)
{
SHSetValue(HKEY_CURRENT_USER, c_rootRegPath, valueName.c_str(), REG_DWORD, &value, sizeof(value));
}
bool GetRegBoolean(const std::wstring& valueName, bool defaultValue)
{
DWORD value = GetRegNumber(valueName.c_str(), defaultValue ? 1 : 0);
return (value == 0) ? false : true;
}
void SetRegBoolean(const std::wstring& valueName, bool value)
{
SetRegNumber(valueName, value ? 1 : 0);
}
std::wstring GetRegString(const std::wstring& valueName, const std::wstring& subPath)
{
wchar_t value[CSettings::MAX_INPUT_STRING_LEN];
value[0] = L'\0';
DWORD type = REG_SZ;
DWORD size = CSettings::MAX_INPUT_STRING_LEN * sizeof(wchar_t);
std::wstring completePath = std::wstring(c_rootRegPath) + subPath;
if (SHGetValue(HKEY_CURRENT_USER, completePath.c_str(), valueName.c_str(), &type, value, &size) == ERROR_SUCCESS)
{
return std::wstring(value);
}
return std::wstring{};
}
bool LastModifiedTime(const std::wstring& filePath, FILETIME* lpFileTime)
{
WIN32_FILE_ATTRIBUTE_DATA attr{};
if (GetFileAttributesExW(filePath.c_str(), GetFileExInfoStandard, &attr))
{
*lpFileTime = attr.ftLastWriteTime;
return true;
}
return false;
}
}
class MRUListHandler
{
public:
MRUListHandler(unsigned int size, const std::wstring& filePath, const std::wstring& regPath) :
pushIdx(0),
nextIdx(1),
size(size),
jsonFilePath(PTSettingsHelper::get_module_save_folder_location(PowerRenameConstants::ModuleKey) + filePath),
registryFilePath(regPath)
{
items.resize(size);
Load();
}
void Push(const std::wstring& data);
bool Next(std::wstring& data);
void Reset();
private:
void Load();
void Save();
void MigrateFromRegistry();
json::JsonArray Serialize();
void ParseJson();
bool Exists(const std::wstring& data);
std::vector<std::wstring> items;
unsigned int pushIdx;
unsigned int nextIdx;
unsigned int size;
const std::wstring jsonFilePath;
const std::wstring registryFilePath;
};
void MRUListHandler::Push(const std::wstring& data)
{
if (Exists(data))
{
// TODO: Already existing item should be put on top of MRU list.
return;
}
items[pushIdx] = data;
pushIdx = (pushIdx + 1) % size;
Save();
}
bool MRUListHandler::Next(std::wstring& data)
{
if (nextIdx == size + 1)
{
Reset();
return false;
}
// Go backwards to consume latest items first.
unsigned int idx = (pushIdx + size - nextIdx) % size;
if (items[idx].empty())
{
Reset();
return false;
}
data = items[idx];
++nextIdx;
return true;
}
void MRUListHandler::Reset()
{
nextIdx = 1;
}
void MRUListHandler::Load()
{
if (!std::filesystem::exists(jsonFilePath))
{
MigrateFromRegistry();
Save();
}
else
{
ParseJson();
}
}
void MRUListHandler::Save()
{
json::JsonObject jsonData;
jsonData.SetNamedValue(c_maxMRUSize, json::value(size));
jsonData.SetNamedValue(c_insertionIdx, json::value(pushIdx));
jsonData.SetNamedValue(c_mruList, Serialize());
json::to_file(jsonFilePath, jsonData);
}
json::JsonArray MRUListHandler::Serialize()
{
json::JsonArray searchMRU{};
std::wstring data{};
for (const std::wstring& item : items)
{
searchMRU.Append(json::value(item));
}
return searchMRU;
}
void MRUListHandler::MigrateFromRegistry()
{
std::wstring searchListKeys = GetRegString(c_mruList, registryFilePath);
std::sort(std::begin(searchListKeys), std::end(searchListKeys));
for (const wchar_t& key : searchListKeys)
{
Push(GetRegString(std::wstring(1, key), registryFilePath));
}
}
void MRUListHandler::ParseJson()
{
auto json = json::from_file(jsonFilePath);
if (json)
{
const json::JsonObject& jsonObject = json.value();
try
{
unsigned int oldSize{ size };
if (json::has(jsonObject, c_maxMRUSize, json::JsonValueType::Number))
{
oldSize = (unsigned int)jsonObject.GetNamedNumber(c_maxMRUSize);
}
unsigned int oldPushIdx{ 0 };
if (json::has(jsonObject, c_insertionIdx, json::JsonValueType::Number))
{
oldPushIdx = (unsigned int)jsonObject.GetNamedNumber(c_insertionIdx);
if (oldPushIdx < 0 || oldPushIdx >= oldSize)
{
oldPushIdx = 0;
}
}
if (json::has(jsonObject, c_mruList, json::JsonValueType::Array))
{
auto jsonArray = jsonObject.GetNamedArray(c_mruList);
if (oldSize == size)
{
for (uint32_t i = 0; i < jsonArray.Size(); ++i)
{
items[i] = std::wstring(jsonArray.GetStringAt(i));
}
pushIdx = oldPushIdx;
}
else
{
std::vector<std::wstring> temp;
for (unsigned int i = 0; i < min(jsonArray.Size(), size); ++i)
{
int idx = (oldPushIdx + oldSize - (i + 1)) % oldSize;
temp.push_back(std::wstring(jsonArray.GetStringAt(idx)));
}
if (size > oldSize)
{
std::reverse(std::begin(temp), std::end(temp));
pushIdx = (unsigned int)temp.size();
temp.resize(size);
}
else
{
temp.resize(size);
std::reverse(std::begin(temp), std::end(temp));
}
items = std::move(temp);
Save();
}
}
}
catch (const winrt::hresult_error&)
{
}
}
}
bool MRUListHandler::Exists(const std::wstring& data)
{
return std::find(std::begin(items), std::end(items), data) != std::end(items);
}
class CRenameMRU :
public IEnumString,
public IPowerRenameMRU
{
public:
// IUnknown
IFACEMETHODIMP_(ULONG)
AddRef();
IFACEMETHODIMP_(ULONG)
Release();
IFACEMETHODIMP QueryInterface(_In_ REFIID riid, _Outptr_ void** ppv);
// IEnumString
IFACEMETHODIMP Next(__in ULONG celt, __out_ecount_part(celt, *pceltFetched) LPOLESTR* rgelt, __out_opt ULONG* pceltFetched);
IFACEMETHODIMP Skip(__in ULONG) { return E_NOTIMPL; }
IFACEMETHODIMP Reset();
IFACEMETHODIMP Clone(__deref_out IEnumString** ppenum)
{
*ppenum = nullptr;
return E_NOTIMPL;
}
// IPowerRenameMRU
IFACEMETHODIMP AddMRUString(_In_ PCWSTR entry);
static HRESULT CreateInstance(_In_ const std::wstring& filePath, _In_ const std::wstring& regPath, _Outptr_ IUnknown** ppUnk);
private:
CRenameMRU(int size, const std::wstring& filePath, const std::wstring& regPath);
std::unique_ptr<MRUListHandler> mruList;
unsigned int refCount = 0;
};
CRenameMRU::CRenameMRU(int size, const std::wstring& filePath, const std::wstring& regPath) :
refCount(1)
{
mruList = std::make_unique<MRUListHandler>(size, filePath, regPath);
}
HRESULT CRenameMRU::CreateInstance(_In_ const std::wstring& filePath, _In_ const std::wstring& regPath, _Outptr_ IUnknown** ppUnk)
{
*ppUnk = nullptr;
unsigned int maxMRUSize = CSettingsInstance().GetMaxMRUSize();
HRESULT hr = E_FAIL;
if (maxMRUSize > 0)
{
CRenameMRU* renameMRU = new CRenameMRU(maxMRUSize, filePath, regPath);
hr = E_OUTOFMEMORY;
if (renameMRU)
{
renameMRU->QueryInterface(IID_PPV_ARGS(ppUnk));
renameMRU->Release();
hr = S_OK;
}
}
return hr;
}
IFACEMETHODIMP_(ULONG)
CRenameMRU::AddRef()
{
return InterlockedIncrement(&refCount);
}
IFACEMETHODIMP_(ULONG)
CRenameMRU::Release()
{
unsigned int cnt = InterlockedDecrement(&refCount);
if (cnt == 0)
{
delete this;
}
return cnt;
}
IFACEMETHODIMP CRenameMRU::QueryInterface(_In_ REFIID riid, _Outptr_ void** ppv)
{
static const QITAB qit[] = {
QITABENT(CRenameMRU, IEnumString),
QITABENT(CRenameMRU, IPowerRenameMRU),
{ 0 }
};
return QISearch(this, qit, riid, ppv);
}
IFACEMETHODIMP CRenameMRU::Next(__in ULONG celt, __out_ecount_part(celt, *pceltFetched) LPOLESTR* rgelt, __out_opt ULONG* pceltFetched)
{
if (pceltFetched)
{
*pceltFetched = 0;
}
if (!celt)
{
return S_OK;
}
if (!rgelt)
{
return S_FALSE;
}
HRESULT hr = S_FALSE;
if (std::wstring data{}; mruList->Next(data))
{
hr = SHStrDup(data.c_str(), rgelt);
if (SUCCEEDED(hr) && pceltFetched != nullptr)
{
*pceltFetched = 1;
}
}
return hr;
}
IFACEMETHODIMP CRenameMRU::Reset()
{
mruList->Reset();
return S_OK;
}
IFACEMETHODIMP CRenameMRU::AddMRUString(_In_ PCWSTR entry)
{
mruList->Push(entry);
return S_OK;
}
CSettings::CSettings()
@@ -547,13 +170,3 @@ CSettings& CSettingsInstance()
static CSettings instance;
return instance;
}
HRESULT CRenameMRUSearch_CreateInstance(_Outptr_ IUnknown** ppUnk)
{
return CRenameMRU::CreateInstance(c_searchMRUListFilePath, c_mruSearchRegPath, ppUnk);
}
HRESULT CRenameMRUReplace_CreateInstance(_Outptr_ IUnknown** ppUnk)
{
return CRenameMRU::CreateInstance(c_replaceMRUListFilePath, c_mruReplaceRegPath, ppUnk);
}

5
src/modules/powerrename/lib/Settings.h
View File

@@ -5,8 +5,6 @@
class CSettings
{
public:
static const int MAX_INPUT_STRING_LEN = 1024;
CSettings();
inline bool GetEnabled()
@@ -146,6 +144,3 @@ private:
};
CSettings& CSettingsInstance();
HRESULT CRenameMRUSearch_CreateInstance(_Outptr_ IUnknown** ppUnk);
HRESULT CRenameMRUReplace_CreateInstance(_Outptr_ IUnknown** ppUnk);