src/TortoiseProc/BrowseRefsDlg.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2009-2012 - 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 // BrowseRefsDlg.cpp : implementation file
  20 //
  21
  22 #include "stdafx.h"
  23 #include "TortoiseProc.h"
  24 #include "BrowseRefsDlg.h"
  25 #include "LogDlg.h"
  26 #include "AddRemoteDlg.h"
  27 #include "AppUtils.h"
  28 #include "Settings\SettingGitRemote.h"
  29 #include "SinglePropSheetDlg.h"
  30 #include "MessageBox.h"
  31 #include "RefLogDlg.h"
  32 #include "IconMenu.h"
  33 #include "FileDiffDlg.h"
  34
  35 void SetSortArrow(CListCtrl * control, int nColumn, bool bAscending)
  36 {
  37         if (control == NULL)
  38                 return;
  39         // set the sort arrow
  40         CHeaderCtrl * pHeader = control->GetHeaderCtrl();
  41         HDITEM HeaderItem = {0};
  42         HeaderItem.mask = HDI_FORMAT;
  43         for (int i=0; i<pHeader->GetItemCount(); ++i)
  44         {
  45                 pHeader->GetItem(i, &HeaderItem);
  46                 HeaderItem.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
  47                 pHeader->SetItem(i, &HeaderItem);
  48         }
  49         if (nColumn >= 0)
  50         {
  51                 pHeader->GetItem(nColumn, &HeaderItem);
  52                 HeaderItem.fmt |= (bAscending ? HDF_SORTUP : HDF_SORTDOWN);
  53                 pHeader->SetItem(nColumn, &HeaderItem);
  54         }
  55 }
  56
  57 // CBrowseRefsDlg dialog
  58
  59 IMPLEMENT_DYNAMIC(CBrowseRefsDlg, CResizableStandAloneDialog)
  60
  61 CBrowseRefsDlg::CBrowseRefsDlg(CString cmdPath, CWnd* pParent /*=NULL*/)
  62 :       CResizableStandAloneDialog(CBrowseRefsDlg::IDD, pParent),
  63         m_cmdPath(cmdPath),
  64         m_currSortCol(-1),
  65         m_currSortDesc(false),
  66         m_initialRef(L"HEAD"),
  67         m_pickRef_Kind(gPickRef_All),
  68         m_pListCtrlRoot(NULL),
  69         m_bHasWC(true)
  70 {
  71
  72 }
  73
  74 CBrowseRefsDlg::~CBrowseRefsDlg()
  75 {
  76 }
  77
  78 void CBrowseRefsDlg::DoDataExchange(CDataExchange* pDX)
  79 {
  80         CDialog::DoDataExchange(pDX);
  81         DDX_Control(pDX, IDC_TREE_REF,                  m_RefTreeCtrl);
  82         DDX_Control(pDX, IDC_LIST_REF_LEAFS,    m_ListRefLeafs);
  83 }
  84
  85
  86 BEGIN_MESSAGE_MAP(CBrowseRefsDlg, CResizableStandAloneDialog)
  87         ON_BN_CLICKED(IDOK, &CBrowseRefsDlg::OnBnClickedOk)
  88         ON_NOTIFY(TVN_SELCHANGED, IDC_TREE_REF, &CBrowseRefsDlg::OnTvnSelchangedTreeRef)
  89         ON_WM_CONTEXTMENU()
  90         ON_NOTIFY(LVN_COLUMNCLICK, IDC_LIST_REF_LEAFS, &CBrowseRefsDlg::OnLvnColumnclickListRefLeafs)
  91         ON_WM_DESTROY()
  92         ON_NOTIFY(NM_DBLCLK, IDC_LIST_REF_LEAFS, &CBrowseRefsDlg::OnNMDblclkListRefLeafs)
  93         ON_NOTIFY(LVN_ENDLABELEDIT, IDC_LIST_REF_LEAFS, &CBrowseRefsDlg::OnLvnEndlabeleditListRefLeafs)
  94         ON_NOTIFY(LVN_BEGINLABELEDIT, IDC_LIST_REF_LEAFS, &CBrowseRefsDlg::OnLvnBeginlabeleditListRefLeafs)
  95 END_MESSAGE_MAP()
  96
  97
  98 // CBrowseRefsDlg message handlers
  99
 100 void CBrowseRefsDlg::OnBnClickedOk()
 101 {
 102         OnOK();
 103 }
 104
 105 BOOL CBrowseRefsDlg::OnInitDialog()
 106 {
 107         CResizableStandAloneDialog::OnInitDialog();
 108         CAppUtils::MarkWindowAsUnpinnable(m_hWnd);
 109
 110         AddAnchor(IDC_TREE_REF, TOP_LEFT, BOTTOM_LEFT);
 111         AddAnchor(IDC_LIST_REF_LEAFS, TOP_LEFT, BOTTOM_RIGHT);
 112         AddAnchor(IDHELP, BOTTOM_RIGHT);
 113
 114         m_ListRefLeafs.SetExtendedStyle(m_ListRefLeafs.GetExtendedStyle()|LVS_EX_FULLROWSELECT);
 115         CString temp;
 116         temp.LoadString(IDS_BRANCHNAME);
 117         m_ListRefLeafs.InsertColumn(eCol_Name, temp, 0, 150);
 118         temp.LoadString(IDS_DATELASTCOMMIT);
 119         m_ListRefLeafs.InsertColumn(eCol_Date, temp, 0, 100);
 120         temp.LoadString(IDS_LASTCOMMIT);
 121         m_ListRefLeafs.InsertColumn(eCol_Msg, temp, 0, 300);
 122         temp.LoadString(IDS_HASH);
 123         m_ListRefLeafs.InsertColumn(eCol_Hash, temp, 0, 80);
 124
 125         AddAnchor(IDOK,BOTTOM_RIGHT);
 126         AddAnchor(IDCANCEL,BOTTOM_RIGHT);
 127
 128         Refresh(m_initialRef);
 129
 130         EnableSaveRestore(L"BrowseRefs");
 131
 132         CString sWindowTitle;
 133         GetWindowText(sWindowTitle);
 134         CAppUtils::SetWindowTitle(m_hWnd, g_Git.m_CurrentDir, sWindowTitle);
 135
 136         m_bHasWC = !g_GitAdminDir.IsBareRepo(g_Git.m_CurrentDir);
 137
 138         m_ListRefLeafs.SetFocus();
 139         return FALSE;
 140 }
 141
 142 CShadowTree* CShadowTree::GetNextSub(CString& nameLeft, bool bCreateIfNotExist)
 143 {
 144         int posSlash=nameLeft.Find('/');
 145         CString nameSub;
 146         if(posSlash<0)
 147         {
 148                 nameSub=nameLeft;
 149                 nameLeft.Empty();//Nothing left
 150         }
 151         else
 152         {
 153                 nameSub=nameLeft.Left(posSlash);
 154                 nameLeft=nameLeft.Mid(posSlash+1);
 155         }
 156         if(nameSub.IsEmpty())
 157                 return NULL;
 158
 159         if(!bCreateIfNotExist && m_ShadowTree.find(nameSub)==m_ShadowTree.end())
 160                 return NULL;
 161
 162         CShadowTree& nextNode=m_ShadowTree[nameSub];
 163         nextNode.m_csRefName=nameSub;
 164         nextNode.m_pParent=this;
 165         return &nextNode;
 166 }
 167
 168 CShadowTree* CShadowTree::FindLeaf(CString partialRefName)
 169 {
 170         if(IsLeaf())
 171         {
 172                 if(m_csRefName.GetLength() > partialRefName.GetLength())
 173                         return NULL;
 174                 if(partialRefName.Right(m_csRefName.GetLength()) == m_csRefName)
 175                 {
 176                         //Match of leaf name. Try match on total name.
 177                         CString totalRefName = GetRefName();
 178                         if(totalRefName.Right(partialRefName.GetLength()) == partialRefName)
 179                                 return this; //Also match. Found.
 180                 }
 181         }
 182         else
 183         {
 184                 //Not a leaf. Search all nodes.
 185                 for(TShadowTreeMap::iterator itShadowTree = m_ShadowTree.begin(); itShadowTree != m_ShadowTree.end(); ++itShadowTree)
 186                 {
 187                         CShadowTree* pSubtree = itShadowTree->second.FindLeaf(partialRefName);
 188                         if(pSubtree != NULL)
 189                                 return pSubtree; //Found
 190                 }
 191         }
 192         return NULL;//Not found
 193 }
 194
 195
 196 typedef std::map<CString,CString> MAP_STRING_STRING;
 197
 198 CString CBrowseRefsDlg::GetSelectedRef(bool onlyIfLeaf, bool pickFirstSelIfMultiSel)
 199 {
 200         POSITION pos=m_ListRefLeafs.GetFirstSelectedItemPosition();
 201         //List ctrl selection?
 202         if(pos && (pickFirstSelIfMultiSel || m_ListRefLeafs.GetSelectedCount() == 1))
 203         {
 204                 //A leaf is selected
 205                 CShadowTree* pTree=(CShadowTree*)m_ListRefLeafs.GetItemData(
 206                                 m_ListRefLeafs.GetNextSelectedItem(pos));
 207                 return pTree->GetRefName();
 208         }
 209         else if(!onlyIfLeaf)
 210         {
 211                 //Tree ctrl selection?
 212                 HTREEITEM hTree=m_RefTreeCtrl.GetSelectedItem();
 213                 if(hTree!=NULL)
 214                 {
 215                         CShadowTree* pTree=(CShadowTree*)m_RefTreeCtrl.GetItemData(hTree);
 216                         return pTree->GetRefName();
 217                 }
 218         }
 219         return CString();//None
 220 }
 221
 222 void CBrowseRefsDlg::Refresh(CString selectRef)
 223 {
 224 //      m_RefMap.clear();
 225 //      g_Git.GetMapHashToFriendName(m_RefMap);
 226
 227         if(!selectRef.IsEmpty())
 228         {
 229                 if(selectRef == "HEAD")
 230                 {
 231                         selectRef = g_Git.GetSymbolicRef(selectRef, false);
 232                 }
 233         }
 234         else
 235         {
 236                 selectRef = GetSelectedRef(false, true);
 237         }
 238
 239         m_RefTreeCtrl.DeleteAllItems();
 240         m_ListRefLeafs.DeleteAllItems();
 241         m_TreeRoot.m_ShadowTree.clear();
 242         m_TreeRoot.m_csRefName = "refs";
 243         m_TreeRoot.m_hTree=m_RefTreeCtrl.InsertItem(L"Refs",NULL,NULL);
 244         m_RefTreeCtrl.SetItemData(m_TreeRoot.m_hTree,(DWORD_PTR)&m_TreeRoot);
 245
 246         CString allRefs;
 247         g_Git.Run(L"git for-each-ref --format="
 248                           L"%(refname)%04"
 249                           L"%(objectname)%04"
 250                           L"%(authordate:relative)%04"
 251                           L"%(subject)%04"
 252                           L"%(authorname)%04"
 253                           L"%(authordate:iso8601)%03",
 254                           &allRefs, NULL, CP_UTF8);
 255
 256         int linePos=0;
 257         CString singleRef;
 258
 259         MAP_STRING_STRING refMap;
 260
 261         //First sort on ref name
 262         while(!(singleRef=allRefs.Tokenize(L"\03",linePos)).IsEmpty())
 263         {
 264                 singleRef.TrimLeft(L"\r\n");
 265                 int valuePos=0;
 266                 CString refName=singleRef.Tokenize(L"\04",valuePos);
 267                 if(refName.IsEmpty())
 268                         continue;
 269                 CString refRest=singleRef.Mid(valuePos);
 270
 271
 272                 //Use ref based on m_pickRef_Kind
 273                 if(wcsncmp(refName,L"refs/heads",10)==0 && !(m_pickRef_Kind & gPickRef_Head) )
 274                         continue; //Skip
 275                 if(wcsncmp(refName,L"refs/tags",9)==0 && !(m_pickRef_Kind & gPickRef_Tag) )
 276                         continue; //Skip
 277                 if(wcsncmp(refName,L"refs/remotes",12)==0 && !(m_pickRef_Kind & gPickRef_Remote) )
 278                         continue; //Skip
 279
 280                 refMap[refName] = refRest; //Use
 281         }
 282
 283
 284
 285         //Populate ref tree
 286         for(MAP_STRING_STRING::iterator iterRefMap=refMap.begin();iterRefMap!=refMap.end();++iterRefMap)
 287         {
 288                 CShadowTree& treeLeaf=GetTreeNode(iterRefMap->first,NULL,true);
 289                 CString values=iterRefMap->second;
 290                 values.Replace(L"\04" L"\04",L"\04 \04");//Workaround Tokenize problem (treating 2 tokens as one)
 291
 292                 int valuePos=0;
 293                 treeLeaf.m_csRefHash=           values.Tokenize(L"\04",valuePos); if(valuePos < 0) continue;
 294                 treeLeaf.m_csDate=                      values.Tokenize(L"\04",valuePos); if(valuePos < 0) continue;
 295                 treeLeaf.m_csSubject=           values.Tokenize(L"\04",valuePos); if(valuePos < 0) continue;
 296                 treeLeaf.m_csAuthor=            values.Tokenize(L"\04",valuePos); if(valuePos < 0) continue;
 297                 treeLeaf.m_csDate_Iso8601=      values.Tokenize(L"\04",valuePos);
 298         }
 299
 300
 301         if(selectRef.IsEmpty() || !SelectRef(selectRef, false))
 302                 //Probably not on a branch. Select root node.
 303                 m_RefTreeCtrl.Expand(m_TreeRoot.m_hTree,TVE_EXPAND);
 304
 305 }
 306
 307 bool CBrowseRefsDlg::SelectRef(CString refName, bool bExactMatch)
 308 {
 309         if(!bExactMatch)
 310         {
 311                 CString newRefName = GetFullRefName(refName);
 312                 if(!newRefName.IsEmpty())
 313                         refName = newRefName;
 314                 //else refName is not a valid ref. Try to select as good as possible.
 315         }
 316         if(_wcsnicmp(refName, L"refs/", 5) != 0)
 317                 return false; // Not a ref name
 318
 319         CShadowTree& treeLeafHead=GetTreeNode(refName,NULL,false);
 320         if(treeLeafHead.m_hTree != NULL)
 321         {
 322                 //Not a leaf. Select tree node and return
 323                 m_RefTreeCtrl.Select(treeLeafHead.m_hTree,TVGN_CARET);
 324                 return true;
 325         }
 326
 327         if(treeLeafHead.m_pParent==NULL)
 328                 return false; //Weird... should not occur.
 329
 330         //This is the current head.
 331         m_RefTreeCtrl.Select(treeLeafHead.m_pParent->m_hTree,TVGN_CARET);
 332
 333         for(int indexPos = 0; indexPos < m_ListRefLeafs.GetItemCount(); ++indexPos)
 334         {
 335                 CShadowTree* pCurrShadowTree = (CShadowTree*)m_ListRefLeafs.GetItemData(indexPos);
 336                 if(pCurrShadowTree == &treeLeafHead)
 337                 {
 338                         m_ListRefLeafs.SetItemState(indexPos,LVIS_SELECTED,LVIS_SELECTED);
 339                         m_ListRefLeafs.EnsureVisible(indexPos,FALSE);
 340                 }
 341         }
 342
 343         return true;
 344 }
 345
 346 CShadowTree& CBrowseRefsDlg::GetTreeNode(CString refName, CShadowTree* pTreePos, bool bCreateIfNotExist)
 347 {
 348         if(pTreePos==NULL)
 349         {
 350                 if(_wcsnicmp(refName, L"refs/", 5) == 0)
 351                         refName=refName.Mid(5);
 352                 pTreePos=&m_TreeRoot;
 353         }
 354         if(refName.IsEmpty())
 355                 return *pTreePos;//Found leaf
 356
 357         CShadowTree* pNextTree=pTreePos->GetNextSub(refName,bCreateIfNotExist);
 358         if(pNextTree==NULL)
 359         {
 360                 //Should not occur when all ref-names are valid and bCreateIfNotExist is true.
 361                 ASSERT(!bCreateIfNotExist);
 362                 return *pTreePos;
 363         }
 364
 365         if(!refName.IsEmpty())
 366         {
 367                 //When the refName is not empty, this node is not a leaf, so lets add it to the tree control.
 368                 //Leafs are for the list control.
 369                 if(pNextTree->m_hTree==NULL)
 370                 {
 371                         //New tree. Create node in control.
 372                         pNextTree->m_hTree=m_RefTreeCtrl.InsertItem(pNextTree->m_csRefName,pTreePos->m_hTree,NULL);
 373                         m_RefTreeCtrl.SetItemData(pNextTree->m_hTree,(DWORD_PTR)pNextTree);
 374                 }
 375         }
 376
 377         return GetTreeNode(refName, pNextTree, bCreateIfNotExist);
 378 }
 379
 380
 381 void CBrowseRefsDlg::OnTvnSelchangedTreeRef(NMHDR *pNMHDR, LRESULT *pResult)
 382 {
 383         LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
 384         *pResult = 0;
 385
 386         FillListCtrlForTreeNode(pNMTreeView->itemNew.hItem);
 387 }
 388
 389 void CBrowseRefsDlg::FillListCtrlForTreeNode(HTREEITEM treeNode)
 390 {
 391         m_ListRefLeafs.DeleteAllItems();
 392         m_currSortCol = -1;
 393         m_currSortDesc = false;
 394         SetSortArrow(&m_ListRefLeafs,-1,false);
 395
 396         CShadowTree* pTree=(CShadowTree*)(m_RefTreeCtrl.GetItemData(treeNode));
 397         if(pTree==NULL)
 398         {
 399                 ASSERT(FALSE);
 400                 return;
 401         }
 402         FillListCtrlForShadowTree(pTree,L"",true);
 403 }
 404
 405 void CBrowseRefsDlg::FillListCtrlForShadowTree(CShadowTree* pTree, CString refNamePrefix, bool isFirstLevel)
 406 {
 407         if(pTree->IsLeaf())
 408         {
 409                 if (!(pTree->m_csRefName.IsEmpty() || pTree->m_csRefName == "refs" && pTree->m_pParent == NULL))
 410                 {
 411                         int indexItem = m_ListRefLeafs.InsertItem(m_ListRefLeafs.GetItemCount(), L"");
 412
 413                         m_ListRefLeafs.SetItemData(indexItem,(DWORD_PTR)pTree);
 414                         m_ListRefLeafs.SetItemText(indexItem,eCol_Name, refNamePrefix+pTree->m_csRefName);
 415                         m_ListRefLeafs.SetItemText(indexItem,eCol_Date, pTree->m_csDate);
 416                         m_ListRefLeafs.SetItemText(indexItem,eCol_Msg, pTree->m_csSubject);
 417                         m_ListRefLeafs.SetItemText(indexItem,eCol_Hash, pTree->m_csRefHash);
 418                 }
 419         }
 420         else
 421         {
 422
 423                 CString csThisName;
 424                 if(!isFirstLevel)
 425                         csThisName=refNamePrefix+pTree->m_csRefName+L"/";
 426                 else
 427                         m_pListCtrlRoot = pTree;
 428                 for(CShadowTree::TShadowTreeMap::iterator itSubTree=pTree->m_ShadowTree.begin(); itSubTree!=pTree->m_ShadowTree.end(); ++itSubTree)
 429                 {
 430                         FillListCtrlForShadowTree(&itSubTree->second,csThisName,false);
 431                 }
 432         }
 433 }
 434
 435 bool CBrowseRefsDlg::ConfirmDeleteRef(VectorPShadowTree& leafs)
 436 {
 437         ASSERT(!leafs.empty());
 438
 439         CString csMessage;
 440         UINT mbIcon=MB_ICONQUESTION;
 441
 442         bool bIsRemoteBranch = false;
 443         bool bIsBranch = false;
 444         if              (leafs[0]->IsFrom(L"refs/remotes"))     {bIsBranch = true; bIsRemoteBranch = true;}
 445         else if (leafs[0]->IsFrom(L"refs/heads"))       {bIsBranch = true;}
 446
 447         if(bIsBranch)
 448         {
 449                 if(leafs.size() == 1)
 450                 {
 451                         CString branchToDelete = leafs[0]->GetRefName().Mid(bIsRemoteBranch ? 13 : 11);
 452                         csMessage.Format(IDS_PROC_DELETEBRANCHTAG, branchToDelete);
 453
 454                         //Check if branch is fully merged in HEAD
 455                         CGitHash branchHash = g_Git.GetHash(leafs[0]->GetRefName());
 456                         CGitHash commonAncestor;
 457                         CString commonAncestorstr;
 458                         CString cmd;
 459                         cmd.Format(L"git.exe merge-base HEAD %s", leafs[0]->GetRefName());
 460                         g_Git.Run(cmd, &commonAncestorstr, NULL, CP_UTF8);
 461
 462                         commonAncestor=commonAncestorstr;
 463
 464                         if(commonAncestor != branchHash)
 465                         {
 466                                 csMessage += L"\r\n\r\n";
 467                                 csMessage += CString(MAKEINTRESOURCE(IDS_PROC_BROWSEREFS_WARNINGUNMERGED));
 468                                 mbIcon = MB_ICONWARNING;
 469                         }
 470
 471                         if(bIsRemoteBranch)
 472                         {
 473                                 csMessage += L"\r\n\r\n";
 474                                 csMessage += CString(MAKEINTRESOURCE(IDS_PROC_BROWSEREFS_WARNINGDELETEREMOTEBRANCHES));
 475                                 mbIcon = MB_ICONWARNING;
 476                         }
 477                 }
 478                 else
 479                 {
 480                         csMessage.Format(IDS_PROC_DELETENREFS, leafs.size());
 481
 482                         csMessage += L"\r\n\r\n";
 483                         csMessage += CString(MAKEINTRESOURCE(IDS_PROC_BROWSEREFS_WARNINGNOMERGECHECK));
 484                         mbIcon = MB_ICONWARNING;
 485
 486                         if(bIsRemoteBranch)
 487                         {
 488                                 csMessage += L"\r\n\r\n";
 489                                 csMessage += CString(MAKEINTRESOURCE(IDS_PROC_BROWSEREFS_WARNINGDELETEREMOTEBRANCHES));
 490                                 mbIcon = MB_ICONWARNING;
 491                         }
 492                 }
 493
 494         }
 495         else if(leafs[0]->IsFrom(L"refs/tags"))
 496         {
 497                 if(leafs.size() == 1)
 498                 {
 499                         CString tagToDelete = leafs[0]->GetRefName().Mid(10);
 500                         csMessage.Format(IDS_PROC_DELETEBRANCHTAG, tagToDelete);
 501                 }
 502                 else
 503                 {
 504                         csMessage.Format(IDS_PROC_DELETENREFS, leafs.size());
 505                 }
 506         }
 507
 508         return CMessageBox::Show(m_hWnd, csMessage, _T("TortoiseGit"), MB_YESNO | mbIcon) == IDYES;
 509
 510 }
 511
 512 bool CBrowseRefsDlg::DoDeleteRefs(VectorPShadowTree& leafs, bool bForce)
 513 {
 514         for(VectorPShadowTree::iterator i = leafs.begin(); i != leafs.end(); ++i)
 515                 if(!DoDeleteRef((*i)->GetRefName(), bForce))
 516                         return false;
 517         return true;
 518 }
 519
 520 bool CBrowseRefsDlg::DoDeleteRef(CString completeRefName, bool bForce)
 521 {
 522         bool bIsRemoteBranch = false;
 523         bool bIsBranch = false;
 524         if              (wcsncmp(completeRefName, L"refs/remotes",12)==0)       {bIsBranch = true; bIsRemoteBranch = true;}
 525         else if (wcsncmp(completeRefName, L"refs/heads",10)==0)         {bIsBranch = true;}
 526
 527         if(bIsBranch)
 528         {
 529                 CString branchToDelete = completeRefName.Mid(bIsRemoteBranch ? 13 : 11);
 530                 CString cmd;
 531                 if(bIsRemoteBranch)
 532                 {
 533                         int slash = branchToDelete.Find(L'/');
 534                         if(slash < 0)
 535                                 return false;
 536                         CString remoteName = branchToDelete.Left(slash);
 537                         CString remoteBranchToDelete = branchToDelete.Mid(slash + 1);
 538
 539                         if(CAppUtils::IsSSHPutty())
 540                         {
 541                                 CAppUtils::LaunchPAgent(NULL, &remoteName);
 542                         }
 543
 544                         cmd.Format(L"git.exe push \"%s\" :%s", remoteName, remoteBranchToDelete);
 545                 }
 546                 else
 547                         cmd.Format(L"git.exe branch -%c -- %s",bForce?L'D':L'd',branchToDelete);
 548                 CString errorMsg;
 549                 if(g_Git.Run(cmd,&errorMsg,CP_UTF8)!=0)
 550                 {
 551                         CMessageBox::Show(m_hWnd, errorMsg, _T("TortoiseGit"), MB_OK | MB_ICONERROR);
 552                         return false;
 553                 }
 554         }
 555         else if(wcsncmp(completeRefName,L"refs/tags",9)==0)
 556         {
 557                 CString tagToDelete = completeRefName.Mid(10);
 558                 CString cmd;
 559                 cmd.Format(L"git.exe tag -d -- %s",tagToDelete);
 560                 CString errorMsg;
 561                 if(g_Git.Run(cmd,&errorMsg,CP_UTF8)!=0)
 562                 {
 563                         CMessageBox::Show(m_hWnd, errorMsg, _T("TortoiseGit"), MB_OK | MB_ICONERROR);
 564                         return false;
 565                 }
 566         }
 567         return true;
 568 }
 569
 570 CString CBrowseRefsDlg::GetFullRefName(CString partialRefName)
 571 {
 572         CShadowTree* pLeaf = m_TreeRoot.FindLeaf(partialRefName);
 573         if(pLeaf == NULL)
 574                 return CString();
 575         return pLeaf->GetRefName();
 576 }
 577
 578
 579 void CBrowseRefsDlg::OnContextMenu(CWnd* pWndFrom, CPoint point)
 580 {
 581         if(pWndFrom==&m_RefTreeCtrl)       OnContextMenu_RefTreeCtrl(point);
 582         else if(pWndFrom==&m_ListRefLeafs) OnContextMenu_ListRefLeafs(point);
 583 }
 584
 585 void CBrowseRefsDlg::OnContextMenu_RefTreeCtrl(CPoint point)
 586 {
 587         CPoint clientPoint=point;
 588         m_RefTreeCtrl.ScreenToClient(&clientPoint);
 589
 590         HTREEITEM hTreeItem=m_RefTreeCtrl.HitTest(clientPoint);
 591         if(hTreeItem!=NULL)
 592                 m_RefTreeCtrl.Select(hTreeItem,TVGN_CARET);
 593
 594         VectorPShadowTree tree;
 595         ShowContextMenu(point,hTreeItem,tree);
 596 }
 597
 598
 599 void CBrowseRefsDlg::OnContextMenu_ListRefLeafs(CPoint point)
 600 {
 601         std::vector<CShadowTree*> selectedLeafs;
 602         selectedLeafs.reserve(m_ListRefLeafs.GetSelectedCount());
 603         POSITION pos=m_ListRefLeafs.GetFirstSelectedItemPosition();
 604         while(pos)
 605         {
 606                 selectedLeafs.push_back(
 607                         (CShadowTree*)m_ListRefLeafs.GetItemData(
 608                                 m_ListRefLeafs.GetNextSelectedItem(pos)));
 609         }
 610
 611         ShowContextMenu(point,m_RefTreeCtrl.GetSelectedItem(),selectedLeafs);
 612 }
 613
 614 void CBrowseRefsDlg::ShowContextMenu(CPoint point, HTREEITEM hTreePos, VectorPShadowTree& selectedLeafs)
 615 {
 616         CIconMenu popupMenu;
 617         popupMenu.CreatePopupMenu();
 618
 619         bool bAddSeparator = false;
 620         CString remoteName;
 621
 622         if(selectedLeafs.size()==1)
 623         {
 624                 bAddSeparator = true;
 625
 626                 bool bShowReflogOption                          = false;
 627                 bool bShowFetchOption                           = false;
 628                 bool bShowSwitchOption                          = false;
 629                 bool bShowRenameOption                          = false;
 630                 bool bShowCreateBranchOption            = false;
 631
 632                 CString fetchFromCmd;
 633
 634                 if(selectedLeafs[0]->IsFrom(L"refs/heads"))
 635                 {
 636                         bShowReflogOption = true;
 637                         bShowSwitchOption = true;
 638                         bShowRenameOption = true;
 639                 }
 640                 else if(selectedLeafs[0]->IsFrom(L"refs/remotes"))
 641                 {
 642                         bShowReflogOption = true;
 643                         bShowFetchOption  = true;
 644                         bShowCreateBranchOption = true;
 645
 646                         int dummy = 0;//Needed for tokenize
 647                         remoteName = selectedLeafs[0]->GetRefName();
 648                         remoteName = remoteName.Mid(13);
 649                         remoteName = remoteName.Tokenize(L"/", dummy);
 650                         fetchFromCmd.Format(IDS_PROC_BROWSEREFS_FETCHFROM, remoteName);
 651                 }
 652                 else if(selectedLeafs[0]->IsFrom(L"refs/tags"))
 653                 {
 654                 }
 655
 656                 CString temp;
 657                 temp.LoadString(IDS_MENULOG);
 658                 popupMenu.AppendMenuIcon(eCmd_ViewLog, temp, IDI_LOG);
 659                 if(bShowReflogOption)
 660                 {
 661                         temp.LoadString(IDS_MENUREFLOG);
 662                         popupMenu.AppendMenuIcon(eCmd_ShowReflog, temp, IDI_LOG);
 663                 }
 664
 665                 popupMenu.AppendMenu(MF_SEPARATOR);
 666                 bAddSeparator = false;
 667
 668                 if(bShowFetchOption)
 669                 {
 670                         bAddSeparator = true;
 671                         popupMenu.AppendMenuIcon(eCmd_Fetch, fetchFromCmd, IDI_PULL);
 672                 }
 673
 674                 if(bAddSeparator)
 675                         popupMenu.AppendMenu(MF_SEPARATOR);
 676
 677                 bAddSeparator = false;
 678                 if (m_bHasWC)
 679                 {
 680                         popupMenu.AppendMenuIcon(eCmd_Switch, CString(MAKEINTRESOURCE(IDS_SWITCH_TO_THIS)), IDI_SWITCH);
 681                         popupMenu.AppendMenu(MF_SEPARATOR);
 682                 }
 683
 684                 if(bShowCreateBranchOption)
 685                 {
 686                         bAddSeparator = true;
 687                         temp.LoadString(IDS_MENUBRANCH);
 688                         popupMenu.AppendMenuIcon(eCmd_CreateBranch, temp, IDI_COPY);
 689                 }
 690
 691                 if(bShowRenameOption)
 692                 {
 693                         bAddSeparator = true;
 694                         popupMenu.AppendMenuIcon(eCmd_Rename, CString(MAKEINTRESOURCE(IDS_PROC_BROWSEREFS_RENAME)), IDI_RENAME);
 695                 }
 696         }
 697         else if(selectedLeafs.size() == 2)
 698         {
 699                 bAddSeparator = true;
 700                 popupMenu.AppendMenuIcon(eCmd_Diff, CString(MAKEINTRESOURCE(IDS_PROC_BROWSEREFS_COMPAREREFS)), IDI_DIFF);
 701         }
 702
 703         if(!selectedLeafs.empty())
 704         {
 705                 if(AreAllFrom(selectedLeafs, L"refs/remotes/"))
 706                 {
 707                         if(bAddSeparator)
 708                                 popupMenu.AppendMenu(MF_SEPARATOR);
 709                         CString menuItemName;
 710                         if(selectedLeafs.size() == 1)
 711                                 menuItemName.LoadString(IDS_PROC_BROWSEREFS_DELETEREMOTEBRANCH);
 712                         else
 713                                 menuItemName.Format(IDS_PROC_BROWSEREFS_DELETEREMOTEBRANCHES, selectedLeafs.size());
 714
 715                         popupMenu.AppendMenuIcon(eCmd_DeleteRemoteBranch, menuItemName, IDI_DELETE);
 716                         bAddSeparator = true;
 717                 }
 718                 else if(AreAllFrom(selectedLeafs, L"refs/heads/"))
 719                 {
 720                         if(bAddSeparator)
 721                                 popupMenu.AppendMenu(MF_SEPARATOR);
 722                         CString menuItemName;
 723                         if(selectedLeafs.size() == 1)
 724                                 menuItemName.LoadString(IDS_PROC_BROWSEREFS_DELETEBRANCH);
 725                         else
 726                                 menuItemName.Format(IDS_PROC_BROWSEREFS_DELETEBRANCHES, selectedLeafs.size());
 727
 728                         popupMenu.AppendMenuIcon(eCmd_DeleteBranch, menuItemName, IDI_DELETE);
 729                         bAddSeparator = true;
 730                 }
 731                 else if(AreAllFrom(selectedLeafs, L"refs/tags/"))
 732                 {
 733                         if(bAddSeparator)
 734                                 popupMenu.AppendMenu(MF_SEPARATOR);
 735                         CString menuItemName;
 736                         if(selectedLeafs.size() == 1)
 737                                 menuItemName.LoadString(IDS_PROC_BROWSEREFS_DELETETAG);
 738                         else
 739                                 menuItemName.Format(IDS_PROC_BROWSEREFS_DELETETAGS, selectedLeafs.size());
 740
 741                         popupMenu.AppendMenuIcon(eCmd_DeleteTag, menuItemName, IDI_DELETE);
 742                         bAddSeparator = true;
 743                 }
 744         }
 745
 746
 747         if(hTreePos!=NULL && selectedLeafs.empty())
 748         {
 749                 CShadowTree* pTree=(CShadowTree*)m_RefTreeCtrl.GetItemData(hTreePos);
 750                 if(pTree->IsFrom(L"refs/remotes"))
 751                 {
 752                         if(bAddSeparator)
 753                                 popupMenu.AppendMenu(MF_SEPARATOR);
 754                         popupMenu.AppendMenuIcon(eCmd_ManageRemotes, CString(MAKEINTRESOURCE(IDS_PROC_BROWSEREFS_MANAGEREMOTES)), IDI_SETTINGS);
 755                         bAddSeparator = true;
 756                         if(selectedLeafs.empty())
 757                         {
 758                                 int dummy = 0;//Needed for tokenize
 759                                 remoteName = pTree->GetRefName();
 760                                 remoteName = remoteName.Mid(13);
 761                                 remoteName = remoteName.Tokenize(L"/", dummy);
 762                                 if(!remoteName.IsEmpty())
 763                                 {
 764                                         CString fetchFromCmd;
 765                                         fetchFromCmd.Format(IDS_PROC_BROWSEREFS_FETCHFROM, remoteName);
 766                                         popupMenu.AppendMenuIcon(eCmd_Fetch, fetchFromCmd, IDI_PULL);
 767                                 }
 768                         }
 769                 }
 770                 if(pTree->IsFrom(L"refs/heads"))
 771                 {
 772                         if(bAddSeparator)
 773                                 popupMenu.AppendMenu(MF_SEPARATOR);
 774                         CString temp;
 775                         temp.LoadString(IDS_MENUBRANCH);
 776                         popupMenu.AppendMenuIcon(eCmd_CreateBranch, temp, IDI_COPY);
 777                 }
 778                 if(pTree->IsFrom(L"refs/tags"))
 779                 {
 780                         if(bAddSeparator)
 781                                 popupMenu.AppendMenu(MF_SEPARATOR);
 782                         CString temp;
 783                         temp.LoadString(IDS_MENUTAG);
 784                         popupMenu.AppendMenuIcon(eCmd_CreateTag, temp, IDI_TAG);
 785                 }
 786         }
 787
 788
 789         eCmd cmd=(eCmd)popupMenu.TrackPopupMenuEx(TPM_LEFTALIGN|TPM_RETURNCMD, point.x, point.y, this, 0);
 790         switch(cmd)
 791         {
 792         case eCmd_ViewLog:
 793                 {
 794                         CLogDlg dlg;
 795                         dlg.SetStartRef(selectedLeafs[0]->GetRefName());
 796                         dlg.DoModal();
 797                 }
 798                 break;
 799         case eCmd_DeleteBranch:
 800         case eCmd_DeleteRemoteBranch:
 801                 {
 802                         if(ConfirmDeleteRef(selectedLeafs))
 803                                 DoDeleteRefs(selectedLeafs, true);
 804                         Refresh();
 805                 }
 806                 break;
 807         case eCmd_DeleteTag:
 808                 {
 809                         if(ConfirmDeleteRef(selectedLeafs))
 810                                 DoDeleteRefs(selectedLeafs, true);
 811                         Refresh();
 812                 }
 813                 break;
 814         case eCmd_ShowReflog:
 815                 {
 816                         CRefLogDlg refLogDlg(this);
 817                         refLogDlg.m_CurrentBranch = selectedLeafs[0]->GetRefName();
 818                         refLogDlg.DoModal();
 819                 }
 820                 break;
 821         case eCmd_Fetch:
 822                 {
 823                         CAppUtils::Fetch(remoteName);
 824                         Refresh();
 825                 }
 826                 break;
 827         case eCmd_Switch:
 828                 {
 829                         CAppUtils::Switch(NULL, selectedLeafs[0]->GetRefName());
 830                 }
 831                 break;
 832         case eCmd_Rename:
 833                 {
 834                         POSITION pos = m_ListRefLeafs.GetFirstSelectedItemPosition();
 835                         if(pos != NULL)
 836                                 m_ListRefLeafs.EditLabel(m_ListRefLeafs.GetNextSelectedItem(pos));
 837                 }
 838                 break;
 839         case eCmd_AddRemote:
 840                 {
 841                         CAddRemoteDlg(this).DoModal();
 842                         Refresh();
 843                 }
 844                 break;
 845         case eCmd_ManageRemotes:
 846                 {
 847                         CSinglePropSheetDlg(CString(MAKEINTRESOURCE(IDS_PROCS_TITLE_GITREMOTESETTINGS)), new CSettingGitRemote(g_Git.m_CurrentDir), this).DoModal();
 848 //                      CSettingGitRemote W_Remotes(m_cmdPath);
 849 //                      W_Remotes.DoModal();
 850                         Refresh();
 851                 }
 852                 break;
 853         case eCmd_CreateBranch:
 854                 {
 855                         CString *commitHash = NULL;
 856                         if (selectedLeafs.size() == 1)
 857                                 commitHash = &(selectedLeafs[0]->m_csRefHash);
 858                         CAppUtils::CreateBranchTag(false, commitHash);
 859                         Refresh();
 860                 }
 861                 break;
 862         case eCmd_CreateTag:
 863                 {
 864                         CAppUtils::CreateBranchTag(true);
 865                         Refresh();
 866                 }
 867                 break;
 868         case eCmd_Diff:
 869                 {
 870                         CFileDiffDlg dlg;
 871                         dlg.SetDiff(
 872                                 NULL,
 873                                 selectedLeafs[0]->m_csRefHash,
 874                                 selectedLeafs[1]->m_csRefHash);
 875                         dlg.DoModal();
 876                 }
 877                 break;
 878         }
 879 }
 880
 881 bool CBrowseRefsDlg::AreAllFrom(VectorPShadowTree& leafs, const wchar_t* from)
 882 {
 883         for(VectorPShadowTree::iterator i = leafs.begin(); i != leafs.end(); ++i)
 884                 if(!(*i)->IsFrom(from))
 885                         return false;
 886         return true;
 887 }
 888
 889 BOOL CBrowseRefsDlg::PreTranslateMessage(MSG* pMsg)
 890 {
 891         if (pMsg->message == WM_KEYDOWN)
 892         {
 893                 switch (pMsg->wParam)
 894                 {
 895 /*              case VK_RETURN:
 896                         {
 897                                 if (GetAsyncKeyState(VK_CONTROL)&0x8000)
 898                                 {
 899                                         if ( GetDlgItem(IDOK)->IsWindowEnabled() )
 900                                         {
 901                                                 PostMessage(WM_COMMAND, IDOK);
 902                                         }
 903                                         return TRUE;
 904                                 }
 905                         }
 906                         break;
 907 */              case VK_F2:
 908                         {
 909                                 if(pMsg->hwnd == m_ListRefLeafs.m_hWnd)
 910                                 {
 911                                         POSITION pos = m_ListRefLeafs.GetFirstSelectedItemPosition();
 912                                         if(pos != NULL)
 913                                                 m_ListRefLeafs.EditLabel(m_ListRefLeafs.GetNextSelectedItem(pos));
 914                                 }
 915                         }
 916                         break;
 917
 918                 case VK_F5:
 919                         {
 920                                 Refresh();
 921                         }
 922                         break;
 923                 }
 924         }
 925
 926
 927         return CResizableStandAloneDialog::PreTranslateMessage(pMsg);
 928 }
 929
 930 class CRefLeafListCompareFunc
 931 {
 932 public:
 933         CRefLeafListCompareFunc(CListCtrl* pList, int col, bool desc):m_col(col),m_desc(desc),m_pList(pList){}
 934
 935         static int CALLBACK StaticCompare(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
 936         {
 937                 return ((CRefLeafListCompareFunc*)lParamSort)->Compare(lParam1,lParam2);
 938         }
 939
 940         int Compare(LPARAM lParam1, LPARAM lParam2)
 941         {
 942                 return Compare(
 943                         (CShadowTree*)m_pList->GetItemData(lParam1),
 944                         (CShadowTree*)m_pList->GetItemData(lParam2));
 945         }
 946
 947         int Compare(CShadowTree* pLeft, CShadowTree* pRight)
 948         {
 949                 int result=CompareNoDesc(pLeft,pRight);
 950                 if(m_desc)
 951                         return -result;
 952                 return result;
 953         }
 954
 955         int CompareNoDesc(CShadowTree* pLeft, CShadowTree* pRight)
 956         {
 957                 switch(m_col)
 958                 {
 959                 case CBrowseRefsDlg::eCol_Name: return pLeft->GetRefName().CompareNoCase(pRight->GetRefName());
 960                 case CBrowseRefsDlg::eCol_Date: return pLeft->m_csDate_Iso8601.CompareNoCase(pRight->m_csDate_Iso8601);
 961                 case CBrowseRefsDlg::eCol_Msg:  return pLeft->m_csSubject.CompareNoCase(pRight->m_csSubject);
 962                 case CBrowseRefsDlg::eCol_Hash: return pLeft->m_csRefHash.CompareNoCase(pRight->m_csRefHash);
 963                 }
 964                 return 0;
 965         }
 966
 967         int m_col;
 968         bool m_desc;
 969         CListCtrl* m_pList;
 970
 971
 972 };
 973
 974
 975 void CBrowseRefsDlg::OnLvnColumnclickListRefLeafs(NMHDR *pNMHDR, LRESULT *pResult)
 976 {
 977         LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
 978         *pResult = 0;
 979
 980         if(m_currSortCol == pNMLV->iSubItem)
 981                 m_currSortDesc = !m_currSortDesc;
 982         else
 983         {
 984                 m_currSortCol  = pNMLV->iSubItem;
 985                 m_currSortDesc = false;
 986         }
 987
 988         CRefLeafListCompareFunc compareFunc(&m_ListRefLeafs, m_currSortCol, m_currSortDesc);
 989         m_ListRefLeafs.SortItemsEx(&CRefLeafListCompareFunc::StaticCompare, (DWORD_PTR)&compareFunc);
 990
 991         SetSortArrow(&m_ListRefLeafs,m_currSortCol,!m_currSortDesc);
 992 }
 993
 994 void CBrowseRefsDlg::OnDestroy()
 995 {
 996         m_pickedRef = GetSelectedRef(true, false);
 997
 998         CResizableStandAloneDialog::OnDestroy();
 999 }
1000
1001 void CBrowseRefsDlg::OnNMDblclkListRefLeafs(NMHDR *pNMHDR, LRESULT *pResult)
1002 {
1003         UNREFERENCED_PARAMETER(pNMHDR);
1004         *pResult = 0;
1005
1006         EndDialog(IDOK);
1007 }
1008
1009 CString CBrowseRefsDlg::PickRef(bool /*returnAsHash*/, CString initialRef, int pickRef_Kind)
1010 {
1011         CBrowseRefsDlg dlg(CString(),NULL);
1012
1013         if(initialRef.IsEmpty())
1014                 initialRef = L"HEAD";
1015         dlg.m_initialRef = initialRef;
1016         dlg.m_pickRef_Kind = pickRef_Kind;
1017
1018         if(dlg.DoModal() != IDOK)
1019                 return CString();
1020
1021         return dlg.m_pickedRef;
1022 }
1023
1024 bool CBrowseRefsDlg::PickRefForCombo(CComboBoxEx* pComboBox, int pickRef_Kind)
1025 {
1026         CString origRef;
1027         pComboBox->GetLBText(pComboBox->GetCurSel(), origRef);
1028         CString resultRef = PickRef(false,origRef,pickRef_Kind);
1029         if(resultRef.IsEmpty())
1030                 return false;
1031         if(wcsncmp(resultRef,L"refs/",5)==0)
1032                 resultRef = resultRef.Mid(5);
1033 //      if(wcsncmp(resultRef,L"heads/",6)==0)
1034 //              resultRef = resultRef.Mid(6);
1035
1036         //Find closest match of choice in combobox
1037         int ixFound = -1;
1038         int matchLength = 0;
1039         CString comboRefName;
1040         for(int i = 0; i < pComboBox->GetCount(); ++i)
1041         {
1042                 pComboBox->GetLBText(i, comboRefName);
1043                 if(comboRefName.Find(L'/') < 0 && !comboRefName.IsEmpty())
1044                         comboRefName.Insert(0,L"heads/"); // If combo contains single level ref name, it is usualy from 'heads/'
1045                 if(matchLength < comboRefName.GetLength() && resultRef.Right(comboRefName.GetLength()) == comboRefName)
1046                 {
1047                         matchLength = comboRefName.GetLength();
1048                         ixFound = i;
1049                 }
1050         }
1051         if(ixFound >= 0)
1052                 pComboBox->SetCurSel(ixFound);
1053         else
1054                 ASSERT(FALSE);//No match found. So either pickRef_Kind is wrong or the combobox does not contain the ref specified in the picker (which it should unless the repo has changed before creating the CBrowseRef dialog)
1055
1056         return true;
1057 }
1058
1059 void CBrowseRefsDlg::OnLvnEndlabeleditListRefLeafs(NMHDR *pNMHDR, LRESULT *pResult)
1060 {
1061         NMLVDISPINFO *pDispInfo = reinterpret_cast<NMLVDISPINFO*>(pNMHDR);
1062         *pResult = FALSE;
1063
1064         if(pDispInfo->item.pszText == NULL)
1065                 return; //User canceled changing
1066
1067         CShadowTree* pTree=(CShadowTree*)m_ListRefLeafs.GetItemData(pDispInfo->item.iItem);
1068
1069         if(!pTree->IsFrom(L"refs/heads"))
1070         {
1071                 CMessageBox::Show(m_hWnd, IDS_PROC_BROWSEREFS_RENAMEONLYBRANCHES, IDS_APPNAME, MB_OK | MB_ICONERROR);
1072                 return;
1073         }
1074
1075         CString origName = pTree->GetRefName().Mid(11);
1076
1077         CString newName;
1078         if(m_pListCtrlRoot != NULL)
1079                 newName = m_pListCtrlRoot->GetRefName() + L'/';
1080         newName += pDispInfo->item.pszText;
1081
1082         if(wcsncmp(newName,L"refs/heads/",11)!=0)
1083         {
1084                 CMessageBox::Show(m_hWnd, IDS_PROC_BROWSEREFS_NOCHANGEOFTYPE, IDS_APPNAME, MB_OK | MB_ICONERROR);
1085                 return;
1086         }
1087
1088         CString newNameTrunced = newName.Mid(11);
1089
1090         CString errorMsg;
1091         if(g_Git.Run(L"git branch -m \"" + origName + L"\" \"" + newNameTrunced + L"\"", &errorMsg, CP_UTF8) != 0)
1092         {
1093                 CMessageBox::Show(m_hWnd, errorMsg, _T("TortoiseGit"), MB_OK | MB_ICONERROR);
1094                 return;
1095         }
1096         //Do as if it failed to rename. Let Refresh() do the job.
1097         //*pResult = TRUE;
1098
1099         Refresh(newName);
1100
1101 //      CString W_csPopup;W_csPopup.Format8(L"Ref: %s. New name: %s. With path: %s", pTree->GetRefName(), pDispInfo->item.pszText, newName);
1102
1103 //      AfxMessageBox(W_csPopup);
1104
1105 }
1106
1107 void CBrowseRefsDlg::OnLvnBeginlabeleditListRefLeafs(NMHDR *pNMHDR, LRESULT *pResult)
1108 {
1109         NMLVDISPINFO *pDispInfo = reinterpret_cast<NMLVDISPINFO*>(pNMHDR);
1110         *pResult = FALSE;
1111
1112         CShadowTree* pTree=(CShadowTree*)m_ListRefLeafs.GetItemData(pDispInfo->item.iItem);
1113
1114         if(!pTree->IsFrom(L"refs/heads"))
1115         {
1116                 *pResult = TRUE; //Dont allow renaming any other things then branches at the moment.
1117                 return;
1118         }
1119 }