src/TortoiseProc/GitTagCompareList.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2015-2017 - TortoiseGit
   4
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License
   7 // as published by the Free Software Foundation; either version 2
   8 // of the License, or (at your option) any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19 // GitRefCompareList.cpp : implementation file
  20 //
  21 #include "stdafx.h"
  22 #include "resource.h"
  23 #include "Git.h"
  24 #include "GitTagCompareList.h"
  25 #include "GitRefCompareList.h"
  26 #include "registry.h"
  27 #include "UnicodeUtils.h"
  28 #include "IconMenu.h"
  29 #include "AppUtils.h"
  30 #include "..\TortoiseShell\resource.h"
  31 #include "LoglistCommonResource.h"
  32 #include "SysProgressDlg.h"
  33 #include "ProgressDlg.h"
  34
  35 IMPLEMENT_DYNAMIC(CGitTagCompareList, CHintCtrl<CListCtrl>)
  36
  37 BEGIN_MESSAGE_MAP(CGitTagCompareList, CHintCtrl<CListCtrl>)
  38         ON_WM_CONTEXTMENU()
  39         ON_NOTIFY(HDN_ITEMCLICKA, 0, OnHdnItemclick)
  40         ON_NOTIFY(HDN_ITEMCLICKW, 0, OnHdnItemclick)
  41 END_MESSAGE_MAP()
  42
  43 BOOL CGitTagCompareList::m_bSortLogical = FALSE;
  44
  45 enum IDGITRCL
  46 {
  47         IDGITRCL_MYLOG = 1,
  48         IDGITRCL_THEIRLOG,
  49         IDGITRCL_COMPARE,
  50         IDGITRCL_DELETELOCAL,
  51         IDGITRCL_DELETEREMOTE,
  52         IDGITRCL_PUSH,
  53         IDGITRCL_FETCH,
  54 };
  55
  56 enum IDGITRCLH
  57 {
  58         IDGITRCLH_HIDEUNCHANGED = 1,
  59 };
  60
  61 inline static bool SortPredicate(bool sortLogical, const CString& e1, const CString& e2)
  62 {
  63         if (sortLogical)
  64                 return StrCmpLogicalW(e1, e2) < 0;
  65         return e1.Compare(e2) < 0;
  66 }
  67
  68 CGitTagCompareList::CGitTagCompareList()
  69         : CHintCtrl<CListCtrl>()
  70         , colTag(0)
  71         , colDiff(0)
  72         , colMyHash(0)
  73         , colMyMessage(0)
  74         , colTheirHash(0)
  75         , colTheirMessage(0)
  76         , m_bAscending(false)
  77         , m_nSortedColumn(-1)
  78 {
  79         m_bSortLogical = !CRegDWORD(L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer\\NoStrCmpLogical", 0, false, HKEY_CURRENT_USER);
  80         if (m_bSortLogical)
  81                 m_bSortLogical = !CRegDWORD(L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer\\NoStrCmpLogical", 0, false, HKEY_LOCAL_MACHINE);
  82         m_bHideEqual = CRegDWORD(L"Software\\TortoiseGit\\TagCompareHideEqual", FALSE);
  83 }
  84
  85 void CGitTagCompareList::Init()
  86 {
  87         int index = 0;
  88         colTag = InsertColumn(index++, CString(MAKEINTRESOURCE(IDS_PROC_TAG)));
  89         colDiff = InsertColumn(index++, CString(MAKEINTRESOURCE(IDS_STATUSLIST_COLSTATUS)));
  90         colMyHash = InsertColumn(index++, CString(MAKEINTRESOURCE(IDS_TAGCOMPARE_LOCALHASH)));
  91         colMyMessage = InsertColumn(index++, CString(MAKEINTRESOURCE(IDS_TAGCOMPARE_LOCALMESSAGE)));
  92         colTheirHash = InsertColumn(index++, CString(MAKEINTRESOURCE(IDS_TAGCOMPARE_REMOTEHASH)));
  93         colTheirMessage = InsertColumn(index++, CString(MAKEINTRESOURCE(IDS_TAGCOMPARE_REMOTEMESSAGE)));
  94
  95         SetWindowTheme(m_hWnd, L"Explorer", nullptr);
  96
  97         if (!!CRegDWORD(L"Software\\TortoiseGit\\SortTagsReversed", 0, false, HKEY_LOCAL_MACHINE) || !!CRegDWORD(L"Software\\TortoiseGit\\SortTagsReversed", 0, false, HKEY_CURRENT_USER))
  98         {
  99                 m_bAscending = false;
 100                 m_nSortedColumn = 0;
 101         }
 102 }
 103
 104 int CGitTagCompareList::Fill(const CString& remote, CString& err)
 105 {
 106         m_remote = remote;
 107         m_TagList.clear();
 108         DeleteAllItems();
 109         {
 110                 CString pleaseWait;
 111                 pleaseWait.LoadString(IDS_PROGRESSWAIT);
 112                 ShowText(pleaseWait, true);
 113         }
 114         if (!g_Git.m_IsUseLibGit2)
 115         {
 116                 err = L"Only available with libgit2 enabled";
 117                 return -1;
 118         }
 119
 120         REF_VECTOR remoteTags;
 121         if (g_Git.GetRemoteTags(remote, remoteTags))
 122         {
 123                 err = g_Git.GetGitLastErr(L"Could not retrieve remote tags.", CGit::GIT_CMD_FETCH);
 124                 return -1;
 125         }
 126
 127         CAutoRepository repo(g_Git.GetGitRepository());
 128         if (!repo)
 129         {
 130                 err = CGit::GetLibGit2LastErr(L"Could not open repository.");
 131                 return -1;
 132         }
 133
 134         MAP_HASH_NAME hashMap;
 135         if (CGit::GetMapHashToFriendName(repo, hashMap))
 136         {
 137                 err = CGit::GetLibGit2LastErr(L"Could not get all refs.");
 138                 return -1;
 139         }
 140
 141         REF_VECTOR localTags;
 142         for (auto it = hashMap.cbegin(); it != hashMap.cend(); ++it)
 143         {
 144                 const auto& hash = it->first;
 145                 const auto& refs = it->second;
 146                 std::for_each(refs.cbegin(), refs.cend(), [&](const auto& ref)
 147                 {
 148                         if (CStringUtils::StartsWith(ref, L"refs/tags/"))
 149                         {
 150                                 auto tagname = ref.Mid((int)wcslen(L"refs/tags/"));
 151                                 localTags.emplace_back(TGitRef{ tagname, hash });
 152                                 if (CStringUtils::EndsWith(tagname, L"^{}"))
 153                                 {
 154                                         tagname.Replace(L"^{}", L"");
 155                                         CAutoObject gitObject;
 156                                         if (git_revparse_single(gitObject.GetPointer(), repo, CUnicodeUtils::GetUTF8(tagname)))
 157                                                 return;
 158                                         CGitHash tagHash;
 159                                         git_oid_cpy((git_oid*)tagHash.m_hash, git_object_id(gitObject));
 160                                         localTags.emplace_back(TGitRef{ tagname, tagHash });
 161                                 }
 162                         }
 163                 });
 164         }
 165         std::sort(remoteTags.begin(), remoteTags.end(), std::bind(SortPredicate, m_bSortLogical, std::placeholders::_1, std::placeholders::_2));
 166         std::sort(localTags.begin(), localTags.end(), std::bind(SortPredicate, m_bSortLogical, std::placeholders::_1, std::placeholders::_2));
 167
 168         auto remoteIt = remoteTags.cbegin();
 169         auto localIt = localTags.cbegin();
 170
 171         while (remoteIt != remoteTags.cend() && localIt != localTags.cend())
 172         {
 173                 if (SortPredicate(m_bSortLogical, remoteIt->name, localIt->name))
 174                 {
 175                         AddEntry(repo, remoteIt->name, nullptr, &remoteIt->hash);
 176                         ++remoteIt;
 177                         continue;
 178                 }
 179
 180                 if (remoteIt->name == localIt->name)
 181                 {
 182                         AddEntry(repo, remoteIt->name, &localIt->hash, &remoteIt->hash);
 183                         ++remoteIt;
 184                 }
 185                 else
 186                         AddEntry(repo, localIt->name, &localIt->hash, nullptr);
 187
 188                 ++localIt;
 189         }
 190
 191         while (remoteIt != remoteTags.cend())
 192         {
 193                 AddEntry(repo, remoteIt->name, nullptr, &remoteIt->hash);
 194                 ++remoteIt;
 195         }
 196
 197         while (localIt != localTags.cend())
 198         {
 199                 AddEntry(repo, localIt->name, &localIt->hash, nullptr);
 200                 ++localIt;
 201         }
 202
 203         Show();
 204
 205         CHeaderCtrl * pHeader = GetHeaderCtrl();
 206         HDITEM HeaderItem = { 0 };
 207         HeaderItem.mask = HDI_FORMAT;
 208         for (int i = 0; i < pHeader->GetItemCount(); ++i)
 209         {
 210                 pHeader->GetItem(i, &HeaderItem);
 211                 HeaderItem.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
 212                 pHeader->SetItem(i, &HeaderItem);
 213         }
 214         if (m_nSortedColumn >= 0)
 215         {
 216                 pHeader->GetItem(m_nSortedColumn, &HeaderItem);
 217                 HeaderItem.fmt |= (m_bAscending ? HDF_SORTUP : HDF_SORTDOWN);
 218                 pHeader->SetItem(m_nSortedColumn, &HeaderItem);
 219         }
 220
 221         return 0;
 222 }
 223
 224 void CGitTagCompareList::AddEntry(git_repository* repo, const CString& tag, const CGitHash* myHash, const CGitHash* theirHash)
 225 {
 226         TagEntry entry;
 227         entry.name = tag;
 228         if (myHash)
 229                 entry.myHash = *myHash;
 230         if (theirHash)
 231                 entry.theirHash = *theirHash;
 232
 233         CAutoCommit oldCommit;
 234         if (myHash)
 235         {
 236                 if (!git_commit_lookup(oldCommit.GetPointer(), repo, (const git_oid*)&myHash->m_hash))
 237                         entry.myMessage = CGitRefCompareList::GetCommitMessage(oldCommit);
 238         }
 239
 240         CAutoCommit newCommit;
 241         if (theirHash)
 242         {
 243                 if (!git_commit_lookup(newCommit.GetPointer(), repo, (const git_oid*)&theirHash->m_hash))
 244                         entry.theirMessage = CGitRefCompareList::GetCommitMessage(newCommit);
 245         }
 246
 247         if (myHash && theirHash)
 248         {
 249                 if (*myHash == *theirHash)
 250                         entry.diffstate.LoadString(IDS_TAGCOMPARE_SAME);
 251                 else
 252                         entry.diffstate.LoadString(IDS_TAGCOMPARE_DIFFER);
 253         }
 254         else if (myHash)
 255                 entry.diffstate.LoadString(IDS_TAGCOMPARE_ONLYLOCAL);
 256         else
 257                 entry.diffstate.LoadString(IDS_TAGCOMPARE_ONLYREMOTE);
 258         m_TagList.emplace_back(entry);
 259 }
 260
 261 void CGitTagCompareList::Show()
 262 {
 263         {
 264                 CString pleaseWait;
 265                 pleaseWait.LoadString(IDS_PROGRESSWAIT);
 266                 ShowText(pleaseWait, true);
 267         }
 268         SetRedraw(false);
 269         DeleteAllItems();
 270
 271         if (m_nSortedColumn >= 0)
 272         {
 273                 auto predicate = [](bool sortLogical, int sortColumn, const TagEntry& e1, const TagEntry& e2)
 274                 {
 275                         switch (sortColumn)
 276                         {
 277                         case 0:
 278                                 return SortPredicate(sortLogical, e1.name, e2.name);
 279                                 break;
 280                         case 1:
 281                                 return SortPredicate(false, e1.diffstate, e2.diffstate);
 282                                 break;
 283                         case 2:
 284                                 return e1.myHash < e2.myHash;
 285                                 break;
 286                         case 3:
 287                                 return SortPredicate(sortLogical, e1.myMessage, e2.myMessage);
 288                                 break;
 289                         case 4:
 290                                 return e1.theirHash < e2.theirHash;
 291                                 break;
 292                         case 5:
 293                                 return SortPredicate(sortLogical, e1.theirMessage, e2.theirMessage);
 294                                 break;
 295                         }
 296                         return false;
 297                 };
 298
 299                 if (m_bAscending)
 300                         std::stable_sort(m_TagList.begin(), m_TagList.end(), std::bind(predicate, m_bSortLogical, m_nSortedColumn, std::placeholders::_1, std::placeholders::_2));
 301                 else
 302                         std::stable_sort(m_TagList.begin(), m_TagList.end(), std::bind(predicate, m_bSortLogical, m_nSortedColumn, std::placeholders::_2, std::placeholders::_1));
 303         }
 304
 305         int index = 0;
 306         for (const auto& entry : m_TagList)
 307         {
 308                 if (entry.myHash == entry.theirHash && m_bHideEqual)
 309                         continue;
 310
 311                 InsertItem(index, entry.name);
 312                 SetItemText(index, colDiff, entry.diffstate);
 313                 if (!entry.myHash.IsEmpty())
 314                         SetItemText(index, colMyHash, entry.myHash.ToString().Left(g_Git.GetShortHASHLength()));
 315                 SetItemText(index, colMyMessage, entry.myMessage);
 316                 if (!entry.theirHash.IsEmpty())
 317                         SetItemText(index, colTheirHash, entry.theirHash.ToString().Left(g_Git.GetShortHASHLength()));
 318                 SetItemText(index, colTheirMessage, entry.theirMessage);
 319                 ++index;
 320         }
 321         for (int i = 0; i < GetHeaderCtrl()->GetItemCount(); ++i)
 322                 SetColumnWidth(i, LVSCW_AUTOSIZE_USEHEADER);
 323
 324         auto pHeader = GetHeaderCtrl();
 325         HDITEM HeaderItem = { 0 };
 326         HeaderItem.mask = HDI_FORMAT;
 327         for (int i = 0; i < pHeader->GetItemCount(); ++i)
 328         {
 329                 pHeader->GetItem(i, &HeaderItem);
 330                 HeaderItem.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
 331                 pHeader->SetItem(i, &HeaderItem);
 332         }
 333         if (m_nSortedColumn >= 0)
 334         {
 335                 pHeader->GetItem(m_nSortedColumn, &HeaderItem);
 336                 HeaderItem.fmt |= (m_bAscending ? HDF_SORTUP : HDF_SORTDOWN);
 337                 pHeader->SetItem(m_nSortedColumn, &HeaderItem);
 338         }
 339         SetRedraw(true);
 340
 341         if (!index)
 342         {
 343                 CString empty;
 344                 empty.LoadString(IDS_COMPAREREV_NODIFF);
 345                 ShowText(empty, true);
 346         }
 347         else
 348                 ShowText(L"", true);
 349 }
 350
 351 void CGitTagCompareList::OnHdnItemclick(NMHDR *pNMHDR, LRESULT *pResult)
 352 {
 353         auto phdr = reinterpret_cast<LPNMHEADER>(pNMHDR);
 354         *pResult = 0;
 355
 356         if (m_TagList.empty())
 357                 return;
 358
 359         if (m_nSortedColumn == phdr->iItem)
 360                 m_bAscending = !m_bAscending;
 361         else
 362                 m_bAscending = TRUE;
 363         m_nSortedColumn = phdr->iItem;
 364
 365         Show();
 366 }
 367
 368 void CGitTagCompareList::OnContextMenu(CWnd *pWnd, CPoint point)
 369 {
 370         if (pWnd == this)
 371         {
 372                 OnContextMenuList(pWnd, point);
 373         }
 374         else if (pWnd == GetHeaderCtrl())
 375         {
 376                 OnContextMenuHeader(pWnd, point);
 377         }
 378 }
 379
 380 void CGitTagCompareList::OnContextMenuList(CWnd * /*pWnd*/, CPoint point)
 381 {
 382         int selIndex = GetSelectionMark();
 383         if (selIndex < 0)
 384                 return;
 385
 386         CString tag = GetItemText(selIndex, colTag);
 387         tag.Replace(L"^{}", L"");
 388         CString myHash = GetItemText(selIndex, colMyHash);
 389         CString theirHash = GetItemText(selIndex, colTheirHash);
 390         CIconMenu popup;
 391         popup.CreatePopupMenu();
 392         CString logStr;
 393         if (!myHash.IsEmpty())
 394         {
 395                 logStr.Format(IDS_SHOWLOG_OF, (LPCTSTR)myHash);
 396                 popup.AppendMenuIcon(IDGITRCL_MYLOG, logStr, IDI_LOG);
 397         }
 398
 399         if (myHash != theirHash)
 400         {
 401                 if (!theirHash.IsEmpty())
 402                 {
 403                         logStr.Format(IDS_SHOWLOG_OF, (LPCTSTR)theirHash);
 404                         popup.AppendMenuIcon(IDGITRCL_THEIRLOG, logStr, IDI_LOG);
 405                 }
 406
 407                 if (!myHash.IsEmpty() && !theirHash.IsEmpty())
 408                         popup.AppendMenuIcon(IDGITRCL_COMPARE, IDS_LOG_POPUP_COMPAREWITHPREVIOUS, IDI_DIFF);
 409
 410                 popup.AppendMenu(MF_SEPARATOR);
 411
 412                 if (!theirHash.IsEmpty())
 413                         popup.AppendMenuIcon(IDGITRCL_FETCH, IDS_MENUFETCH, IDI_UPDATE);
 414
 415                 if (!myHash.IsEmpty())
 416                         popup.AppendMenuIcon(IDGITRCL_PUSH, IDS_MENUPUSH, IDI_COMMIT);
 417
 418         }
 419         popup.AppendMenu(MF_SEPARATOR);
 420
 421         if (!myHash.IsEmpty())
 422                 popup.AppendMenuIcon(IDGITRCL_DELETELOCAL, IDS_DELETE_LOCALTAG, IDI_DELETE);
 423
 424         if (!theirHash.IsEmpty())
 425                 popup.AppendMenuIcon(IDGITRCL_DELETEREMOTE, IDS_DELETE_REMOTETAG, IDI_DELETE);
 426
 427         int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this);
 428         switch (cmd)
 429         {
 430                 case IDGITRCL_MYLOG:
 431                 case IDGITRCL_THEIRLOG:
 432                 {
 433                         CString sCmd;
 434                         sCmd.Format(L"/command:log /path:\"%s\" /endrev:\"%s\"", (LPCTSTR)g_Git.m_CurrentDir, cmd == IDGITRCL_MYLOG ? (LPCTSTR)myHash : (LPCTSTR)theirHash);
 435                         CAppUtils::RunTortoiseGitProc(sCmd);
 436                         break;
 437                 }
 438                 case IDGITRCL_COMPARE:
 439                 {
 440                         CString sCmd;
 441                         sCmd.Format(L"/command:showcompare /path:\"%s\" /revision1:\"%s\" /revision2:\"%s\"", (LPCTSTR)g_Git.m_CurrentDir, (LPCTSTR)myHash, (LPCTSTR)theirHash);
 442                         if (!!(GetAsyncKeyState(VK_SHIFT) & 0x8000))
 443                                 sCmd += L" /alternative";
 444                         CAppUtils::RunTortoiseGitProc(sCmd);
 445                         break;
 446                 }
 447                 case IDGITRCL_DELETELOCAL:
 448                 {
 449                         CString csMessage;
 450                         csMessage.Format(IDS_PROC_DELETEBRANCHTAG, (LPCTSTR)tag);
 451                         if (MessageBox(csMessage, L"TortoiseGit", MB_YESNO | MB_ICONQUESTION) != IDYES)
 452                                 return;
 453
 454                         g_Git.DeleteRef(L"refs/tags/" + tag);
 455
 456                         CString err;
 457                         if (Fill(m_remote, err))
 458                                 MessageBox(err, L"TortoiseGit", MB_ICONERROR);
 459                         break;
 460                 }
 461                 case IDGITRCL_DELETEREMOTE:
 462                 {
 463                         CString csMessage;
 464                         csMessage.Format(IDS_PROC_DELETEBRANCHTAG, (LPCTSTR)tag);
 465                         if (MessageBox(csMessage, L"TortoiseGit", MB_YESNO | MB_ICONQUESTION) != IDYES)
 466                                 return;
 467                         CSysProgressDlg sysProgressDlg;
 468                         sysProgressDlg.SetTitle(CString(MAKEINTRESOURCE(IDS_APPNAME)));
 469                         sysProgressDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_DELETING_REMOTE_REFS)));
 470                         sysProgressDlg.SetLine(2, CString(MAKEINTRESOURCE(IDS_PROGRESSWAIT)));
 471                         sysProgressDlg.SetShowProgressBar(false);
 472                         sysProgressDlg.ShowModal(this, true);
 473
 474                         STRING_VECTOR list;
 475                         list.push_back(L"refs/tags/" + tag);
 476                         if (g_Git.DeleteRemoteRefs(m_remote, list))
 477                         {
 478                                 MessageBox(g_Git.GetGitLastErr(L"Could not delete remote tag.", CGit::GIT_CMD_PUSH), L"TortoiseGit", MB_OK | MB_ICONERROR);
 479                                 sysProgressDlg.Stop();
 480                                 BringWindowToTop();
 481                                 return;
 482                         }
 483
 484                         CString err;
 485                         auto ret = Fill(m_remote, err);
 486                         sysProgressDlg.Stop();
 487                         if (ret)
 488                                 MessageBox(err, L"TortoiseGit", MB_ICONERROR);
 489
 490                         BringWindowToTop();
 491                         break;
 492                 }
 493                 case IDGITRCL_PUSH:
 494                 {
 495                         CProgressDlg dlg;
 496                         dlg.m_GitCmd.Format(L"git.exe push --force \"%s\" refs/tags/%s", (LPCTSTR)m_remote, (LPCTSTR)tag);
 497                         dlg.DoModal();
 498
 499                         CString err;
 500                         if (Fill(m_remote, err))
 501                                 MessageBox(err, L"TortoiseGit", MB_ICONERROR);
 502
 503                         break;
 504                 }
 505                 case IDGITRCL_FETCH:
 506                 {
 507                         CProgressDlg dlg;
 508                         dlg.m_GitCmd.Format(L"git.exe fetch \"%s\" refs/tags/%s:refs/tags/%s", (LPCTSTR)m_remote, (LPCTSTR)tag, (LPCTSTR)tag);
 509                         dlg.DoModal();
 510
 511                         CString err;
 512                         if (Fill(m_remote, err))
 513                                 MessageBox(err, L"TortoiseGit", MB_ICONERROR);
 514
 515                         break;
 516                 }
 517         }
 518 }
 519
 520 static void AppendMenuChecked(CMenu &menu, UINT nTextID, UINT_PTR nItemID, BOOL checked = FALSE, BOOL enabled = TRUE)
 521 {
 522         CString text;
 523         text.LoadString(nTextID);
 524         menu.AppendMenu(MF_STRING | (enabled ? MF_ENABLED : MF_DISABLED) | (checked ? MF_CHECKED : MF_UNCHECKED), nItemID, text);
 525 }
 526
 527 void CGitTagCompareList::OnContextMenuHeader(CWnd * /*pWnd*/, CPoint point)
 528 {
 529         CMenu popup;
 530         if (popup.CreatePopupMenu())
 531         {
 532                 AppendMenuChecked(popup, IDS_HIDEUNCHANGED, IDGITRCLH_HIDEUNCHANGED, m_bHideEqual);
 533
 534                 int selection = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this);
 535                 switch (selection)
 536                 {
 537                         case IDGITRCLH_HIDEUNCHANGED:
 538                                 m_bHideEqual = !m_bHideEqual;
 539                                 Show();
 540                                 break;
 541                 }
 542         }
 543 }