Rename variable

SinghRajenM · SinghRajenM · commit 5d094fdbeba9 · 2024-11-11T08:31:41.000+05:30
diff --git a/src/NppJsonViewer/JsonViewDlg.cpp b/src/NppJsonViewer/JsonViewDlg.cpp
@@ -18,7 +18,7 @@ JsonViewDlg::JsonViewDlg(HINSTANCE hInstance, const NppData& nppData, const bool
     , m_IsNppReady(isReady)
     , m_nDlgId(nCmdId)
     , m_pEditor(std::make_unique<ScintillaEditor>(nppData))
-    , m_hTreeView(std::make_unique<TreeViewCtrl>())
+    , m_pTreeView(std::make_unique<TreeViewCtrl>())
     , m_pSetting(pSetting)
     , m_pCurrFileName(std::make_unique<wchar_t[]>(FILENAME_LEN_IN_TITLE))
 {
@@ -341,7 +341,7 @@ void JsonViewDlg::DrawJsonTree()
     EnableControls(ctrls, false);
 
     HTREEITEM rootNode = nullptr;
-    rootNode           = m_hTreeView->InitTree();
+    rootNode           = m_pTreeView->InitTree();
 
     // Refresh the view
     m_pEditor->RefreshViewHandle();
@@ -350,7 +350,7 @@ void JsonViewDlg::DrawJsonTree()
 
     if (!selectedText.has_value() || selectedText.value().empty())
     {
-        m_hTreeView->InsertNode(JSON_ERR_PARSE, NULL, rootNode);
+        m_pTreeView->InsertNode(JSON_ERR_PARSE, NULL, rootNode);
 
         if (IsMultiSelection(selectedData))
         {
@@ -366,9 +366,9 @@ void JsonViewDlg::DrawJsonTree()
             // Later on second launch, don't show the error message as this could be some text file
             // If it is real json file but has some error, then there must be more than 1 node exist.
 
-            if (!m_IsNppReady && m_hTreeView->GetNodeCount() <= 1)
+            if (!m_IsNppReady && m_pTreeView->GetNodeCount() <= 1)
             {
-                m_hTreeView->InsertNode(JSON_ERR_VALIDATE, NULL, rootNode);
+                m_pTreeView->InsertNode(JSON_ERR_VALIDATE, NULL, rootNode);
             }
             else
             {
@@ -377,7 +377,7 @@ void JsonViewDlg::DrawJsonTree()
         }
     }
 
-    m_hTreeView->Expand(rootNode);
+    m_pTreeView->Expand(rootNode);
 
     // Enable all buttons and treeView
     EnableControls(ctrls, true);
@@ -441,34 +441,34 @@ auto JsonViewDlg::PopulateTreeUsingSax(HTREEITEM tree_root, const std::string& j
 HTREEITEM JsonViewDlg::InsertToTree(HTREEITEM parent, const std::string& text)
 {
     auto wText = StringHelper::ToWstring(text, CP_UTF8);
-    return m_hTreeView->InsertNode(wText, NULL, parent);
+    return m_pTreeView->InsertNode(wText, NULL, parent);
 }
 
 HTREEITEM JsonViewDlg::InsertToTree(HTREEITEM parent, const std::string& text, const Position& pos)
 {
     auto wText  = StringHelper::ToWstring(text, CP_UTF8);
     auto lparam = new Position(pos);
-    return m_hTreeView->InsertNode(wText, reinterpret_cast<LPARAM>(lparam), parent);
+    return m_pTreeView->InsertNode(wText, reinterpret_cast<LPARAM>(lparam), parent);
 }
 
 void JsonViewDlg::AppendNodeCount(HTREEITEM node, unsigned elementCount, bool bArray)
 {
     if (!node)
         return;
 
-    auto txt = m_hTreeView->GetNodeName(node, false);
+    auto txt = m_pTreeView->GetNodeName(node, false);
 
     txt += L" ";
     txt += bArray ? L"[" : L"{";
     txt += std::to_wstring(elementCount);
     txt += bArray ? L"]" : L"}";
 
-    m_hTreeView->UpdateNodeText(node, txt);
+    m_pTreeView->UpdateNodeText(node, txt);
 }
 
 void JsonViewDlg::UpdateNodePath(HTREEITEM htiNode)
 {
-    std::wstring nodePath = m_hTreeView->GetNodePath(htiNode);
+    std::wstring nodePath = m_pTreeView->GetNodePath(htiNode);
     CUtility::SetEditCtrlText(::GetDlgItem(_hSelf, IDC_EDT_NODEPATH), nodePath);
 }
 
@@ -486,31 +486,31 @@ void JsonViewDlg::SearchInTree()
 {
     std::wstring itemToSearch = CUtility::GetEditCtrlText(::GetDlgItem(_hSelf, IDC_EDT_SEARCH));
     CUtility::SetEditCtrlText(::GetDlgItem(_hSelf, IDC_EDT_NODEPATH), STR_SRCH_SEARCHING + itemToSearch);
-    m_hTreeView->SetSelection(nullptr);
+    m_pTreeView->SetSelection(nullptr);
 
     static int          foundCount = 0;
     static std::wstring previousSearch;
-    static HTREEITEM    nextNode = m_hTreeView->NextItem(m_hTreeView->GetRoot());
+    static HTREEITEM    nextNode = m_pTreeView->NextItem(m_pTreeView->GetRoot());
 
     // New search, hence search from beginning
     if (previousSearch != itemToSearch)
     {
         previousSearch = itemToSearch;
-        nextNode       = m_hTreeView->NextItem(m_hTreeView->GetRoot());
+        nextNode       = m_pTreeView->NextItem(m_pTreeView->GetRoot());
         foundCount     = 0;
     }
     else
     {
-        nextNode = m_hTreeView->NextItem(nextNode);
-        if (nextNode == m_hTreeView->GetRoot())
+        nextNode = m_pTreeView->NextItem(nextNode);
+        if (nextNode == m_pTreeView->GetRoot())
         {
-            nextNode   = m_hTreeView->NextItem(nextNode);
+            nextNode   = m_pTreeView->NextItem(nextNode);
             foundCount = 0;
         }
     }
 
     // Check if this is an empty json
-    std::wstring nodeText = m_hTreeView->GetNodeName(nextNode, true);
+    std::wstring nodeText = m_pTreeView->GetNodeName(nextNode, true);
     if (nodeText.empty() || wcscmp(nodeText.c_str(), JSON_ERR_PARSE) == 0)
     {
         CUtility::SetEditCtrlText(::GetDlgItem(_hSelf, IDC_EDT_NODEPATH), STR_SRCH_NOTFOUND + itemToSearch);
@@ -520,9 +520,9 @@ void JsonViewDlg::SearchInTree()
         bool bFound = false;
         while (!bFound && nextNode)
         {
-            nodeText     = m_hTreeView->GetNodeName(nextNode, true);
-            auto nodeKey = m_hTreeView->GetNodeKey(nextNode);
-            auto nodeVal = m_hTreeView->GetNodeValue(nextNode);
+            nodeText     = m_pTreeView->GetNodeName(nextNode, true);
+            auto nodeKey = m_pTreeView->GetNodeKey(nextNode);
+            auto nodeVal = m_pTreeView->GetNodeValue(nextNode);
 
             // Search in node value
             //  1. If both key and value are not equal
@@ -545,13 +545,13 @@ void JsonViewDlg::SearchInTree()
             if (bFound)
                 break;
 
-            nextNode = m_hTreeView->NextItem(nextNode);
+            nextNode = m_pTreeView->NextItem(nextNode);
         }
 
         if (bFound)
         {
             UpdateNodePath(nextNode);
-            m_hTreeView->SetSelection(nextNode);
+            m_pTreeView->SetSelection(nextNode);
             ++foundCount;
         }
         else
@@ -719,15 +719,15 @@ void JsonViewDlg::ShowContextMenu(int x, int y)
 
     TVHITTESTINFO tvHitInfo {.pt = p, .flags = 0, .hItem = nullptr};
 
-    m_hTreeView->ScreenToTreeView(&(tvHitInfo.pt));
+    m_pTreeView->ScreenToTreeView(&(tvHitInfo.pt));
 
     // Detect if the given position is on the element TVITEM
-    HTREEITEM hTreeItem = m_hTreeView->HitTest(&tvHitInfo);
+    HTREEITEM hTreeItem = m_pTreeView->HitTest(&tvHitInfo);
 
     if (hTreeItem != nullptr)
     {
         // Make item selected
-        m_hTreeView->SelectItem(hTreeItem);
+        m_pTreeView->SelectItem(hTreeItem);
 
         if (tvHitInfo.flags & (TVHT_ONITEM | TVHT_ONITEMBUTTON))
         {
@@ -741,7 +741,7 @@ void JsonViewDlg::ShowContextMenu(int x, int y)
 void JsonViewDlg::ShowContextMenu(HTREEITEM htiNode, LPPOINT lppScreen)
 {
     // Select it
-    m_hTreeView->SelectItem(htiNode);
+    m_pTreeView->SelectItem(htiNode);
 
     // Show menu
     if (lppScreen != NULL)
@@ -753,19 +753,19 @@ void JsonViewDlg::ShowContextMenu(HTREEITEM htiNode, LPPOINT lppScreen)
         bool bEnableExpand   = false;
         bool bEnableCollapse = false;
 
-        if (m_hTreeView->GetRoot() == htiNode)
+        if (m_pTreeView->GetRoot() == htiNode)
         {
             bEnableCopyName  = false;
             bEnableCopyValue = false;
             bEnableCopyPath  = false;
         }
 
-        if (m_hTreeView->HasChild(htiNode))
+        if (m_pTreeView->HasChild(htiNode))
         {
             bEnableCopyName  = false;
             bEnableCopyValue = false;
-            bEnableCollapse  = m_hTreeView->IsThisOrAnyChildExpanded(htiNode);
-            bEnableExpand    = m_hTreeView->IsThisOrAnyChildCollapsed(htiNode);
+            bEnableCollapse  = m_pTreeView->IsThisOrAnyChildExpanded(htiNode);
+            bEnableExpand    = m_pTreeView->IsThisOrAnyChildCollapsed(htiNode);
         }
 
         // Create menu
@@ -806,56 +806,56 @@ void JsonViewDlg::ShowContextMenu(HTREEITEM htiNode, LPPOINT lppScreen)
 
 void JsonViewDlg::ContextMenuExpand(bool bExpand)
 {
-    HTREEITEM htiSelected = m_hTreeView->GetSelection();
+    HTREEITEM htiSelected = m_pTreeView->GetSelection();
     if (htiSelected == NULL)
         return;
 
-    HTREEITEM htiRoot = m_hTreeView->GetRoot();
+    HTREEITEM htiRoot = m_pTreeView->GetRoot();
     HTREEITEM htiNext = htiSelected;
     while (htiNext != NULL)
     {
         if (!(htiNext == htiRoot && !bExpand))
-            bExpand ? m_hTreeView->Expand(htiNext) : m_hTreeView->Collapse(htiNext);
-        htiNext = m_hTreeView->NextItem(htiNext, htiSelected);
+            bExpand ? m_pTreeView->Expand(htiNext) : m_pTreeView->Collapse(htiNext);
+        htiNext = m_pTreeView->NextItem(htiNext, htiSelected);
     }
 }
 
 auto JsonViewDlg::CopyName() const -> std::wstring
 {
-    HTREEITEM selectedNode = m_hTreeView->GetSelection();
+    HTREEITEM selectedNode = m_pTreeView->GetSelection();
     if (selectedNode)
     {
-        return m_hTreeView->GetNodeName(selectedNode, true);
+        return m_pTreeView->GetNodeName(selectedNode, true);
     }
     return std::wstring();
 }
 
 auto JsonViewDlg::CopyKey() const -> std::wstring
 {
-    HTREEITEM selectedNode = m_hTreeView->GetSelection();
+    HTREEITEM selectedNode = m_pTreeView->GetSelection();
     if (selectedNode)
     {
-        return m_hTreeView->GetNodeKey(selectedNode);
+        return m_pTreeView->GetNodeKey(selectedNode);
     }
     return std::wstring();
 }
 
 auto JsonViewDlg::CopyValue() const -> std::wstring
 {
-    HTREEITEM selectedNode = m_hTreeView->GetSelection();
+    HTREEITEM selectedNode = m_pTreeView->GetSelection();
     if (selectedNode)
     {
-        return m_hTreeView->GetNodeValue(selectedNode);
+        return m_pTreeView->GetNodeValue(selectedNode);
     }
     return std::wstring();
 }
 
 auto JsonViewDlg::CopyPath() const -> std::wstring
 {
-    HTREEITEM selectedNode = m_hTreeView->GetSelection();
+    HTREEITEM selectedNode = m_pTreeView->GetSelection();
     if (selectedNode)
     {
-        return m_hTreeView->GetNodePath(selectedNode);
+        return m_pTreeView->GetNodePath(selectedNode);
     }
     return std::wstring();
 }
@@ -911,7 +911,7 @@ void JsonViewDlg::HandleTreeEvents(LPARAM lParam)
         {
             UpdateNodePath(hItem);
 
-            auto pPosition = m_hTreeView->GetNodePosition(hItem);
+            auto pPosition = m_pTreeView->GetNodePosition(hItem);
             if (pPosition != nullptr)
             {
                 GoToLine(pPosition->nLine);
@@ -922,9 +922,9 @@ void JsonViewDlg::HandleTreeEvents(LPARAM lParam)
 
     case NM_DBLCLK:
     {
-        HTREEITEM hItem = m_hTreeView->GetSelection();
+        HTREEITEM hItem = m_pTreeView->GetSelection();
 
-        auto pPosition = m_hTreeView->GetNodePosition(hItem);
+        auto pPosition = m_pTreeView->GetNodePosition(hItem);
         if (pPosition != nullptr)
         {
             GoToPosition(pPosition->nLine, pPosition->nColumn, pPosition->nKeyLength);
@@ -1029,7 +1029,7 @@ INT_PTR JsonViewDlg::run_dlgProc(UINT message, WPARAM wParam, LPARAM lParam)
         // Save ourselves in GWLP_USERDATA.
         ::SetWindowLongPtr(getHSelf(), GWLP_USERDATA, reinterpret_cast<LONG_PTR>(this));
 
-        m_hTreeView->OnInit(getHSelf());
+        m_pTreeView->OnInit(getHSelf());
 
         PrepareButtons();
 
diff --git a/src/NppJsonViewer/JsonViewDlg.h b/src/NppJsonViewer/JsonViewDlg.h
@@ -117,6 +117,6 @@ class JsonViewDlg
 
     std::unique_ptr<wchar_t[]>       m_pCurrFileName;
     std::unique_ptr<ScintillaEditor> m_pEditor   = nullptr;
-    std::unique_ptr<TreeViewCtrl>    m_hTreeView = nullptr;
+    std::unique_ptr<TreeViewCtrl>    m_pTreeView = nullptr;
     std::shared_ptr<Setting>         m_pSetting  = nullptr;
 };

Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ JsonViewDlg::JsonViewDlg(HINSTANCE hInstance, const NppData& nppData, const bool`
`18`	`18`	`, m_IsNppReady(isReady)`
`19`	`19`	`, m_nDlgId(nCmdId)`
`20`	`20`	`, m_pEditor(std::make_unique<ScintillaEditor>(nppData))`
`21`		`- , m_hTreeView(std::make_unique<TreeViewCtrl>())`
	`21`	`+ , m_pTreeView(std::make_unique<TreeViewCtrl>())`
`22`	`22`	`, m_pSetting(pSetting)`
`23`	`23`	`, m_pCurrFileName(std::make_unique<wchar_t[]>(FILENAME_LEN_IN_TITLE))`
`24`	`24`	`{`
`@@ -341,7 +341,7 @@ void JsonViewDlg::DrawJsonTree()`
`341`	`341`	`EnableControls(ctrls, false);`
`342`	`342`
`343`	`343`	`HTREEITEM rootNode = nullptr;`
`344`		`- rootNode = m_hTreeView->InitTree();`
	`344`	`+ rootNode = m_pTreeView->InitTree();`
`345`	`345`
`346`	`346`	`// Refresh the view`
`347`	`347`	`m_pEditor->RefreshViewHandle();`
`@@ -350,7 +350,7 @@ void JsonViewDlg::DrawJsonTree()`
`350`	`350`
`351`	`351`	`if (!selectedText.has_value() \|\| selectedText.value().empty())`
`352`	`352`	`{`
`353`		`- m_hTreeView->InsertNode(JSON_ERR_PARSE, NULL, rootNode);`
	`353`	`+ m_pTreeView->InsertNode(JSON_ERR_PARSE, NULL, rootNode);`
`354`	`354`
`355`	`355`	`if (IsMultiSelection(selectedData))`
`356`	`356`	`{`
`@@ -366,9 +366,9 @@ void JsonViewDlg::DrawJsonTree()`
`366`	`366`	`// Later on second launch, don't show the error message as this could be some text file`
`367`	`367`	`// If it is real json file but has some error, then there must be more than 1 node exist.`
`368`	`368`
`369`		`- if (!m_IsNppReady && m_hTreeView->GetNodeCount() <= 1)`
	`369`	`+ if (!m_IsNppReady && m_pTreeView->GetNodeCount() <= 1)`
`370`	`370`	`{`
`371`		`- m_hTreeView->InsertNode(JSON_ERR_VALIDATE, NULL, rootNode);`
	`371`	`+ m_pTreeView->InsertNode(JSON_ERR_VALIDATE, NULL, rootNode);`
`372`	`372`	`}`
`373`	`373`	`else`
`374`	`374`	`{`
`@@ -377,7 +377,7 @@ void JsonViewDlg::DrawJsonTree()`
`377`	`377`	`}`
`378`	`378`	`}`
`379`	`379`
`380`		`- m_hTreeView->Expand(rootNode);`
	`380`	`+ m_pTreeView->Expand(rootNode);`
`381`	`381`
`382`	`382`	`// Enable all buttons and treeView`
`383`	`383`	`EnableControls(ctrls, true);`
`@@ -441,34 +441,34 @@ auto JsonViewDlg::PopulateTreeUsingSax(HTREEITEM tree_root, const std::string& j`
`441`	`441`	`HTREEITEM JsonViewDlg::InsertToTree(HTREEITEM parent, const std::string& text)`
`442`	`442`	`{`
`443`	`443`	`auto wText = StringHelper::ToWstring(text, CP_UTF8);`
`444`		`- return m_hTreeView->InsertNode(wText, NULL, parent);`
	`444`	`+ return m_pTreeView->InsertNode(wText, NULL, parent);`
`445`	`445`	`}`
`446`	`446`
`447`	`447`	`HTREEITEM JsonViewDlg::InsertToTree(HTREEITEM parent, const std::string& text, const Position& pos)`
`448`	`448`	`{`
`449`	`449`	`auto wText = StringHelper::ToWstring(text, CP_UTF8);`
`450`	`450`	`auto lparam = new Position(pos);`
`451`		`- return m_hTreeView->InsertNode(wText, reinterpret_cast<LPARAM>(lparam), parent);`
	`451`	`+ return m_pTreeView->InsertNode(wText, reinterpret_cast<LPARAM>(lparam), parent);`
`452`	`452`	`}`
`453`	`453`
`454`	`454`	`void JsonViewDlg::AppendNodeCount(HTREEITEM node, unsigned elementCount, bool bArray)`
`455`	`455`	`{`
`456`	`456`	`if (!node)`
`457`	`457`	`return;`
`458`	`458`
`459`		`- auto txt = m_hTreeView->GetNodeName(node, false);`
	`459`	`+ auto txt = m_pTreeView->GetNodeName(node, false);`
`460`	`460`
`461`	`461`	`txt += L" ";`
`462`	`462`	`txt += bArray ? L"[" : L"{";`
`463`	`463`	`txt += std::to_wstring(elementCount);`
`464`	`464`	`txt += bArray ? L"]" : L"}";`
`465`	`465`
`466`		`- m_hTreeView->UpdateNodeText(node, txt);`
	`466`	`+ m_pTreeView->UpdateNodeText(node, txt);`
`467`	`467`	`}`
`468`	`468`
`469`	`469`	`void JsonViewDlg::UpdateNodePath(HTREEITEM htiNode)`
`470`	`470`	`{`
`471`		`- std::wstring nodePath = m_hTreeView->GetNodePath(htiNode);`
	`471`	`+ std::wstring nodePath = m_pTreeView->GetNodePath(htiNode);`
`472`	`472`	`CUtility::SetEditCtrlText(::GetDlgItem(_hSelf, IDC_EDT_NODEPATH), nodePath);`
`473`	`473`	`}`
`474`	`474`
`@@ -486,31 +486,31 @@ void JsonViewDlg::SearchInTree()`
`486`	`486`	`{`
`487`	`487`	`std::wstring itemToSearch = CUtility::GetEditCtrlText(::GetDlgItem(_hSelf, IDC_EDT_SEARCH));`
`488`	`488`	`CUtility::SetEditCtrlText(::GetDlgItem(_hSelf, IDC_EDT_NODEPATH), STR_SRCH_SEARCHING + itemToSearch);`
`489`		`- m_hTreeView->SetSelection(nullptr);`
	`489`	`+ m_pTreeView->SetSelection(nullptr);`
`490`	`490`
`491`	`491`	`static int foundCount = 0;`
`492`	`492`	`static std::wstring previousSearch;`
`493`		`- static HTREEITEM nextNode = m_hTreeView->NextItem(m_hTreeView->GetRoot());`
	`493`	`+ static HTREEITEM nextNode = m_pTreeView->NextItem(m_pTreeView->GetRoot());`
`494`	`494`
`495`	`495`	`// New search, hence search from beginning`
`496`	`496`	`if (previousSearch != itemToSearch)`
`497`	`497`	`{`
`498`	`498`	`previousSearch = itemToSearch;`
`499`		`- nextNode = m_hTreeView->NextItem(m_hTreeView->GetRoot());`
	`499`	`+ nextNode = m_pTreeView->NextItem(m_pTreeView->GetRoot());`
`500`	`500`	`foundCount = 0;`
`501`	`501`	`}`
`502`	`502`	`else`
`503`	`503`	`{`
`504`		`- nextNode = m_hTreeView->NextItem(nextNode);`
`505`		`- if (nextNode == m_hTreeView->GetRoot())`
	`504`	`+ nextNode = m_pTreeView->NextItem(nextNode);`
	`505`	`+ if (nextNode == m_pTreeView->GetRoot())`
`506`	`506`	`{`
`507`		`- nextNode = m_hTreeView->NextItem(nextNode);`
	`507`	`+ nextNode = m_pTreeView->NextItem(nextNode);`
`508`	`508`	`foundCount = 0;`
`509`	`509`	`}`
`510`	`510`	`}`
`511`	`511`
`512`	`512`	`// Check if this is an empty json`
`513`		`- std::wstring nodeText = m_hTreeView->GetNodeName(nextNode, true);`
	`513`	`+ std::wstring nodeText = m_pTreeView->GetNodeName(nextNode, true);`
`514`	`514`	`if (nodeText.empty() \|\| wcscmp(nodeText.c_str(), JSON_ERR_PARSE) == 0)`
`515`	`515`	`{`
`516`	`516`	`CUtility::SetEditCtrlText(::GetDlgItem(_hSelf, IDC_EDT_NODEPATH), STR_SRCH_NOTFOUND + itemToSearch);`
`@@ -520,9 +520,9 @@ void JsonViewDlg::SearchInTree()`
`520`	`520`	`bool bFound = false;`
`521`	`521`	`while (!bFound && nextNode)`
`522`	`522`	`{`
`523`		`- nodeText = m_hTreeView->GetNodeName(nextNode, true);`
`524`		`- auto nodeKey = m_hTreeView->GetNodeKey(nextNode);`
`525`		`- auto nodeVal = m_hTreeView->GetNodeValue(nextNode);`
	`523`	`+ nodeText = m_pTreeView->GetNodeName(nextNode, true);`
	`524`	`+ auto nodeKey = m_pTreeView->GetNodeKey(nextNode);`
	`525`	`+ auto nodeVal = m_pTreeView->GetNodeValue(nextNode);`
`526`	`526`
`527`	`527`	`// Search in node value`
`528`	`528`	`// 1. If both key and value are not equal`
`@@ -545,13 +545,13 @@ void JsonViewDlg::SearchInTree()`
`545`	`545`	`if (bFound)`
`546`	`546`	`break;`
`547`	`547`
`548`		`- nextNode = m_hTreeView->NextItem(nextNode);`
	`548`	`+ nextNode = m_pTreeView->NextItem(nextNode);`
`549`	`549`	`}`
`550`	`550`
`551`	`551`	`if (bFound)`
`552`	`552`	`{`
`553`	`553`	`UpdateNodePath(nextNode);`
`554`		`- m_hTreeView->SetSelection(nextNode);`
	`554`	`+ m_pTreeView->SetSelection(nextNode);`
`555`	`555`	`++foundCount;`
`556`	`556`	`}`
`557`	`557`	`else`
`@@ -719,15 +719,15 @@ void JsonViewDlg::ShowContextMenu(int x, int y)`
`719`	`719`
`720`	`720`	`TVHITTESTINFO tvHitInfo {.pt = p, .flags = 0, .hItem = nullptr};`
`721`	`721`
`722`		`- m_hTreeView->ScreenToTreeView(&(tvHitInfo.pt));`
	`722`	`+ m_pTreeView->ScreenToTreeView(&(tvHitInfo.pt));`
`723`	`723`
`724`	`724`	`// Detect if the given position is on the element TVITEM`
`725`		`- HTREEITEM hTreeItem = m_hTreeView->HitTest(&tvHitInfo);`
	`725`	`+ HTREEITEM hTreeItem = m_pTreeView->HitTest(&tvHitInfo);`
`726`	`726`
`727`	`727`	`if (hTreeItem != nullptr)`
`728`	`728`	`{`
`729`	`729`	`// Make item selected`
`730`		`- m_hTreeView->SelectItem(hTreeItem);`
	`730`	`+ m_pTreeView->SelectItem(hTreeItem);`
`731`	`731`
`732`	`732`	`if (tvHitInfo.flags & (TVHT_ONITEM \| TVHT_ONITEMBUTTON))`
`733`	`733`	`{`
`@@ -741,7 +741,7 @@ void JsonViewDlg::ShowContextMenu(int x, int y)`
`741`	`741`	`void JsonViewDlg::ShowContextMenu(HTREEITEM htiNode, LPPOINT lppScreen)`
`742`	`742`	`{`
`743`	`743`	`// Select it`
`744`		`- m_hTreeView->SelectItem(htiNode);`
	`744`	`+ m_pTreeView->SelectItem(htiNode);`
`745`	`745`
`746`	`746`	`// Show menu`
`747`	`747`	`if (lppScreen != NULL)`
`@@ -753,19 +753,19 @@ void JsonViewDlg::ShowContextMenu(HTREEITEM htiNode, LPPOINT lppScreen)`
`753`	`753`	`bool bEnableExpand = false;`
`754`	`754`	`bool bEnableCollapse = false;`
`755`	`755`
`756`		`- if (m_hTreeView->GetRoot() == htiNode)`
	`756`	`+ if (m_pTreeView->GetRoot() == htiNode)`
`757`	`757`	`{`
`758`	`758`	`bEnableCopyName = false;`
`759`	`759`	`bEnableCopyValue = false;`
`760`	`760`	`bEnableCopyPath = false;`
`761`	`761`	`}`
`762`	`762`
`763`		`- if (m_hTreeView->HasChild(htiNode))`
	`763`	`+ if (m_pTreeView->HasChild(htiNode))`
`764`	`764`	`{`
`765`	`765`	`bEnableCopyName = false;`
`766`	`766`	`bEnableCopyValue = false;`
`767`		`- bEnableCollapse = m_hTreeView->IsThisOrAnyChildExpanded(htiNode);`
`768`		`- bEnableExpand = m_hTreeView->IsThisOrAnyChildCollapsed(htiNode);`
	`767`	`+ bEnableCollapse = m_pTreeView->IsThisOrAnyChildExpanded(htiNode);`
	`768`	`+ bEnableExpand = m_pTreeView->IsThisOrAnyChildCollapsed(htiNode);`
`769`	`769`	`}`
`770`	`770`
`771`	`771`	`// Create menu`
`@@ -806,56 +806,56 @@ void JsonViewDlg::ShowContextMenu(HTREEITEM htiNode, LPPOINT lppScreen)`
`806`	`806`
`807`	`807`	`void JsonViewDlg::ContextMenuExpand(bool bExpand)`
`808`	`808`	`{`
`809`		`- HTREEITEM htiSelected = m_hTreeView->GetSelection();`
	`809`	`+ HTREEITEM htiSelected = m_pTreeView->GetSelection();`
`810`	`810`	`if (htiSelected == NULL)`
`811`	`811`	`return;`
`812`	`812`
`813`		`- HTREEITEM htiRoot = m_hTreeView->GetRoot();`
	`813`	`+ HTREEITEM htiRoot = m_pTreeView->GetRoot();`
`814`	`814`	`HTREEITEM htiNext = htiSelected;`
`815`	`815`	`while (htiNext != NULL)`
`816`	`816`	`{`
`817`	`817`	`if (!(htiNext == htiRoot && !bExpand))`
`818`		`- bExpand ? m_hTreeView->Expand(htiNext) : m_hTreeView->Collapse(htiNext);`
`819`		`- htiNext = m_hTreeView->NextItem(htiNext, htiSelected);`
	`818`	`+ bExpand ? m_pTreeView->Expand(htiNext) : m_pTreeView->Collapse(htiNext);`
	`819`	`+ htiNext = m_pTreeView->NextItem(htiNext, htiSelected);`
`820`	`820`	`}`
`821`	`821`	`}`
`822`	`822`
`823`	`823`	`auto JsonViewDlg::CopyName() const -> std::wstring`
`824`	`824`	`{`
`825`		`- HTREEITEM selectedNode = m_hTreeView->GetSelection();`
	`825`	`+ HTREEITEM selectedNode = m_pTreeView->GetSelection();`
`826`	`826`	`if (selectedNode)`
`827`	`827`	`{`
`828`		`- return m_hTreeView->GetNodeName(selectedNode, true);`
	`828`	`+ return m_pTreeView->GetNodeName(selectedNode, true);`
`829`	`829`	`}`
`830`	`830`	`return std::wstring();`
`831`	`831`	`}`
`832`	`832`
`833`	`833`	`auto JsonViewDlg::CopyKey() const -> std::wstring`
`834`	`834`	`{`
`835`		`- HTREEITEM selectedNode = m_hTreeView->GetSelection();`
	`835`	`+ HTREEITEM selectedNode = m_pTreeView->GetSelection();`
`836`	`836`	`if (selectedNode)`
`837`	`837`	`{`
`838`		`- return m_hTreeView->GetNodeKey(selectedNode);`
	`838`	`+ return m_pTreeView->GetNodeKey(selectedNode);`
`839`	`839`	`}`
`840`	`840`	`return std::wstring();`
`841`	`841`	`}`
`842`	`842`
`843`	`843`	`auto JsonViewDlg::CopyValue() const -> std::wstring`
`844`	`844`	`{`
`845`		`- HTREEITEM selectedNode = m_hTreeView->GetSelection();`
	`845`	`+ HTREEITEM selectedNode = m_pTreeView->GetSelection();`
`846`	`846`	`if (selectedNode)`
`847`	`847`	`{`
`848`		`- return m_hTreeView->GetNodeValue(selectedNode);`
	`848`	`+ return m_pTreeView->GetNodeValue(selectedNode);`
`849`	`849`	`}`
`850`	`850`	`return std::wstring();`
`851`	`851`	`}`
`852`	`852`
`853`	`853`	`auto JsonViewDlg::CopyPath() const -> std::wstring`
`854`	`854`	`{`
`855`		`- HTREEITEM selectedNode = m_hTreeView->GetSelection();`
	`855`	`+ HTREEITEM selectedNode = m_pTreeView->GetSelection();`
`856`	`856`	`if (selectedNode)`
`857`	`857`	`{`
`858`		`- return m_hTreeView->GetNodePath(selectedNode);`
	`858`	`+ return m_pTreeView->GetNodePath(selectedNode);`
`859`	`859`	`}`
`860`	`860`	`return std::wstring();`
`861`	`861`	`}`
`@@ -911,7 +911,7 @@ void JsonViewDlg::HandleTreeEvents(LPARAM lParam)`
`911`	`911`	`{`
`912`	`912`	`UpdateNodePath(hItem);`
`913`	`913`
`914`		`- auto pPosition = m_hTreeView->GetNodePosition(hItem);`
	`914`	`+ auto pPosition = m_pTreeView->GetNodePosition(hItem);`
`915`	`915`	`if (pPosition != nullptr)`
`916`	`916`	`{`
`917`	`917`	`GoToLine(pPosition->nLine);`
`@@ -922,9 +922,9 @@ void JsonViewDlg::HandleTreeEvents(LPARAM lParam)`
`922`	`922`
`923`	`923`	`case NM_DBLCLK:`
`924`	`924`	`{`
`925`		`- HTREEITEM hItem = m_hTreeView->GetSelection();`
	`925`	`+ HTREEITEM hItem = m_pTreeView->GetSelection();`
`926`	`926`
`927`		`- auto pPosition = m_hTreeView->GetNodePosition(hItem);`
	`927`	`+ auto pPosition = m_pTreeView->GetNodePosition(hItem);`
`928`	`928`	`if (pPosition != nullptr)`
`929`	`929`	`{`
`930`	`930`	`GoToPosition(pPosition->nLine, pPosition->nColumn, pPosition->nKeyLength);`
`@@ -1029,7 +1029,7 @@ INT_PTR JsonViewDlg::run_dlgProc(UINT message, WPARAM wParam, LPARAM lParam)`
`1029`	`1029`	`// Save ourselves in GWLP_USERDATA.`
`1030`	`1030`	`::SetWindowLongPtr(getHSelf(), GWLP_USERDATA, reinterpret_cast<LONG_PTR>(this));`
`1031`	`1031`
`1032`		`- m_hTreeView->OnInit(getHSelf());`
	`1032`	`+ m_pTreeView->OnInit(getHSelf());`
`1033`	`1033`
`1034`	`1034`	`PrepareButtons();`
`1035`	`1035`