src/TortoiseProc/BrowseRefsDlg.cpp

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