src/Git/GitStatusListCtrl.cpp

   1 \r
   2 \r
   3 // TortoiseSVN - a Windows shell extension for easy version control\r
   4 \r
   5 // Copyright (C) 2003-2008 - TortoiseSVN\r
   6 \r
   7 // This program is free software; you can redistribute it and/or\r
   8 // modify it under the terms of the GNU General Public License\r
   9 // as published by the Free Software Foundation; either version 2\r
  10 // of the License, or (at your option) any later version.\r
  11 \r
  12 // This program is distributed in the hope that it will be useful,\r
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  15 // GNU General Public License for more details.\r
  16 \r
  17 // You should have received a copy of the GNU General Public License\r
  18 // along with this program; if not, write to the Free Software Foundation,\r
  19 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.\r
  20 //\r
  21 \r
  22 #include "StdAfx.h"\r
  23 #include "GitStatusListCtrl.h"\r
  24 #include "resource.h"\r
  25 #include "..\\TortoiseShell\resource.h"\r
  26 #include "MessageBox.h"\r
  27 #include "MyMemDC.h"\r
  28 #include "UnicodeUtils.h"\r
  29 #include "AppUtils.h"\r
  30 #include "PathUtils.h"\r
  31 #include "TempFile.h"\r
  32 #include "StringUtils.h"\r
  33 #include "DirFileEnum.h"\r
  34 #include "GitConfig.h"\r
  35 //#include "SVNProperties.h"\r
  36 #include "Git.h"\r
  37 #include "GitDiff.h"\r
  38 //#include "LogDlg.h"\r
  39 //#include "SVNProgressDlg.h"\r
  40 #include "SysImageList.h"\r
  41 //#include "Svnstatuslistctrl.h"\r
  42 #include "TGitPath.h"\r
  43 #include "Registry.h"\r
  44 #include "GitStatus.h"\r
  45 //#include "SVNHelpers.h"\r
  46 #include "InputDlg.h"\r
  47 #include "ShellUpdater.h"\r
  48 #include "GitAdminDir.h"\r
  49 //#include "DropFiles.h"\r
  50 #include "IconMenu.h"\r
  51 //#include "AddDlg.h"\r
  52 //#include "EditPropertiesDlg.h"\r
  53 //#include "CreateChangelistDlg.h"\r
  54 #include "XPTheme.h"\r
  55 \r
  56 const UINT CGitStatusListCtrl::SVNSLNM_ITEMCOUNTCHANGED\r
  57                                         = ::RegisterWindowMessage(_T("GITSLNM_ITEMCOUNTCHANGED"));\r
  58 const UINT CGitStatusListCtrl::SVNSLNM_NEEDSREFRESH\r
  59                                         = ::RegisterWindowMessage(_T("GITSLNM_NEEDSREFRESH"));\r
  60 const UINT CGitStatusListCtrl::SVNSLNM_ADDFILE\r
  61                                         = ::RegisterWindowMessage(_T("GITSLNM_ADDFILE"));\r
  62 const UINT CGitStatusListCtrl::SVNSLNM_CHECKCHANGED\r
  63                                         = ::RegisterWindowMessage(_T("GITSLNM_CHECKCHANGED"));\r
  64 \r
  65 #define IDSVNLC_REVERT                   1\r
  66 #define IDSVNLC_COMPARE                  2\r
  67 #define IDSVNLC_OPEN                     3\r
  68 #define IDSVNLC_DELETE                   4\r
  69 #define IDSVNLC_IGNORE                   5\r
  70 #define IDSVNLC_GNUDIFF1                 6\r
  71 #define IDSVNLC_UPDATE           7\r
  72 #define IDSVNLC_LOG              8\r
  73 #define IDSVNLC_EDITCONFLICT     9\r
  74 #define IDSVNLC_IGNOREMASK          10\r
  75 #define IDSVNLC_ADD                         11\r
  76 #define IDSVNLC_RESOLVECONFLICT 12\r
  77 #define IDSVNLC_LOCK                    13\r
  78 #define IDSVNLC_LOCKFORCE               14\r
  79 #define IDSVNLC_UNLOCK                  15\r
  80 #define IDSVNLC_UNLOCKFORCE             16\r
  81 #define IDSVNLC_OPENWITH                17\r
  82 #define IDSVNLC_EXPLORE                 18\r
  83 #define IDSVNLC_RESOLVETHEIRS   19\r
  84 #define IDSVNLC_RESOLVEMINE             20\r
  85 #define IDSVNLC_REMOVE                  21\r
  86 #define IDSVNLC_COMMIT                  22\r
  87 #define IDSVNLC_PROPERTIES              23\r
  88 #define IDSVNLC_COPY                    24\r
  89 #define IDSVNLC_COPYEXT                 25\r
  90 #define IDSVNLC_REPAIRMOVE              26\r
  91 #define IDSVNLC_REMOVEFROMCS    27\r
  92 #define IDSVNLC_CREATECS                28\r
  93 #define IDSVNLC_CREATEIGNORECS  29\r
  94 #define IDSVNLC_CHECKGROUP              30\r
  95 #define IDSVNLC_UNCHECKGROUP    31\r
  96 #define IDSVNLC_ADD_RECURSIVE   32\r
  97 #define IDSVNLC_COMPAREWC               33\r
  98 #define IDSVNLC_BLAME                   34\r
  99 // the IDSVNLC_MOVETOCS *must* be the last index, because it contains a dynamic submenu where \r
 100 // the submenu items get command ID's sequent to this number\r
 101 #define IDSVNLC_MOVETOCS                35\r
 102 \r
 103 \r
 104 BEGIN_MESSAGE_MAP(CGitStatusListCtrl, CListCtrl)\r
 105         ON_NOTIFY(HDN_ITEMCLICKA, 0, OnHdnItemclick)\r
 106         ON_NOTIFY(HDN_ITEMCLICKW, 0, OnHdnItemclick)\r
 107         ON_NOTIFY(HDN_ENDTRACK, 0, OnColumnResized)\r
 108         ON_NOTIFY(HDN_ENDDRAG, 0, OnColumnMoved)\r
 109         ON_NOTIFY_REFLECT_EX(LVN_ITEMCHANGED, OnLvnItemchanged)\r
 110         ON_WM_CONTEXTMENU()\r
 111         ON_NOTIFY_REFLECT(NM_DBLCLK, OnNMDblclk)\r
 112         ON_NOTIFY_REFLECT(LVN_GETINFOTIP, OnLvnGetInfoTip)\r
 113         ON_NOTIFY_REFLECT(NM_CUSTOMDRAW, OnNMCustomdraw)\r
 114         ON_WM_SETCURSOR()\r
 115         ON_WM_GETDLGCODE()\r
 116         ON_NOTIFY_REFLECT(NM_RETURN, OnNMReturn)\r
 117         ON_WM_KEYDOWN()\r
 118         ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTW, 0, 0xFFFF, OnToolTipText)\r
 119         ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTA, 0, 0xFFFF, OnToolTipText)\r
 120         ON_WM_PAINT()\r
 121         ON_NOTIFY(HDN_BEGINTRACKA, 0, &CGitStatusListCtrl::OnHdnBegintrack)\r
 122         ON_NOTIFY(HDN_BEGINTRACKW, 0, &CGitStatusListCtrl::OnHdnBegintrack)\r
 123         ON_NOTIFY(HDN_ITEMCHANGINGA, 0, &CGitStatusListCtrl::OnHdnItemchanging)\r
 124         ON_NOTIFY(HDN_ITEMCHANGINGW, 0, &CGitStatusListCtrl::OnHdnItemchanging)\r
 125         ON_WM_DESTROY()\r
 126         ON_NOTIFY_REFLECT(LVN_BEGINDRAG, OnBeginDrag)\r
 127         ON_NOTIFY_REFLECT(LVN_ITEMCHANGING, &CGitStatusListCtrl::OnLvnItemchanging)\r
 128 END_MESSAGE_MAP()\r
 129 \r
 130 \r
 131 \r
 132 CGitStatusListCtrl::CGitStatusListCtrl() : CListCtrl()\r
 133         //, m_HeadRev(GitRev::REV_HEAD)\r
 134         , m_pbCanceled(NULL)\r
 135         , m_pStatLabel(NULL)\r
 136         , m_pSelectButton(NULL)\r
 137         , m_pConfirmButton(NULL)\r
 138         , m_bBusy(false)\r
 139         , m_bEmpty(false)\r
 140         , m_bUnversionedRecurse(true)\r
 141         , m_bShowIgnores(false)\r
 142         , m_pDropTarget(NULL)\r
 143         , m_bIgnoreRemoveOnly(false)\r
 144         , m_bCheckChildrenWithParent(false)\r
 145         , m_bUnversionedLast(true)\r
 146         , m_bHasChangeLists(false)\r
 147         , m_bHasLocks(false)\r
 148         , m_bBlock(false)\r
 149         , m_bBlockUI(false)\r
 150         , m_bHasCheckboxes(false)\r
 151         , m_bCheckIfGroupsExist(true)\r
 152         , m_bFileDropsEnabled(false)\r
 153         , m_bOwnDrag(false)\r
 154     , m_dwDefaultColumns(0)\r
 155     , m_ColumnManager(this)\r
 156     , m_bAscending(false)\r
 157     , m_nSortedColumn(-1)\r
 158         , m_sNoPropValueText(MAKEINTRESOURCE(IDS_STATUSLIST_NOPROPVALUE))\r
 159 {\r
 160         m_FileLoaded=0;\r
 161         m_critSec.Init();\r
 162 }\r
 163 \r
 164 CGitStatusListCtrl::~CGitStatusListCtrl()\r
 165 {\r
 166 //      if (m_pDropTarget)\r
 167 //              delete m_pDropTarget;\r
 168         ClearStatusArray();\r
 169 }\r
 170 \r
 171 void CGitStatusListCtrl::ClearStatusArray()\r
 172 {\r
 173 #if 0\r
 174         Locker lock(m_critSec);\r
 175         for (size_t i=0; i < m_arStatusArray.size(); i++)\r
 176         {\r
 177                 delete m_arStatusArray[i];\r
 178         }\r
 179         m_arStatusArray.clear();\r
 180 #endif\r
 181 }\r
 182 #if 0\r
 183 CGitStatusListCtrl::FileEntry * CGitStatusListCtrl::GetListEntry(UINT_PTR index)\r
 184 {\r
 185 \r
 186         if (index >= (UINT_PTR)m_arListArray.size())\r
 187                 return NULL;\r
 188         if (m_arListArray[index] >= m_arStatusArray.size())\r
 189                 return NULL;\r
 190         return m_arStatusArray[m_arListArray[index]];\r
 191 \r
 192         return NULL;\r
 193 }\r
 194 #endif\r
 195 #if 0\r
 196 CGitStatusListCtrl::FileEntry * CGitStatusListCtrl::GetVisibleListEntry(const CTGitPath& path)\r
 197 {\r
 198         int itemCount = GetItemCount();\r
 199         for (int i=0; i < itemCount; i++)\r
 200         {\r
 201                 FileEntry * entry = GetListEntry(i);\r
 202                 if (entry->GetPath().IsEquivalentTo(path))\r
 203                         return entry;\r
 204         }\r
 205         return NULL;\r
 206 }\r
 207 #endif\r
 208 #if 0\r
 209 CGitStatusListCtrl::FileEntry * CGitStatusListCtrl::GetListEntry(const CTGitPath& path)\r
 210 {\r
 211 \r
 212         for (size_t i=0; i < m_arStatusArray.size(); i++)\r
 213         {\r
 214                 FileEntry * entry = m_arStatusArray[i];\r
 215                 if (entry->GetPath().IsEquivalentTo(path))\r
 216                         return entry;\r
 217         }\r
 218 \r
 219         return NULL;\r
 220 }\r
 221 #endif\r
 222 \r
 223 #if 0\r
 224 int CGitStatusListCtrl::GetIndex(const CTGitPath& path)\r
 225 {\r
 226         int itemCount = GetItemCount();\r
 227         for (int i=0; i < itemCount; i++)\r
 228         {\r
 229                 FileEntry * entry = GetListEntry(i);\r
 230                 if (entry->GetPath().IsEquivalentTo(path))\r
 231                         return i;\r
 232         }\r
 233         return -1;\r
 234 }\r
 235 #endif \r
 236 \r
 237 void CGitStatusListCtrl::Init(DWORD dwColumns, const CString& sColumnInfoContainer, DWORD dwContextMenus /* = GitSLC_POPALL */, bool bHasCheckboxes /* = true */)\r
 238 {\r
 239         Locker lock(m_critSec);\r
 240 \r
 241     m_dwDefaultColumns = dwColumns | 1;\r
 242     m_dwContextMenus = dwContextMenus;\r
 243         m_bHasCheckboxes = bHasCheckboxes;\r
 244 \r
 245     // set the extended style of the listcontrol\r
 246         // the style LVS_EX_FULLROWSELECT interferes with the background watermark image but it's more important to be able to select in the whole row.\r
 247         CRegDWORD regFullRowSelect(_T("Software\\TortoiseGit\\FullRowSelect"), TRUE);\r
 248         DWORD exStyle = LVS_EX_HEADERDRAGDROP | LVS_EX_DOUBLEBUFFER | LVS_EX_INFOTIP | LVS_EX_SUBITEMIMAGES;\r
 249         if (DWORD(regFullRowSelect))\r
 250                 exStyle |= LVS_EX_FULLROWSELECT;\r
 251         exStyle |= (bHasCheckboxes ? LVS_EX_CHECKBOXES : 0);\r
 252         SetRedraw(false);\r
 253         SetExtendedStyle(exStyle);\r
 254 \r
 255         CXPTheme theme;\r
 256         theme.SetWindowTheme(m_hWnd, L"Explorer", NULL);\r
 257 \r
 258         m_nIconFolder = SYS_IMAGE_LIST().GetDirIconIndex();\r
 259         SetImageList(&SYS_IMAGE_LIST(), LVSIL_SMALL);\r
 260 \r
 261     m_ColumnManager.ReadSettings (m_dwDefaultColumns, sColumnInfoContainer);\r
 262 \r
 263         // enable file drops\r
 264 #if 0\r
 265         if (m_pDropTarget == NULL)\r
 266         {\r
 267                 m_pDropTarget = new CGitStatusListCtrlDropTarget(this);\r
 268                 RegisterDragDrop(m_hWnd,m_pDropTarget);\r
 269                 // create the supported formats:\r
 270                 FORMATETC ftetc={0};\r
 271                 ftetc.dwAspect = DVASPECT_CONTENT;\r
 272                 ftetc.lindex = -1;\r
 273                 ftetc.tymed = TYMED_HGLOBAL;\r
 274                 ftetc.cfFormat=CF_HDROP;\r
 275                 m_pDropTarget->AddSuportedFormat(ftetc);\r
 276         }\r
 277 #endif\r
 278 \r
 279         SetRedraw(true);\r
 280 \r
 281         m_bUnversionedRecurse = !!((DWORD)CRegDWORD(_T("Software\\TortoiseGit\\UnversionedRecurse"), TRUE));\r
 282 }\r
 283 \r
 284 bool CGitStatusListCtrl::SetBackgroundImage(UINT nID)\r
 285 {\r
 286         return CAppUtils::SetListCtrlBackgroundImage(GetSafeHwnd(), nID);\r
 287 }\r
 288 \r
 289 BOOL CGitStatusListCtrl::GetStatus ( const CTGitPathList& pathList\r
 290                                    , bool bUpdate /* = FALSE */\r
 291                                    , bool bShowIgnores /* = false */\r
 292                                                                    , bool bShowUnRev\r
 293                                    , bool bShowUserProps /* = false */)\r
 294 {\r
 295         Locker lock(m_critSec);\r
 296         int mask= CGitStatusListCtrl::FILELIST_MODIFY;\r
 297         if(bShowIgnores)\r
 298                 mask|= CGitStatusListCtrl::FILELIST_IGNORE;\r
 299         if(bShowUnRev)\r
 300                 mask|= CGitStatusListCtrl::FILELIST_UNVER;\r
 301         this->UpdateFileList(mask,bUpdate,(CTGitPathList*)&pathList);\r
 302 \r
 303 #if 0\r
 304         \r
 305         int refetchcounter = 0;\r
 306         BOOL bRet = TRUE;\r
 307         Invalidate();\r
 308         // force the cursor to change\r
 309         POINT pt;\r
 310         GetCursorPos(&pt);\r
 311         SetCursorPos(pt.x, pt.y);\r
 312 \r
 313         m_mapFilenameToChecked.clear();\r
 314         //m_StatusUrlList.Clear();\r
 315         bool bHasChangelists = (m_changelists.size()>1 || (m_changelists.size()>0 && !m_bHasIgnoreGroup));\r
 316         m_changelists.clear();\r
 317         for (size_t i=0; i < m_arStatusArray.size(); i++)\r
 318         {\r
 319                 FileEntry * entry = m_arStatusArray[i];\r
 320                 if ( bHasChangelists && entry->checked)\r
 321                 {\r
 322                         // If change lists are present, remember all checked entries\r
 323                         CString path = entry->GetPath().GetGitPathString();\r
 324                         m_mapFilenameToChecked[path] = true;\r
 325                 }\r
 326                 if ( (entry->status==git_wc_status_unversioned || entry->status==git_wc_status_missing ) && entry->checked )\r
 327                 {\r
 328                         // The user manually selected an unversioned or missing file. We remember\r
 329                         // this so that the selection can be restored when refreshing.\r
 330                         CString path = entry->GetPath().GetGitPathString();\r
 331                         m_mapFilenameToChecked[path] = true;\r
 332                 }\r
 333                 else if ( entry->status > git_wc_status_normal && !entry->checked )\r
 334                 {\r
 335                         // The user manually deselected a versioned file. We remember\r
 336                         // this so that the deselection can be restored when refreshing.\r
 337                         CString path = entry->GetPath().GetGitPathString();\r
 338                         m_mapFilenameToChecked[path] = false;\r
 339                 }\r
 340         }\r
 341 \r
 342         // use a sorted path list to make sure we fetch the status of\r
 343         // parent items first, *then* the child items (if any)\r
 344         CTGitPathList sortedPathList = pathList;\r
 345         sortedPathList.SortByPathname();\r
 346         do\r
 347         {\r
 348                 bRet = TRUE;\r
 349                 m_nTargetCount = 0;\r
 350                 m_bHasExternalsFromDifferentRepos = FALSE;\r
 351                 m_bHasExternals = FALSE;\r
 352                 m_bHasUnversionedItems = FALSE;\r
 353                 m_bHasLocks = false;\r
 354                 m_bHasChangeLists = false;\r
 355                 m_bShowIgnores = bShowIgnores;\r
 356                 m_nSortedColumn = 0;\r
 357                 m_bBlock = TRUE;\r
 358                 m_bBusy = true;\r
 359                 m_bEmpty = false;\r
 360                 Invalidate();\r
 361 \r
 362                 // first clear possible status data left from\r
 363                 // previous GetStatus() calls\r
 364                 ClearStatusArray();\r
 365 \r
 366                 m_StatusFileList = sortedPathList;\r
 367 \r
 368                 // Since Git_client_status() returns all files, even those in\r
 369                 // folders included with Git:externals we need to check if all\r
 370                 // files we get here belongs to the same repository.\r
 371                 // It is possible to commit changes in an external folder, as long\r
 372                 // as the folder belongs to the same repository (but another path),\r
 373                 // but it is not possible to commit all files if the externals are\r
 374                 // from a different repository.\r
 375                 //\r
 376                 // To check if all files belong to the same repository, we compare the\r
 377                 // UUID's - if they're identical then the files belong to the same\r
 378                 // repository and can be committed. But if they're different, then\r
 379                 // tell the user to commit all changes in the external folders\r
 380                 // first and exit.\r
 381                 CStringA sUUID;                                 // holds the repo UUID\r
 382                 CTGitPathList arExtPaths;               // list of Git:external paths\r
 383 \r
 384                 GitConfig config;\r
 385 \r
 386                 m_sURL.Empty();\r
 387 \r
 388                 m_nTargetCount = sortedPathList.GetCount();\r
 389 \r
 390                 GitStatus status(m_pbCanceled);\r
 391                 if(m_nTargetCount > 1 && sortedPathList.AreAllPathsFilesInOneDirectory())\r
 392                 {\r
 393                         // This is a special case, where we've been given a list of files\r
 394                         // all from one folder\r
 395                         // We handle them by setting a status filter, then requesting the Git status of\r
 396                         // all the files in the directory, filtering for the ones we're interested in\r
 397                         status.SetFilter(sortedPathList);\r
 398 \r
 399                         // if all selected entries are files, we don't do a recursive status\r
 400                         // fetching. But if only one is a directory, we have to recurse.\r
 401                         git_depth_t depth = git_depth_files;\r
 402                         // We have set a filter. If all selected items were files or we fetch\r
 403                         // the status not recursively, then we have to include\r
 404                         // ignored items too - the user has selected them\r
 405                         bool bShowIgnoresRight = true;\r
 406                         for (int fcindex=0; fcindex<sortedPathList.GetCount(); ++fcindex)\r
 407                         {\r
 408                                 if (sortedPathList[fcindex].IsDirectory())\r
 409                                 {\r
 410                                         depth = git_depth_infinity;\r
 411                                         bShowIgnoresRight = false;\r
 412                                         break;\r
 413                                 }\r
 414                         }\r
 415                         if(!FetchStatusForSingleTarget(config, status, sortedPathList.GetCommonDirectory(), bUpdate, sUUID, arExtPaths, true, depth, bShowIgnoresRight))\r
 416                         {\r
 417                                 bRet = FALSE;\r
 418                         }\r
 419                 }\r
 420                 else\r
 421                 {\r
 422                         for(int nTarget = 0; nTarget < m_nTargetCount; nTarget++)\r
 423                         {\r
 424                                 // check whether the path we want the status for is already fetched due to status-fetching\r
 425                                 // of a parent path.\r
 426                                 // this check is only done for file paths, because folder paths could be included already\r
 427                                 // but not recursively\r
 428                                 if (sortedPathList[nTarget].IsDirectory() || GetListEntry(sortedPathList[nTarget]) == NULL)\r
 429                                 {\r
 430                                         if(!FetchStatusForSingleTarget(config, status, sortedPathList[nTarget], bUpdate, sUUID, \r
 431                                                 arExtPaths, false, git_depth_infinity, bShowIgnores))\r
 432                                         {\r
 433                                                 bRet = FALSE;\r
 434                                         }\r
 435                                 }\r
 436                         }\r
 437                 }\r
 438 \r
 439                 // remove the 'helper' files of conflicted items from the list.\r
 440                 // otherwise they would appear as unversioned files.\r
 441                 for (INT_PTR cind = 0; cind < m_ConflictFileList.GetCount(); ++cind)\r
 442                 {\r
 443                         for (size_t i=0; i < m_arStatusArray.size(); i++)\r
 444                         {\r
 445                                 if (m_arStatusArray[i]->GetPath().IsEquivalentTo(m_ConflictFileList[cind]))\r
 446                                 {\r
 447                                         delete m_arStatusArray[i];\r
 448                                         m_arStatusArray.erase(m_arStatusArray.begin()+i);\r
 449                                         break;\r
 450                                 }\r
 451                         }\r
 452                 }\r
 453                 refetchcounter++;\r
 454         } while(!BuildStatistics() && (refetchcounter < 2) && (*m_pbCanceled==false));\r
 455 \r
 456     if (bShowUserProps)\r
 457         FetchUserProperties();\r
 458 \r
 459     m_ColumnManager.UpdateUserPropList (m_arStatusArray);\r
 460 \r
 461         m_bBlock = FALSE;\r
 462         m_bBusy = false;\r
 463         GetCursorPos(&pt);\r
 464         SetCursorPos(pt.x, pt.y);\r
 465         return bRet;\r
 466 #endif \r
 467         BuildStatistics();\r
 468         return TRUE;\r
 469 }\r
 470 \r
 471 //\r
 472 // Fetch all local properties for all elements in the status array\r
 473 //\r
 474 void CGitStatusListCtrl::FetchUserProperties()\r
 475 {\r
 476 #if 0\r
 477         GitPool globalPool;\r
 478 \r
 479     for (size_t i = 0, count = m_arStatusArray.size(); i < count; ++i)\r
 480     {\r
 481         // local / temp pool to hold parameters and props for a single item\r
 482 \r
 483         GitPool localPool ((apr_pool_t*)globalPool);\r
 484 \r
 485         // open working copy for this path\r
 486 \r
 487         const char* path = m_arStatusArray[i]->path.GetGitApiPath (localPool);\r
 488          \r
 489             Git_wc_adm_access_t *adm_access = NULL;          \r
 490         Git_error_t * error = Git_wc_adm_probe_open3 ( &adm_access\r
 491                                                      , NULL\r
 492                                                      , path\r
 493                                                      , FALSE    // no write lock\r
 494                                                                                                          , 0            // lock just the directory/file itself\r
 495                                                      , NULL\r
 496                                                                                                          , NULL\r
 497                                                      , localPool);\r
 498         if (error == NULL)\r
 499         {\r
 500             // get the props and add them to the status info\r
 501 \r
 502             apr_hash_t* props = NULL;\r
 503             Git_error_t * error = Git_wc_prop_list ( &props\r
 504                                                    , path\r
 505                                                    , adm_access\r
 506                                                    , localPool);\r
 507             if (error == NULL)\r
 508             {\r
 509                 for ( apr_hash_index_t *index \r
 510                         = apr_hash_first (localPool, props)\r
 511                     ; index != NULL\r
 512                     ; index = apr_hash_next (index))\r
 513                 {\r
 514                     // extract next entry from hash\r
 515 \r
 516                     const char* key = NULL;\r
 517                     ptrdiff_t keyLen;\r
 518                     const char** val = NULL;\r
 519 \r
 520                     apr_hash_this ( index\r
 521                                   , reinterpret_cast<const void**>(&key)\r
 522                                   , &keyLen\r
 523                                   , reinterpret_cast<void**>(&val));\r
 524 \r
 525                     // decode / dispatch it\r
 526 \r
 527                         CString name = CUnicodeUtils::GetUnicode (key);\r
 528                         CString value = CUnicodeUtils::GetUnicode (*val);\r
 529 \r
 530                     // store in property container (truncate it after ~100 chars)\r
 531 \r
 532                     m_arStatusArray[i]->present_props[name] \r
 533                         = value.Left (GitSLC_MAXUSERPROPLENGTH);\r
 534                 }\r
 535             }\r
 536             error = Git_wc_adm_close2 (adm_access, localPool);\r
 537         }\r
 538         Git_error_clear (error);\r
 539     }\r
 540 #endif\r
 541 }\r
 542 \r
 543 \r
 544 //\r
 545 // Work on a single item from the list of paths which is provided to us\r
 546 //\r
 547 bool CGitStatusListCtrl::FetchStatusForSingleTarget(\r
 548                                                         GitConfig& config,\r
 549                                                         GitStatus& status,\r
 550                                                         const CTGitPath& target,\r
 551                                                         bool bFetchStatusFromRepository,\r
 552                                                         CStringA& strCurrentRepositoryUUID,\r
 553                                                         CTGitPathList& arExtPaths,\r
 554                                                         bool bAllDirect,\r
 555                                                         git_depth_t depth,\r
 556                                                         bool bShowIgnores\r
 557                                                         )\r
 558 {\r
 559 #if 0\r
 560         config.GetDefaultIgnores();\r
 561 \r
 562         CTGitPath workingTarget(target);\r
 563 \r
 564         git_wc_status2_t * s;\r
 565         CTGitPath GitPath;\r
 566         s = status.GetFirstFileStatus(workingTarget, GitPath, bFetchStatusFromRepository, depth, bShowIgnores);\r
 567 \r
 568         m_HeadRev = SVNRev(status.headrev);\r
 569         if (s!=0)\r
 570         {\r
 571                 Git_wc_status_kind wcFileStatus = GitStatus::GetMoreImportant(s->text_status, s->prop_status);\r
 572 \r
 573                 // This one fixes a problem with externals:\r
 574                 // If a strLine is a file, Git:externals and its parent directory\r
 575                 // will also be returned by GetXXXFileStatus. Hence, we skip all\r
 576                 // status info until we find the one matching workingTarget.\r
 577                 if (!workingTarget.IsDirectory())\r
 578                 {\r
 579                         if (!workingTarget.IsEquivalentTo(GitPath))\r
 580                         {\r
 581                                 while (s != 0)\r
 582                                 {\r
 583                                         s = status.GetNextFileStatus(GitPath);\r
 584                                         if(workingTarget.IsEquivalentTo(GitPath))\r
 585                                         {\r
 586                                                 break;\r
 587                                         }\r
 588                                 }\r
 589                                 if (s == 0)\r
 590                                 {\r
 591                                         m_sLastError = status.GetLastErrorMsg();\r
 592                                         return false;\r
 593                                 }\r
 594                                 // Now, set working target to be the base folder of this item\r
 595                                 workingTarget = workingTarget.GetDirectory();\r
 596                         }\r
 597                 }\r
 598                 bool bEntryFromDifferentRepo = false;\r
 599                 // Is this a versioned item with an associated repos UUID?\r
 600                 if ((s->entry)&&(s->entry->uuid))\r
 601                 {\r
 602                         // Have we seen a repos UUID yet?\r
 603                         if (strCurrentRepositoryUUID.IsEmpty())\r
 604                         {\r
 605                                 // This is the first repos UUID we've seen - record it\r
 606                                 strCurrentRepositoryUUID = s->entry->uuid;\r
 607                                 m_sUUID = strCurrentRepositoryUUID;\r
 608                         }\r
 609                         else\r
 610                         {\r
 611                                 if (strCurrentRepositoryUUID.Compare(s->entry->uuid)!=0)\r
 612                                 {\r
 613                                         // This item comes from a different repository than our main one\r
 614                                         m_bHasExternalsFromDifferentRepos = TRUE;\r
 615                                         bEntryFromDifferentRepo = true;\r
 616                                         if (s->entry->kind == Git_node_dir)\r
 617                                                 arExtPaths.AddPath(workingTarget);\r
 618                                 }\r
 619                         }\r
 620                 }\r
 621                 else if (strCurrentRepositoryUUID.IsEmpty() && (s->text_status == Git_wc_status_added))\r
 622                 {\r
 623                         // An added entry doesn't have an UUID assigned to it yet.\r
 624                         // So we fetch the status of the parent directory instead and\r
 625                         // check if that one has an UUID assigned to it.\r
 626                         Git_wc_status2_t * sparent;\r
 627                         CTGitPath path = workingTarget;\r
 628                         do\r
 629                         {\r
 630                                 CTGitPath GitParentPath;\r
 631                                 GitStatus tempstatus;\r
 632                                 sparent = tempstatus.GetFirstFileStatus(path.GetContainingDirectory(), GitParentPath, false, Git_depth_empty, false);\r
 633                                 path = GitParentPath;\r
 634                         } while ( (sparent) && (sparent->entry) && (!sparent->entry->uuid) && (sparent->text_status==Git_wc_status_added) );\r
 635                         if (sparent && sparent->entry && sparent->entry->uuid)\r
 636                         {\r
 637                                 strCurrentRepositoryUUID = sparent->entry->uuid;\r
 638                                 m_sUUID = strCurrentRepositoryUUID;\r
 639                         }\r
 640                 }\r
 641 \r
 642                 if ((wcFileStatus == Git_wc_status_unversioned)&& GitPath.IsDirectory())\r
 643                 {\r
 644                         // check if the unversioned folder is maybe versioned. This\r
 645                         // could happen with nested layouts\r
 646                         Git_wc_status_kind st = GitStatus::GetAllStatus(workingTarget);\r
 647                         if ((st != Git_wc_status_unversioned)&&(st != Git_wc_status_none))\r
 648                         {\r
 649                                 return true;    // ignore nested layouts\r
 650                         }\r
 651                 }\r
 652                 if (status.IsExternal(GitPath))\r
 653                 {\r
 654                         m_bHasExternals = TRUE;\r
 655                 }\r
 656 \r
 657                 AddNewFileEntry(s, GitPath, workingTarget, true, m_bHasExternals, bEntryFromDifferentRepo);\r
 658 \r
 659                 if (((wcFileStatus == Git_wc_status_unversioned)||(wcFileStatus == Git_wc_status_none)||((wcFileStatus == Git_wc_status_ignored)&&(m_bShowIgnores))) && GitPath.IsDirectory())\r
 660                 {\r
 661                         // we have an unversioned folder -> get all files in it recursively!\r
 662                         AddUnversionedFolder(GitPath, workingTarget.GetContainingDirectory(), &config);\r
 663                 }\r
 664 \r
 665                 // for folders, get all statuses inside it too\r
 666                 if(workingTarget.IsDirectory())\r
 667                 {\r
 668                         ReadRemainingItemsStatus(status, workingTarget, strCurrentRepositoryUUID, arExtPaths, &config, bAllDirect);\r
 669                 }\r
 670 \r
 671         } // if (s!=0)\r
 672         else\r
 673         {\r
 674                 m_sLastError = status.GetLastErrorMsg();\r
 675                 return false;\r
 676         }\r
 677 #endif\r
 678         return true;\r
 679 }\r
 680 #if 0\r
 681 const CGitStatusListCtrl::FileEntry*\r
 682 CGitStatusListCtrl::AddNewFileEntry(\r
 683                         const git_wc_status2_t* pGitStatus,  // The return from the Git GetStatus functions\r
 684                         const CTGitPath& path,                          // The path of the item we're adding\r
 685                         const CTGitPath& basePath,                      // The base directory for this status build\r
 686                         bool bDirectItem,                                       // Was this item the first found by GetFirstFileStatus or by a subsequent GetNextFileStatus call\r
 687                         bool bInExternal,                                       // Are we in an 'external' folder\r
 688                         bool bEntryfromDifferentRepo            // if the entry is from a different repository\r
 689                         )\r
 690 {\r
 691         FileEntry * entry = new FileEntry();\r
 692 \r
 693         \r
 694         entry->path = path;\r
 695         entry->basepath = basePath;\r
 696         entry->status = GitStatus::GetMoreImportant(pGitStatus->text_status, pGitStatus->prop_status);\r
 697         entry->textstatus = pGitStatus->text_status;\r
 698         entry->propstatus = pGitStatus->prop_status;\r
 699 //      entry->remotestatus = GitStatus::GetMoreImportant(pGitStatus->repos_text_status, pGitStatus->repos_prop_status);\r
 700 //      entry->remotetextstatus = pGitStatus->repos_text_status;\r
 701 //      entry->remotepropstatus = pGitStatus->repos_prop_status;\r
 702         entry->inexternal = bInExternal;\r
 703         entry->differentrepo = bEntryfromDifferentRepo;\r
 704         entry->direct = bDirectItem;\r
 705 //      entry->copied = !!pGitStatus->copied;\r
 706 //      entry->switched = !!pGitStatus->switched;\r
 707 \r
 708         entry->last_commit_date = pGitStatus->ood_last_cmt_date;\r
 709         if ((entry->last_commit_date == NULL)&&(pGitStatus->entry))\r
 710                 entry->last_commit_date = pGitStatus->entry->cmt_date;\r
 711         entry->remoterev = pGitStatus->ood_last_cmt_rev;\r
 712         if (pGitStatus->entry)\r
 713                 entry->last_commit_rev = pGitStatus->entry->cmt_rev;\r
 714         if (pGitStatus->ood_last_cmt_author)\r
 715                 entry->last_commit_author = CUnicodeUtils::GetUnicode(pGitStatus->ood_last_cmt_author);\r
 716         if ((entry->last_commit_author.IsEmpty())&&(pGitStatus->entry)&&(pGitStatus->entry->cmt_author))\r
 717                 entry->last_commit_author = CUnicodeUtils::GetUnicode(pGitStatus->entry->cmt_author);\r
 718 \r
 719         if (pGitStatus->entry)\r
 720                 entry->isConflicted = (pGitStatus->entry->conflict_wrk && PathFileExists(CUnicodeUtils::GetUnicode(pGitStatus->entry->conflict_wrk))) ? true : false;\r
 721 \r
 722         if ((entry->status == Git_wc_status_conflicted)||(entry->isConflicted))\r
 723         {\r
 724                 entry->isConflicted = true;\r
 725                 if (pGitStatus->entry)\r
 726                 {\r
 727                         CTGitPath cpath;\r
 728                         if (pGitStatus->entry->conflict_wrk)\r
 729                         {\r
 730                                 cpath = path.GetDirectory();\r
 731                                 cpath.AppendPathString(CUnicodeUtils::GetUnicode(pGitStatus->entry->conflict_wrk));\r
 732                                 m_ConflictFileList.AddPath(cpath);\r
 733                         }\r
 734                         if (pGitStatus->entry->conflict_old)\r
 735                         {\r
 736                                 cpath = path.GetDirectory();\r
 737                                 cpath.AppendPathString(CUnicodeUtils::GetUnicode(pGitStatus->entry->conflict_old));\r
 738                                 m_ConflictFileList.AddPath(cpath);\r
 739                         }\r
 740                         if (pGitStatus->entry->conflict_new)\r
 741                         {\r
 742                                 cpath = path.GetDirectory();\r
 743                                 cpath.AppendPathString(CUnicodeUtils::GetUnicode(pGitStatus->entry->conflict_new));\r
 744                                 m_ConflictFileList.AddPath(cpath);\r
 745                         }\r
 746                         if (pGitStatus->entry->prejfile)\r
 747                         {\r
 748                                 cpath = path.GetDirectory();\r
 749                                 cpath.AppendPathString(CUnicodeUtils::GetUnicode(pGitStatus->entry->prejfile));\r
 750                                 m_ConflictFileList.AddPath(cpath);\r
 751                         }\r
 752                 }\r
 753         }\r
 754 \r
 755         if (pGitStatus->entry)\r
 756         {\r
 757                 entry->isfolder = (pGitStatus->entry->kind == Git_node_dir);\r
 758                 entry->Revision = pGitStatus->entry->revision;\r
 759                 entry->keeplocal = !!pGitStatus->entry->keep_local;\r
 760                 entry->working_size = pGitStatus->entry->working_size;\r
 761                 entry->depth = pGitStatus->entry->depth;\r
 762 \r
 763                 if (pGitStatus->entry->url)\r
 764                 {\r
 765                         entry->url = CUnicodeUtils::GetUnicode(CPathUtils::PathUnescape(pGitStatus->entry->url));\r
 766                 }\r
 767                 if (pGitStatus->entry->copyfrom_url)\r
 768                 {\r
 769                         entry->copyfrom_url = CUnicodeUtils::GetUnicode(CPathUtils::PathUnescape(pGitStatus->entry->copyfrom_url));\r
 770                         entry->copyfrom_rev = pGitStatus->entry->copyfrom_rev;\r
 771                 }\r
 772                 else\r
 773                         entry->copyfrom_rev = 0;\r
 774 \r
 775                 if(bDirectItem)\r
 776                 {\r
 777                         if (m_sURL.IsEmpty())\r
 778                                 m_sURL = entry->url;\r
 779                         else\r
 780                                 m_sURL.LoadString(IDS_STATUSLIST_MULTIPLETARGETS);\r
 781                         m_StatusUrlList.AddPath(CTGitPath(entry->url));\r
 782                 }\r
 783                 if (pGitStatus->entry->lock_owner)\r
 784                         entry->lock_owner = CUnicodeUtils::GetUnicode(pGitStatus->entry->lock_owner);\r
 785                 if (pGitStatus->entry->lock_token)\r
 786                 {\r
 787                         entry->lock_token = CUnicodeUtils::GetUnicode(pGitStatus->entry->lock_token);\r
 788                         m_bHasLocks = true;\r
 789                 }\r
 790                 if (pGitStatus->entry->lock_comment)\r
 791                         entry->lock_comment = CUnicodeUtils::GetUnicode(pGitStatus->entry->lock_comment);\r
 792 \r
 793                 if (pGitStatus->entry->present_props)\r
 794                 {\r
 795                         entry->present_props = pGitStatus->entry->present_props;\r
 796                 }\r
 797 \r
 798                 if (pGitStatus->entry->changelist)\r
 799                 {\r
 800                         entry->changelist = CUnicodeUtils::GetUnicode(pGitStatus->entry->changelist);\r
 801                         m_changelists[entry->changelist] = -1;\r
 802                         m_bHasChangeLists = true;\r
 803                 }\r
 804                 entry->needslock = (pGitStatus->entry->present_props && (strstr(pGitStatus->entry->present_props, "Git:needs-lock")!=NULL) );\r
 805         }\r
 806         else\r
 807         {\r
 808                 if (pGitStatus->ood_kind == Git_node_none)\r
 809                         entry->isfolder = path.IsDirectory();\r
 810                 else\r
 811                         entry->isfolder = (pGitStatus->ood_kind == Git_node_dir);\r
 812         }\r
 813         if (pGitStatus->repos_lock)\r
 814         {\r
 815                 if (pGitStatus->repos_lock->owner)\r
 816                         entry->lock_remoteowner = CUnicodeUtils::GetUnicode(pGitStatus->repos_lock->owner);\r
 817                 if (pGitStatus->repos_lock->token)\r
 818                         entry->lock_remotetoken = CUnicodeUtils::GetUnicode(pGitStatus->repos_lock->token);\r
 819                 if (pGitStatus->repos_lock->comment)\r
 820                         entry->lock_comment = CUnicodeUtils::GetUnicode(pGitStatus->repos_lock->comment);\r
 821         }\r
 822 \r
 823         // Pass ownership of the entry to the array\r
 824         m_arStatusArray.push_back(entry);\r
 825 \r
 826         return entry;\r
 827 }\r
 828 #endif\r
 829 \r
 830 void CGitStatusListCtrl::AddUnversionedFolder(const CTGitPath& folderName,\r
 831                                                                                                 const CTGitPath& basePath,\r
 832                                                                                                 GitConfig * config)\r
 833 {\r
 834 #if 0\r
 835         if (!m_bUnversionedRecurse)\r
 836                 return;\r
 837         CSimpleFileFind filefinder(folderName.GetWinPathString());\r
 838 \r
 839         CTGitPath filename;\r
 840         m_bHasUnversionedItems = TRUE;\r
 841         while (filefinder.FindNextFileNoDots())\r
 842         {\r
 843                 filename.SetFromWin(filefinder.GetFilePath(), filefinder.IsDirectory());\r
 844 \r
 845                 bool bMatchIgnore = !!config->MatchIgnorePattern(filename.GetFileOrDirectoryName());\r
 846                 bMatchIgnore = bMatchIgnore || config->MatchIgnorePattern(filename.GetGitPathString());\r
 847                 if (((bMatchIgnore)&&(m_bShowIgnores))||(!bMatchIgnore))\r
 848                 {\r
 849                         FileEntry * entry = new FileEntry();\r
 850                         entry->path = filename;\r
 851                         entry->basepath = basePath;\r
 852                         entry->inunversionedfolder = true;\r
 853                         entry->isfolder = filefinder.IsDirectory();\r
 854 \r
 855                         m_arStatusArray.push_back(entry);\r
 856                         if (entry->isfolder)\r
 857                         {\r
 858                                 if (!g_GitAdminDir.HasAdminDir(entry->path.GetWinPathString(), true))\r
 859                                         AddUnversionedFolder(entry->path, basePath, config);\r
 860                         }\r
 861                 }\r
 862         }\r
 863 #endif\r
 864 }\r
 865 \r
 866 \r
 867 void CGitStatusListCtrl::ReadRemainingItemsStatus(GitStatus& status, const CTGitPath& basePath,\r
 868                                                                                   CStringA& strCurrentRepositoryUUID,\r
 869                                                                                   CTGitPathList& arExtPaths, GitConfig * config, bool bAllDirect)\r
 870 {\r
 871 #if 0\r
 872         git_wc_status2_t * s;\r
 873 \r
 874         CTGitPath lastexternalpath;\r
 875         CTGitPath GitPath;\r
 876         while ((s = status.GetNextFileStatus(GitPath)) != NULL)\r
 877         {\r
 878                 Git_wc_status_kind wcFileStatus = GitStatus::GetMoreImportant(s->text_status, s->prop_status);\r
 879                 if ((wcFileStatus == Git_wc_status_unversioned) && (GitPath.IsDirectory()))\r
 880                 {\r
 881                         // check if the unversioned folder is maybe versioned. This\r
 882                         // could happen with nested layouts\r
 883                         Git_wc_status_kind st = GitStatus::GetAllStatus(GitPath);\r
 884                         if ((st != Git_wc_status_unversioned)&&(st != Git_wc_status_none))\r
 885                         {\r
 886                                 FileEntry * entry = new FileEntry();\r
 887                                 entry->path = GitPath;\r
 888                                 entry->basepath = basePath;\r
 889                                 entry->inunversionedfolder = true;\r
 890                                 entry->isfolder = true;\r
 891                                 entry->isNested = true;\r
 892                                 m_arStatusArray.push_back(entry);\r
 893                                 continue;\r
 894                         }\r
 895                 }\r
 896                 bool bDirectoryIsExternal = false;\r
 897                 bool bEntryfromDifferentRepo = false;\r
 898                 if (s->entry)\r
 899                 {\r
 900                         if (s->entry->uuid)\r
 901                         {\r
 902                                 if (strCurrentRepositoryUUID.IsEmpty())\r
 903                                         strCurrentRepositoryUUID = s->entry->uuid;\r
 904                                 else\r
 905                                 {\r
 906                                         if (strCurrentRepositoryUUID.Compare(s->entry->uuid)!=0)\r
 907                                         {\r
 908                                                 bEntryfromDifferentRepo = true;\r
 909                                                 if (GitStatus::IsImportant(wcFileStatus))\r
 910                                                         m_bHasExternalsFromDifferentRepos = TRUE;\r
 911                                                 if (s->entry->kind == Git_node_dir)\r
 912                                                 {\r
 913                                                         if ((lastexternalpath.IsEmpty())||(!lastexternalpath.IsAncestorOf(GitPath)))\r
 914                                                         {\r
 915                                                                 arExtPaths.AddPath(GitPath);\r
 916                                                                 lastexternalpath = GitPath;\r
 917                                                         }\r
 918                                                 }\r
 919                                         }\r
 920                                 }\r
 921                         }\r
 922                         else\r
 923                         {\r
 924                                 // we don't have an UUID - maybe an added file/folder\r
 925                                 if (!strCurrentRepositoryUUID.IsEmpty())\r
 926                                 {\r
 927                                         if ((!lastexternalpath.IsEmpty())&&\r
 928                                                 (lastexternalpath.IsAncestorOf(GitPath)))\r
 929                                         {\r
 930                                                 bEntryfromDifferentRepo = true;\r
 931                                                 m_bHasExternalsFromDifferentRepos = TRUE;\r
 932                                         }\r
 933                                 }\r
 934                         }\r
 935                 }\r
 936                 else\r
 937                 {\r
 938                         // if unversioned items lie around in external\r
 939                         // directories from different repos, we have to mark them\r
 940                         // as such too.\r
 941                         if (!strCurrentRepositoryUUID.IsEmpty())\r
 942                         {\r
 943                                 if ((!lastexternalpath.IsEmpty())&&\r
 944                                         (lastexternalpath.IsAncestorOf(GitPath)))\r
 945                                 {\r
 946                                         bEntryfromDifferentRepo = true;\r
 947                                 }\r
 948                         }\r
 949                 }\r
 950                 if (status.IsExternal(GitPath))\r
 951                 {\r
 952                         arExtPaths.AddPath(GitPath);\r
 953                         m_bHasExternals = TRUE;\r
 954                 }\r
 955                 if ((!bEntryfromDifferentRepo)&&(status.IsInExternal(GitPath)))\r
 956                 {\r
 957                         // if the externals are inside an unversioned folder (this happens if\r
 958                         // the externals are specified with e.g. "ext\folder url" instead of just\r
 959                         // "folder url"), then a commit won't succeed.\r
 960                         // therefore, we treat those as if the externals come from a different\r
 961                         // repository\r
 962                         CTGitPath extpath = GitPath;\r
 963                         while (basePath.IsAncestorOf(extpath))\r
 964                         {\r
 965                                 if (!extpath.HasAdminDir())\r
 966                                 {\r
 967                                         bEntryfromDifferentRepo = true;\r
 968                                         break;\r
 969                                 }\r
 970                                 extpath = extpath.GetContainingDirectory();\r
 971                         }\r
 972                 }\r
 973                 // Do we have any external paths?\r
 974                 if(arExtPaths.GetCount() > 0)\r
 975                 {\r
 976                         // If do have external paths, we need to check if the current item belongs\r
 977                         // to one of them\r
 978                         for (int ix=0; ix<arExtPaths.GetCount(); ix++)\r
 979                         {\r
 980                                 if (arExtPaths[ix].IsAncestorOf(GitPath))\r
 981                                 {\r
 982                                         bDirectoryIsExternal = true;\r
 983                                         break;\r
 984                                 }\r
 985                         }\r
 986                 }\r
 987 \r
 988                 if ((wcFileStatus == Git_wc_status_unversioned)&&(!bDirectoryIsExternal))\r
 989                         m_bHasUnversionedItems = TRUE;\r
 990 \r
 991                 const FileEntry* entry = AddNewFileEntry(s, GitPath, basePath, bAllDirect, bDirectoryIsExternal, bEntryfromDifferentRepo);\r
 992 \r
 993                 bool bMatchIgnore = !!config->MatchIgnorePattern(entry->path.GetFileOrDirectoryName());\r
 994                 bMatchIgnore = bMatchIgnore || config->MatchIgnorePattern(entry->path.GetGitPathString());\r
 995                 if ((((wcFileStatus == Git_wc_status_unversioned)||(wcFileStatus == Git_wc_status_none))&&(!bMatchIgnore))||\r
 996                         ((wcFileStatus == Git_wc_status_ignored)&&(m_bShowIgnores))||\r
 997                         (((wcFileStatus == Git_wc_status_unversioned)||(wcFileStatus == Git_wc_status_none))&&(bMatchIgnore)&&(m_bShowIgnores)))\r
 998                 {\r
 999                         if (entry->isfolder)\r
1000                         {\r
1001                                 // we have an unversioned folder -> get all files in it recursively!\r
1002                                 AddUnversionedFolder(GitPath, basePath, config);\r
1003                         }\r
1004                 }\r
1005         } // while ((s = status.GetNextFileStatus(GitPath)) != NULL) \r
1006 #endif\r
1007 }\r
1008 \r
1009 // Get the show-flags bitmap value which corresponds to a particular Git status\r
1010 DWORD CGitStatusListCtrl::GetShowFlagsFromGitStatus(git_wc_status_kind status)\r
1011 {\r
1012         switch (status)\r
1013         {\r
1014         case git_wc_status_none:\r
1015         case git_wc_status_unversioned:\r
1016                 return SVNSLC_SHOWUNVERSIONED;\r
1017         case git_wc_status_ignored:\r
1018                 if (!m_bShowIgnores)\r
1019                         return SVNSLC_SHOWDIRECTS;\r
1020                 return SVNSLC_SHOWDIRECTS|SVNSLC_SHOWIGNORED;\r
1021         case git_wc_status_incomplete:\r
1022                 return SVNSLC_SHOWINCOMPLETE;\r
1023         case git_wc_status_normal:\r
1024                 return SVNSLC_SHOWNORMAL;\r
1025         case git_wc_status_external:\r
1026                 return SVNSLC_SHOWEXTERNAL;\r
1027         case git_wc_status_added:\r
1028                 return SVNSLC_SHOWADDED;\r
1029         case git_wc_status_missing:\r
1030                 return SVNSLC_SHOWMISSING;\r
1031         case git_wc_status_deleted:\r
1032                 return SVNSLC_SHOWREMOVED;\r
1033         case git_wc_status_replaced:\r
1034                 return SVNSLC_SHOWREPLACED;\r
1035         case git_wc_status_modified:\r
1036                 return SVNSLC_SHOWMODIFIED;\r
1037         case git_wc_status_merged:\r
1038                 return SVNSLC_SHOWMERGED;\r
1039         case git_wc_status_conflicted:\r
1040                 return SVNSLC_SHOWCONFLICTED;\r
1041         case git_wc_status_obstructed:\r
1042                 return SVNSLC_SHOWOBSTRUCTED;\r
1043         default:\r
1044                 // we should NEVER get here!\r
1045                 ASSERT(FALSE);\r
1046                 break;\r
1047         }\r
1048         return 0;\r
1049 }\r
1050 \r
1051 void CGitStatusListCtrl::Show(DWORD dwShow, DWORD dwCheck /*=0*/, bool bShowFolders /* = true */,BOOL UpdateStatusList)\r
1052 {\r
1053         CWinApp * pApp = AfxGetApp();\r
1054         if (pApp)\r
1055                 pApp->DoWaitCursor(1);\r
1056 \r
1057         Locker lock(m_critSec);\r
1058         WORD langID = (WORD)CRegStdWORD(_T("Software\\TortoiseSVN\\LanguageID"), GetUserDefaultLangID());\r
1059         \r
1060         //SetItemCount(listIndex);\r
1061         SetRedraw(FALSE);\r
1062         DeleteAllItems();\r
1063         PrepareGroups();\r
1064         m_nSelected = 0;\r
1065 \r
1066         if(UpdateStatusList)\r
1067         {\r
1068                 m_arStatusArray.clear();\r
1069                 for(int i=0;i<this->m_StatusFileList.GetCount();i++)\r
1070                 {\r
1071                         m_arStatusArray.push_back((CTGitPath*)&m_StatusFileList[i]);\r
1072                 }\r
1073 \r
1074                 for(int i=0;i<this->m_UnRevFileList.GetCount();i++)\r
1075                 {\r
1076                         m_arStatusArray.push_back((CTGitPath*)&m_UnRevFileList[i]);\r
1077                 }\r
1078 \r
1079                 for(int i=0;i<this->m_IgnoreFileList.GetCount();i++)\r
1080                 {\r
1081                         m_arStatusArray.push_back((CTGitPath*)&m_IgnoreFileList[i]);\r
1082                 }\r
1083         }\r
1084         for(int i=0;i<this->m_arStatusArray.size();i++)\r
1085         {\r
1086                 if(((CTGitPath*)m_arStatusArray[i])->m_Action & dwShow)\r
1087                                 AddEntry((CTGitPath*)m_arStatusArray[i],langID,i);\r
1088         }\r
1089         \r
1090         int maxcol = ((CHeaderCtrl*)(GetDlgItem(0)))->GetItemCount()-1;\r
1091         for (int col = 0; col <= maxcol; col++)\r
1092         SetColumnWidth (col, m_ColumnManager.GetWidth (col, true));\r
1093 \r
1094     SetRedraw(TRUE);\r
1095         GetStatisticsString();\r
1096 \r
1097         CHeaderCtrl * pHeader = GetHeaderCtrl();\r
1098         HDITEM HeaderItem = {0};\r
1099         HeaderItem.mask = HDI_FORMAT;\r
1100         for (int i=0; i<pHeader->GetItemCount(); ++i)\r
1101         {\r
1102                 pHeader->GetItem(i, &HeaderItem);\r
1103                 HeaderItem.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);\r
1104                 pHeader->SetItem(i, &HeaderItem);\r
1105         }\r
1106         if (m_nSortedColumn)\r
1107         {\r
1108                 pHeader->GetItem(m_nSortedColumn, &HeaderItem);\r
1109                 HeaderItem.fmt |= (m_bAscending ? HDF_SORTUP : HDF_SORTDOWN);\r
1110                 pHeader->SetItem(m_nSortedColumn, &HeaderItem);\r
1111         }\r
1112 \r
1113 #if 0\r
1114         if (nSelectedEntry)\r
1115         {\r
1116                 SetItemState(nSelectedEntry, LVIS_SELECTED, LVIS_SELECTED);\r
1117                 EnsureVisible(nSelectedEntry, false);\r
1118         }\r
1119         else\r
1120         {\r
1121                 // Restore the item at the top of the list.\r
1122                 for (int i=0;GetTopIndex() != nTopIndex;i++)\r
1123                 {\r
1124                         if ( !EnsureVisible(nTopIndex+i,false) )\r
1125                         {\r
1126                                 break;\r
1127                         }\r
1128                 }\r
1129         }\r
1130 #endif\r
1131         if (pApp)\r
1132                 pApp->DoWaitCursor(-1);\r
1133 \r
1134         Invalidate();\r
1135         \r
1136         m_dwShow = dwShow;\r
1137 \r
1138 #if 0\r
1139 \r
1140         CWinApp * pApp = AfxGetApp();\r
1141         if (pApp)\r
1142                 pApp->DoWaitCursor(1);\r
1143 \r
1144         m_bShowFolders = bShowFolders;\r
1145         \r
1146         int nTopIndex = GetTopIndex();\r
1147         POSITION posSelectedEntry = GetFirstSelectedItemPosition();\r
1148         int nSelectedEntry = 0;\r
1149         if (posSelectedEntry)\r
1150                 nSelectedEntry = GetNextSelectedItem(posSelectedEntry);\r
1151         SetRedraw(FALSE);\r
1152         DeleteAllItems();\r
1153 \r
1154         PrepareGroups();\r
1155 \r
1156         m_arListArray.clear();\r
1157 \r
1158         m_arListArray.reserve(m_arStatusArray.size());\r
1159         SetItemCount (static_cast<int>(m_arStatusArray.size()));\r
1160 \r
1161         int listIndex = 0;\r
1162         for (size_t i=0; i < m_arStatusArray.size(); ++i)\r
1163         {\r
1164                 FileEntry * entry = m_arStatusArray[i];\r
1165                 if ((entry->inexternal) && (!(dwShow & SVNSLC_SHOWINEXTERNALS)))\r
1166                         continue;\r
1167                 if ((entry->differentrepo || entry->isNested) && (! (dwShow & SVNSLC_SHOWEXTERNALFROMDIFFERENTREPO)))\r
1168                         continue;\r
1169                 if (entry->IsFolder() && (!bShowFolders))\r
1170                         continue;       // don't show folders if they're not wanted.\r
1171 \r
1172 #if 0\r
1173                 git_wc_status_kind status = GitStatus::GetMoreImportant(entry->status, entry->remotestatus);\r
1174                 DWORD showFlags = GetShowFlagsFromGitStatus(status);\r
1175                 if (entry->IsLocked())\r
1176                         showFlags |= SVNSLC_SHOWLOCKS;\r
1177                 if (entry->switched)\r
1178                         showFlags |= SVNSLC_SHOWSWITCHED;\r
1179                 if (!entry->changelist.IsEmpty())\r
1180                         showFlags |= SVNSLC_SHOWINCHANGELIST;\r
1181 #endif\r
1182                 bool bAllowCheck = ((entry->changelist.Compare(SVNSLC_IGNORECHANGELIST) != 0) \r
1183                         && (m_bCheckIfGroupsExist || (m_changelists.size()==0 || (m_changelists.size()==1 && m_bHasIgnoreGroup))));\r
1184 \r
1185                 // status_ignored is a special case - we must have the 'direct' flag set to add a status_ignored item\r
1186 #if 0\r
1187                 if (status != Git_wc_status_ignored || (entry->direct) || (dwShow & GitSLC_SHOWIGNORED))\r
1188                 {\r
1189                         if ((!entry->IsFolder()) && (status == Git_wc_status_deleted) && (dwShow & SVNSLC_SHOWREMOVEDANDPRESENT))\r
1190                         {\r
1191                                 if (PathFileExists(entry->GetPath().GetWinPath()))\r
1192                                 {\r
1193                                         m_arListArray.push_back(i);\r
1194                                         if ((dwCheck & SVNSLC_SHOWREMOVEDANDPRESENT)||((dwCheck & SVNSLC_SHOWDIRECTS)&&(entry->direct)))\r
1195                                         {\r
1196                                                 if (bAllowCheck)\r
1197                                                         entry->checked = true;\r
1198                                         }\r
1199                                         AddEntry(entry, langID, listIndex++);\r
1200                                 }\r
1201                         }\r
1202                         else if ((dwShow & showFlags)||((dwShow & SVNSLC_SHOWDIRECTFILES)&&(entry->direct)&&(!entry->IsFolder())))\r
1203                         {\r
1204                                 m_arListArray.push_back(i);\r
1205                                 if ((dwCheck & showFlags)||((dwCheck & SVNSLC_SHOWDIRECTS)&&(entry->direct)))\r
1206                                 {\r
1207                                         if (bAllowCheck)\r
1208                                                 entry->checked = true;\r
1209                                 }\r
1210                                 AddEntry(entry, langID, listIndex++);\r
1211                         }\r
1212                         else if ((dwShow & showFlags)||((dwShow & SVNSLC_SHOWDIRECTFOLDER)&&(entry->direct)&&entry->IsFolder()))\r
1213                         {\r
1214                                 m_arListArray.push_back(i);\r
1215                                 if ((dwCheck & showFlags)||((dwCheck & SVNSLC_SHOWDIRECTS)&&(entry->direct)))\r
1216                                 {\r
1217                                         if (bAllowCheck)\r
1218                                                 entry->checked = true;\r
1219                                 }\r
1220                                 AddEntry(entry, langID, listIndex++);\r
1221                         }\r
1222                 }\r
1223 #endif\r
1224         }\r
1225 \r
1226         SetItemCount(listIndex);\r
1227 \r
1228     m_ColumnManager.UpdateRelevance (m_arStatusArray, m_arListArray);\r
1229 \r
1230         int maxcol = ((CHeaderCtrl*)(GetDlgItem(0)))->GetItemCount()-1;\r
1231         for (int col = 0; col <= maxcol; col++)\r
1232         SetColumnWidth (col, m_ColumnManager.GetWidth (col, true));\r
1233 \r
1234     SetRedraw(TRUE);\r
1235         GetStatisticsString();\r
1236 \r
1237         CHeaderCtrl * pHeader = GetHeaderCtrl();\r
1238         HDITEM HeaderItem = {0};\r
1239         HeaderItem.mask = HDI_FORMAT;\r
1240         for (int i=0; i<pHeader->GetItemCount(); ++i)\r
1241         {\r
1242                 pHeader->GetItem(i, &HeaderItem);\r
1243                 HeaderItem.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);\r
1244                 pHeader->SetItem(i, &HeaderItem);\r
1245         }\r
1246         if (m_nSortedColumn)\r
1247         {\r
1248                 pHeader->GetItem(m_nSortedColumn, &HeaderItem);\r
1249                 HeaderItem.fmt |= (m_bAscending ? HDF_SORTUP : HDF_SORTDOWN);\r
1250                 pHeader->SetItem(m_nSortedColumn, &HeaderItem);\r
1251         }\r
1252 \r
1253         if (nSelectedEntry)\r
1254         {\r
1255                 SetItemState(nSelectedEntry, LVIS_SELECTED, LVIS_SELECTED);\r
1256                 EnsureVisible(nSelectedEntry, false);\r
1257         }\r
1258         else\r
1259         {\r
1260                 // Restore the item at the top of the list.\r
1261                 for (int i=0;GetTopIndex() != nTopIndex;i++)\r
1262                 {\r
1263                         if ( !EnsureVisible(nTopIndex+i,false) )\r
1264                         {\r
1265                                 break;\r
1266                         }\r
1267                 }\r
1268         }\r
1269 \r
1270         if (pApp)\r
1271                 pApp->DoWaitCursor(-1);\r
1272 \r
1273         m_bEmpty = (GetItemCount() == 0);\r
1274         Invalidate();\r
1275 #endif\r
1276 \r
1277 }\r
1278 \r
1279 void CGitStatusListCtrl::Show(DWORD dwShow, const CTGitPathList& checkedList, bool bShowFolders /* = true */)\r
1280 {\r
1281         return ;\r
1282 #if 0\r
1283 \r
1284         Locker lock(m_critSec);\r
1285         WORD langID = (WORD)CRegStdWORD(_T("Software\\TortoiseSVN\\LanguageID"), GetUserDefaultLangID());\r
1286 \r
1287         CWinApp * pApp = AfxGetApp();\r
1288         if (pApp)\r
1289                 pApp->DoWaitCursor(1);\r
1290         m_dwShow = dwShow;\r
1291         m_bShowFolders = bShowFolders;\r
1292         m_nSelected = 0;\r
1293         int nTopIndex = GetTopIndex();\r
1294         POSITION posSelectedEntry = GetFirstSelectedItemPosition();\r
1295         int nSelectedEntry = 0;\r
1296         if (posSelectedEntry)\r
1297                 nSelectedEntry = GetNextSelectedItem(posSelectedEntry);\r
1298         SetRedraw(FALSE);\r
1299         DeleteAllItems();\r
1300 \r
1301         PrepareGroups();\r
1302 \r
1303         m_arListArray.clear();\r
1304 \r
1305         m_arListArray.reserve(m_arStatusArray.size());\r
1306         SetItemCount (static_cast<int>(m_arStatusArray.size()));\r
1307 \r
1308         int listIndex = 0;\r
1309         for (size_t i=0; i < m_arStatusArray.size(); ++i)\r
1310         {\r
1311                 FileEntry * entry = m_arStatusArray[i];\r
1312                 if ((entry->inexternal) && (!(dwShow & SVNSLC_SHOWINEXTERNALS)))\r
1313                         continue;\r
1314                 if ((entry->differentrepo || entry->isNested) && (! (dwShow & SVNSLC_SHOWEXTERNALFROMDIFFERENTREPO)))\r
1315                         continue;\r
1316                 if (entry->IsFolder() && (!bShowFolders))\r
1317                         continue;       // don't show folders if they're not wanted.\r
1318 #if 0\r
1319                 git_wc_status_kind status = SVNStatus::GetMoreImportant(entry->status, entry->remotestatus);\r
1320                 DWORD showFlags = GetShowFlagsFromSVNStatus(status);\r
1321                 if (entry->IsLocked())\r
1322                         showFlags |= SVNSLC_SHOWLOCKS;\r
1323                 if (!entry->changelist.IsEmpty())\r
1324                         showFlags |= SVNSLC_SHOWINCHANGELIST;\r
1325 \r
1326                 // status_ignored is a special case - we must have the 'direct' flag set to add a status_ignored item\r
1327                 if (status != git_wc_status_ignored || (entry->direct) || (dwShow & SVNSLC_SHOWIGNORED))\r
1328                 {\r
1329                         for (int npath = 0; npath < checkedList.GetCount(); ++npath)\r
1330                         {\r
1331                                 if (entry->GetPath().IsEquivalentTo(checkedList[npath]))\r
1332                                 {\r
1333                                         entry->checked = true;\r
1334                                         break;\r
1335                                 }\r
1336                         }\r
1337                         if ((!entry->IsFolder()) && (status == git_wc_status_deleted) && (dwShow & SVNSLC_SHOWREMOVEDANDPRESENT))\r
1338                         {\r
1339                                 if (PathFileExists(entry->GetPath().GetWinPath()))\r
1340                                 {\r
1341                                         m_arListArray.push_back(i);\r
1342                                         AddEntry(entry, langID, listIndex++);\r
1343                                 }\r
1344                         }\r
1345                         else if ((dwShow & showFlags)||((dwShow & SVNSLC_SHOWDIRECTFILES)&&(entry->direct)&&(!entry->IsFolder())))\r
1346                         {\r
1347                                 m_arListArray.push_back(i);\r
1348                                 AddEntry(entry, langID, listIndex++);\r
1349                         }\r
1350                         else if ((dwShow & showFlags)||((dwShow & SVNSLC_SHOWDIRECTFOLDER)&&(entry->direct)&&entry->IsFolder()))\r
1351                         {\r
1352                                 m_arListArray.push_back(i);\r
1353                                 AddEntry(entry, langID, listIndex++);\r
1354                         }\r
1355                         else if (entry->switched)\r
1356                         {\r
1357                                 m_arListArray.push_back(i);\r
1358                                 AddEntry(entry, langID, listIndex++);\r
1359                         }\r
1360                 }\r
1361 #endif\r
1362         }\r
1363 \r
1364         SetItemCount(listIndex);\r
1365 \r
1366         int maxcol = ((CHeaderCtrl*)(GetDlgItem(0)))->GetItemCount()-1;\r
1367         for (int col = 0; col <= maxcol; col++)\r
1368         SetColumnWidth (col, m_ColumnManager.GetWidth (col, true));\r
1369 \r
1370     SetRedraw(TRUE);\r
1371         GetStatisticsString();\r
1372 \r
1373         CHeaderCtrl * pHeader = GetHeaderCtrl();\r
1374         HDITEM HeaderItem = {0};\r
1375         HeaderItem.mask = HDI_FORMAT;\r
1376         for (int i=0; i<pHeader->GetItemCount(); ++i)\r
1377         {\r
1378                 pHeader->GetItem(i, &HeaderItem);\r
1379                 HeaderItem.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);\r
1380                 pHeader->SetItem(i, &HeaderItem);\r
1381         }\r
1382         if (m_nSortedColumn)\r
1383         {\r
1384                 pHeader->GetItem(m_nSortedColumn, &HeaderItem);\r
1385                 HeaderItem.fmt |= (m_bAscending ? HDF_SORTUP : HDF_SORTDOWN);\r
1386                 pHeader->SetItem(m_nSortedColumn, &HeaderItem);\r
1387         }\r
1388 \r
1389         if (nSelectedEntry)\r
1390         {\r
1391                 SetItemState(nSelectedEntry, LVIS_SELECTED, LVIS_SELECTED);\r
1392                 EnsureVisible(nSelectedEntry, false);\r
1393         }\r
1394         else\r
1395         {\r
1396                 // Restore the item at the top of the list.\r
1397                 for (int i=0;GetTopIndex() != nTopIndex;i++)\r
1398                 {\r
1399                         if ( !EnsureVisible(nTopIndex+i,false) )\r
1400                         {\r
1401                                 break;\r
1402                         }\r
1403                 }\r
1404         }\r
1405 \r
1406         if (pApp)\r
1407                 pApp->DoWaitCursor(-1);\r
1408 \r
1409         m_bEmpty = (GetItemCount() == 0);\r
1410         Invalidate();\r
1411 #endif\r
1412 \r
1413 }\r
1414 int CGitStatusListCtrl::GetColumnIndex(int mask)\r
1415 {\r
1416         int i=0;\r
1417         for(i=0;i<32;i++)\r
1418                 if(mask&0x1)\r
1419                         return i-1;\r
1420                 else\r
1421                         mask=mask>>1;\r
1422         return -1;\r
1423 }\r
1424 void CGitStatusListCtrl::AddEntry(CTGitPath * GitPath, WORD langID, int listIndex)\r
1425 {\r
1426         static CString ponly(MAKEINTRESOURCE(IDS_STATUSLIST_PROPONLY));\r
1427         static HINSTANCE hResourceHandle(AfxGetResourceHandle());\r
1428 \r
1429         CString path = GitPath->GetGitPathString();\r
1430 \r
1431         m_bBlock = TRUE;\r
1432         TCHAR buf[100];\r
1433         int index = listIndex;\r
1434         int nCol = 1;\r
1435         CString entryname = GitPath->GetGitPathString();\r
1436         int icon_idx = 0;\r
1437 //      if (entry->isfolder)\r
1438 //              icon_idx = m_nIconFolder;\r
1439 //      else\r
1440         {\r
1441                 icon_idx = SYS_IMAGE_LIST().GetPathIconIndex(*GitPath);\r
1442         }\r
1443         // relative path\r
1444         InsertItem(index, entryname, icon_idx);\r
1445 \r
1446         this->SetItemData(index, (DWORD_PTR)GitPath);\r
1447         // SVNSLC_COLFILENAME\r
1448         SetItemText(index, nCol++, GitPath->GetFileOrDirectoryName());\r
1449         // SVNSLC_COLEXT\r
1450         SetItemText(index, nCol++, GitPath->GetFileExtension());\r
1451         // SVNSLC_COLSTATUS\r
1452         SetItemText(index, nCol++, GitPath->GetActionName());\r
1453 \r
1454         SetItemText(index, GetColumnIndex(SVNSLC_COLADD),GitPath->m_StatAdd);\r
1455         SetItemText(index, GetColumnIndex(SVNSLC_COLDEL),GitPath->m_StatDel);\r
1456 \r
1457 \r
1458         SetCheck(index, GitPath->m_Checked);\r
1459         if (GitPath->m_Checked)\r
1460                 m_nSelected++;\r
1461 \r
1462 \r
1463         if( GitPath->m_Action & CTGitPath::LOGACTIONS_IGNORE)\r
1464                 SetItemGroup(index, 2);\r
1465         else if( GitPath->m_Action & CTGitPath::LOGACTIONS_UNVER)\r
1466                 SetItemGroup(index,1);\r
1467         else\r
1468                 SetItemGroup(index,0);\r
1469         m_bBlock = FALSE;\r
1470 \r
1471 \r
1472 }\r
1473 #if 0\r
1474 void CGitStatusListCtrl::AddEntry(FileEntry * entry, WORD langID, int listIndex)\r
1475 {\r
1476         static CString ponly(MAKEINTRESOURCE(IDS_STATUSLIST_PROPONLY));\r
1477         static HINSTANCE hResourceHandle(AfxGetResourceHandle());\r
1478 \r
1479         CString path = entry->GetPath().GetGitPathString();\r
1480         if ( m_mapFilenameToChecked.size()!=0 && m_mapFilenameToChecked.find(path) != m_mapFilenameToChecked.end() )\r
1481         {\r
1482                 // The user manually de-/selected an item. We now restore this status\r
1483                 // when refreshing.\r
1484                 entry->checked = m_mapFilenameToChecked[path];\r
1485         }\r
1486 \r
1487         m_bBlock = TRUE;\r
1488         TCHAR buf[100];\r
1489         int index = listIndex;\r
1490         int nCol = 1;\r
1491         CString entryname = entry->GetDisplayName();\r
1492         int icon_idx = 0;\r
1493         if (entry->isfolder)\r
1494                 icon_idx = m_nIconFolder;\r
1495         else\r
1496         {\r
1497                 icon_idx = SYS_IMAGE_LIST().GetPathIconIndex(entry->path);\r
1498         }\r
1499         // relative path\r
1500         InsertItem(index, entryname, icon_idx);\r
1501         // SVNSLC_COLFILENAME\r
1502         SetItemText(index, nCol++, entry->path.GetFileOrDirectoryName());\r
1503         // SVNSLC_COLEXT\r
1504         SetItemText(index, nCol++, entry->path.GetFileExtension());\r
1505         // SVNSLC_COLSTATUS\r
1506         if (entry->isNested)\r
1507         {\r
1508                 CString sTemp(MAKEINTRESOURCE(IDS_STATUSLIST_NESTED));\r
1509                 SetItemText(index, nCol++, sTemp);\r
1510         }\r
1511         else\r
1512         {\r
1513                 GitStatus::GetStatusString(hResourceHandle, entry->status, buf, sizeof(buf)/sizeof(TCHAR), (WORD)langID);\r
1514                 if ((entry->copied)&&(_tcslen(buf)>1))\r
1515                         _tcscat_s(buf, 100, _T(" (+)"));\r
1516                 if ((entry->switched)&&(_tcslen(buf)>1))\r
1517                         _tcscat_s(buf, 100, _T(" (s)"));\r
1518 #if 0\r
1519                 if ((entry->status == entry->propstatus)&&\r
1520                         (entry->status != git_wc_status_normal)&&\r
1521                         (entry->status != git_wc_status_unversioned)&&\r
1522                         (!GitStatus::IsImportant(entry->textstatus)))\r
1523                         _tcscat_s(buf, 100, ponly);\r
1524 #endif\r
1525                 SetItemText(index, nCol++, buf);\r
1526         }\r
1527         // SVNSLC_COLREMOTESTATUS\r
1528         if (entry->isNested)\r
1529         {\r
1530                 CString sTemp(MAKEINTRESOURCE(IDS_STATUSLIST_NESTED));\r
1531                 SetItemText(index, nCol++, sTemp);\r
1532         }\r
1533         else\r
1534         {\r
1535 #if 0\r
1536                 SVNStatus::GetStatusString(hResourceHandle, entry->remotestatus, buf, sizeof(buf)/sizeof(TCHAR), (WORD)langID);\r
1537                 if ((entry->copied)&&(_tcslen(buf)>1))\r
1538                         _tcscat_s(buf, 100, _T(" (+)"));\r
1539                 if ((entry->switched)&&(_tcslen(buf)>1))\r
1540                         _tcscat_s(buf, 100, _T(" (s)"));\r
1541                 if ((entry->remotestatus == entry->remotepropstatus)&&\r
1542                         (entry->remotestatus != git_wc_status_none)&&\r
1543                         (entry->remotestatus != git_wc_status_normal)&&\r
1544                         (entry->remotestatus != git_wc_status_unversioned)&&\r
1545                         (!SVNStatus::IsImportant(entry->remotetextstatus)))\r
1546                         _tcscat_s(buf, 100, ponly);\r
1547 #endif\r
1548                 SetItemText(index, nCol++, buf);\r
1549         }\r
1550         // SVNSLC_COLTEXTSTATUS\r
1551         if (entry->isNested)\r
1552         {\r
1553                 CString sTemp(MAKEINTRESOURCE(IDS_STATUSLIST_NESTED));\r
1554                 SetItemText(index, nCol++, sTemp);\r
1555         }\r
1556         else\r
1557         {\r
1558 #if 0\r
1559                 SVNStatus::GetStatusString(hResourceHandle, entry->textstatus, buf, sizeof(buf)/sizeof(TCHAR), (WORD)langID);\r
1560                 if ((entry->copied)&&(_tcslen(buf)>1))\r
1561                         _tcscat_s(buf, 100, _T(" (+)"));\r
1562                 if ((entry->switched)&&(_tcslen(buf)>1))\r
1563                         _tcscat_s(buf, 100, _T(" (s)"));\r
1564 #endif\r
1565                 SetItemText(index, nCol++, buf);\r
1566         }\r
1567         // SVNSLC_COLPROPSTATUS\r
1568         if (entry->isNested)\r
1569         {\r
1570                 SetItemText(index, nCol++, _T(""));\r
1571         }\r
1572         else\r
1573         {\r
1574 #if 0\r
1575                 SVNStatus::GetStatusString(hResourceHandle, entry->propstatus, buf, sizeof(buf)/sizeof(TCHAR), (WORD)langID);\r
1576                 if ((entry->copied)&&(_tcslen(buf)>1))\r
1577                         _tcscat_s(buf, 100, _T(" (+)"));\r
1578                 if ((entry->switched)&&(_tcslen(buf)>1))\r
1579                         _tcscat_s(buf, 100, _T(" (s)"));\r
1580 #endif\r
1581                 SetItemText(index, nCol++, buf);\r
1582         }\r
1583         // SVNSLC_COLREMOTETEXT\r
1584         if (entry->isNested)\r
1585         {\r
1586                 SetItemText(index, nCol++, _T(""));\r
1587         }\r
1588         else\r
1589         {\r
1590 #if 0\r
1591                 SVNStatus::GetStatusString(hResourceHandle, entry->remotetextstatus, buf, sizeof(buf)/sizeof(TCHAR), (WORD)langID);\r
1592                 SetItemText(index, nCol++, buf);\r
1593 #endif\r
1594         }\r
1595         // SVNSLC_COLREMOTEPROP\r
1596         if (entry->isNested)\r
1597         {\r
1598                 SetItemText(index, nCol++, _T(""));\r
1599         }\r
1600         else\r
1601         {\r
1602 //              SVNStatus::GetStatusString(hResourceHandle, entry->remotepropstatus, buf, sizeof(buf)/sizeof(TCHAR), (WORD)langID);\r
1603                 SetItemText(index, nCol++, buf);\r
1604         }\r
1605         // SVNSLC_COLURL\r
1606 //      SetItemText(index, nCol++, entry->url);\r
1607         // SVNSLC_COLLOCK\r
1608 #if 0\r
1609         if (!m_HeadRev.IsHead())\r
1610         {\r
1611                 // we have contacted the repository\r
1612 \r
1613                 // decision-matrix\r
1614                 // wc           repository              text\r
1615                 // ""           ""                              ""\r
1616                 // ""           UID1                    owner\r
1617                 // UID1         UID1                    owner\r
1618                 // UID1         ""                              lock has been broken\r
1619                 // UID1         UID2                    lock has been stolen\r
1620                 if (entry->lock_token.IsEmpty() || (entry->lock_token.Compare(entry->lock_remotetoken)==0))\r
1621                 {\r
1622                         if (entry->lock_owner.IsEmpty())\r
1623                                 SetItemText(index, nCol++, entry->lock_remoteowner);\r
1624                         else\r
1625                                 SetItemText(index, nCol++, entry->lock_owner);\r
1626                 }\r
1627                 else if (entry->lock_remotetoken.IsEmpty())\r
1628                 {\r
1629                         // broken lock\r
1630                         CString temp(MAKEINTRESOURCE(IDS_STATUSLIST_LOCKBROKEN));\r
1631                         SetItemText(index, nCol++, temp);\r
1632                 }\r
1633                 else\r
1634                 {\r
1635                         // stolen lock\r
1636                         CString temp;\r
1637                         temp.Format(IDS_STATUSLIST_LOCKSTOLEN, (LPCTSTR)entry->lock_remoteowner);\r
1638                         SetItemText(index, nCol++, temp);\r
1639                 }\r
1640         }\r
1641         else\r
1642                 SetItemText(index, nCol++, entry->lock_owner);\r
1643         // SVNSLC_COLLOCKCOMMENT\r
1644         SetItemText(index, nCol++, entry->lock_comment);\r
1645         // SVNSLC_COLAUTHOR\r
1646         SetItemText(index, nCol++, entry->last_commit_author);\r
1647         // SVNSLC_COLREVISION\r
1648         CString temp;\r
1649         temp.Format(_T("%ld"), entry->last_commit_rev);\r
1650         if (entry->last_commit_rev > 0)\r
1651                 SetItemText(index, nCol++, temp);\r
1652         else\r
1653                 SetItemText(index, nCol++, _T(""));\r
1654         // SVNSLC_COLREMOTEREVISION\r
1655         temp.Format(_T("%ld"), entry->remoterev);\r
1656         if (entry->remoterev > 0)\r
1657                 SetItemText(index, nCol++, temp);\r
1658         else\r
1659                 SetItemText(index, nCol++, _T(""));\r
1660         // SVNSLC_COLDATE\r
1661         TCHAR datebuf[SVN_DATE_BUFFER];\r
1662         apr_time_t date = entry->last_commit_date;\r
1663         SVN::formatDate(datebuf, date, true);\r
1664         if (date)\r
1665                 SetItemText(index, nCol++, datebuf);\r
1666         else\r
1667                 SetItemText(index, nCol++, _T(""));\r
1668         // SVNSLC_COLSVNNEEDSLOCK\r
1669     BOOL bFoundSVNNeedsLock = entry->present_props.IsNeedsLockSet();\r
1670         CString strSVNNeedsLock = (bFoundSVNNeedsLock) ? _T("*") : _T("");\r
1671         SetItemText(index, nCol++, strSVNNeedsLock);\r
1672         // SVNSLC_COLCOPYFROM\r
1673         if (m_sURL.Compare(entry->copyfrom_url.Left(m_sURL.GetLength()))==0)\r
1674                 temp = entry->copyfrom_url.Mid(m_sURL.GetLength());\r
1675         else\r
1676                 temp = entry->copyfrom_url;\r
1677         SetItemText(index, nCol++, temp);\r
1678         // SVNSLC_COLMODIFICATIONDATE\r
1679         __int64 filetime = entry->GetPath().GetLastWriteTime();\r
1680         if ( (filetime) && (entry->status!=git_wc_status_deleted) )\r
1681         {\r
1682                 FILETIME* f = (FILETIME*)(__int64*)&filetime;\r
1683                 TCHAR datebuf[SVN_DATE_BUFFER];\r
1684                 SVN::formatDate(datebuf,*f,true);\r
1685                 SetItemText(index, nCol++, datebuf);\r
1686         }\r
1687         else\r
1688         {\r
1689                 SetItemText(index, nCol++, _T(""));\r
1690         }\r
1691 \r
1692     // user-defined properties\r
1693     for ( int i = SVNSLC_NUMCOLUMNS, count = m_ColumnManager.GetColumnCount()\r
1694         ; i < count\r
1695         ; ++i)\r
1696     {\r
1697         assert (i == nCol++);\r
1698         assert (m_ColumnManager.IsUserProp (i));\r
1699 \r
1700         CString name = m_ColumnManager.GetName(i);\r
1701         if (entry->present_props.HasProperty (name))\r
1702                 {\r
1703                         const CString& propVal = entry->present_props [name];\r
1704                         if (propVal.IsEmpty())\r
1705                                 SetItemText(index, i, m_sNoPropValueText);\r
1706                         else\r
1707                                 SetItemText(index, i, propVal);\r
1708                 }\r
1709                 else\r
1710             SetItemText(index, i, _T(""));\r
1711     }\r
1712 \r
1713         SetCheck(index, entry->checked);\r
1714         if (entry->checked)\r
1715                 m_nSelected++;\r
1716         if (m_changelists.find(entry->changelist) != m_changelists.end())\r
1717                 SetItemGroup(index, m_changelists[entry->changelist]);\r
1718         else\r
1719                 SetItemGroup(index, 0);\r
1720         m_bBlock = FALSE;\r
1721 #endif\r
1722 }\r
1723 #endif\r
1724 bool CGitStatusListCtrl::SetItemGroup(int item, int groupindex)\r
1725 {\r
1726         if ((m_dwContextMenus & SVNSLC_POPCHANGELISTS) == NULL)\r
1727                 return false;\r
1728         if (groupindex < 0)\r
1729                 return false;\r
1730         LVITEM i = {0};\r
1731         i.mask = LVIF_GROUPID;\r
1732         i.iItem = item;\r
1733         i.iSubItem = 0;\r
1734         i.iGroupId = groupindex;\r
1735 \r
1736         return !!SetItem(&i);\r
1737 }\r
1738 \r
1739 void CGitStatusListCtrl::Sort()\r
1740 {\r
1741         Locker lock(m_critSec);\r
1742 \r
1743     CSorter predicate (&m_ColumnManager, m_nSortedColumn, m_bAscending);\r
1744 \r
1745         std::sort(m_arStatusArray.begin(), m_arStatusArray.end(), predicate);\r
1746         SaveColumnWidths();\r
1747         Show(m_dwShow, 0, m_bShowFolders);\r
1748 \r
1749 }\r
1750 \r
1751 void CGitStatusListCtrl::OnHdnItemclick(NMHDR *pNMHDR, LRESULT *pResult)\r
1752 {\r
1753         LPNMHEADER phdr = reinterpret_cast<LPNMHEADER>(pNMHDR);\r
1754         *pResult = 0;\r
1755         if (m_bBlock)\r
1756                 return;\r
1757         m_bBlock = TRUE;\r
1758         if (m_nSortedColumn == phdr->iItem)\r
1759                 m_bAscending = !m_bAscending;\r
1760         else\r
1761                 m_bAscending = TRUE;\r
1762         m_nSortedColumn = phdr->iItem;\r
1763         m_mapFilenameToChecked.clear();\r
1764         Sort();\r
1765 \r
1766         CHeaderCtrl * pHeader = GetHeaderCtrl();\r
1767         HDITEM HeaderItem = {0};\r
1768         HeaderItem.mask = HDI_FORMAT;\r
1769         for (int i=0; i<pHeader->GetItemCount(); ++i)\r
1770         {\r
1771                 pHeader->GetItem(i, &HeaderItem);\r
1772                 HeaderItem.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);\r
1773                 pHeader->SetItem(i, &HeaderItem);\r
1774         }\r
1775         pHeader->GetItem(m_nSortedColumn, &HeaderItem);\r
1776         HeaderItem.fmt |= (m_bAscending ? HDF_SORTUP : HDF_SORTDOWN);\r
1777         pHeader->SetItem(m_nSortedColumn, &HeaderItem);\r
1778 \r
1779         // the checked state of the list control items must be restored\r
1780 \r
1781         for (int i=0; i<GetItemCount(); ++i)\r
1782         {\r
1783                 CTGitPath * entry = (CTGitPath*)GetItemData(i);\r
1784                 SetCheck(i, entry->m_Checked);\r
1785         }\r
1786 \r
1787         m_bBlock = FALSE;\r
1788 }\r
1789 \r
1790 void CGitStatusListCtrl::OnLvnItemchanging(NMHDR *pNMHDR, LRESULT *pResult)\r
1791 {\r
1792         LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);\r
1793         *pResult = 0;\r
1794 \r
1795 #define ISCHECKED(x) ((x) ? ((((x)&LVIS_STATEIMAGEMASK)>>12)-1) : FALSE)\r
1796         if ((m_bBlock)&&(m_bBlockUI))\r
1797         {\r
1798                 // if we're blocked, prevent changing of the check state\r
1799                 if ((!ISCHECKED(pNMLV->uOldState) && ISCHECKED(pNMLV->uNewState))||\r
1800                         (ISCHECKED(pNMLV->uOldState) && !ISCHECKED(pNMLV->uNewState)))\r
1801                         *pResult = TRUE;\r
1802         }\r
1803 }\r
1804 \r
1805 BOOL CGitStatusListCtrl::OnLvnItemchanged(NMHDR *pNMHDR, LRESULT *pResult)\r
1806 {\r
1807         LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);\r
1808         *pResult = 0;\r
1809         if ((pNMLV->uNewState==0)||(pNMLV->uNewState & LVIS_SELECTED)||(pNMLV->uNewState & LVIS_FOCUSED))\r
1810                 return FALSE;\r
1811 \r
1812         if (m_bBlock)\r
1813                 return FALSE;\r
1814 \r
1815         bool bSelected = !!(ListView_GetItemState(m_hWnd, pNMLV->iItem, LVIS_SELECTED) & LVIS_SELECTED);\r
1816         int nListItems = GetItemCount();\r
1817 \r
1818         m_bBlock = TRUE;\r
1819         // was the item checked?\r
1820         \r
1821         //CTGitPath *gitpath=(CTGitPath*)GetItemData(pNMLV->iItem);\r
1822         //gitpath->m_Checked=GetCheck(pNMLV->iItem);\r
1823 \r
1824         if (GetCheck(pNMLV->iItem))\r
1825         {\r
1826                 CheckEntry(pNMLV->iItem, nListItems);\r
1827                 if (bSelected)\r
1828                 {\r
1829                         POSITION pos = GetFirstSelectedItemPosition();\r
1830                         int index;\r
1831                         while ((index = GetNextSelectedItem(pos)) >= 0)\r
1832                         {\r
1833                                 if (index != pNMLV->iItem)\r
1834                                         CheckEntry(index, nListItems);\r
1835                         }\r
1836                 }\r
1837         }\r
1838         else\r
1839         {\r
1840                 UncheckEntry(pNMLV->iItem, nListItems);\r
1841                 if (bSelected)\r
1842                 {\r
1843                         POSITION pos = GetFirstSelectedItemPosition();\r
1844                         int index;\r
1845                         while ((index = GetNextSelectedItem(pos)) >= 0)\r
1846                         {\r
1847                                 if (index != pNMLV->iItem)\r
1848                                         UncheckEntry(index, nListItems);\r
1849                         }\r
1850                 }\r
1851         }\r
1852 \r
1853         GetStatisticsString();\r
1854         m_bBlock = FALSE;\r
1855         NotifyCheck();\r
1856 \r
1857         return FALSE;\r
1858 }\r
1859 \r
1860 void CGitStatusListCtrl::OnColumnResized(NMHDR *pNMHDR, LRESULT *pResult)\r
1861 {\r
1862         LPNMHEADER header = reinterpret_cast<LPNMHEADER>(pNMHDR);\r
1863     if (   (header != NULL) \r
1864         && (header->iItem >= 0) \r
1865         && (header->iItem < m_ColumnManager.GetColumnCount()))\r
1866     {\r
1867         m_ColumnManager.ColumnResized (header->iItem);\r
1868     }\r
1869 \r
1870     *pResult = FALSE;\r
1871 }\r
1872 \r
1873 void CGitStatusListCtrl::OnColumnMoved(NMHDR *pNMHDR, LRESULT *pResult)\r
1874 {\r
1875         LPNMHEADER header = reinterpret_cast<LPNMHEADER>(pNMHDR);\r
1876         *pResult = TRUE;\r
1877     if (   (header != NULL) \r
1878         && (header->iItem >= 0) \r
1879         && (header->iItem < m_ColumnManager.GetColumnCount())\r
1880                 // only allow the reordering if the column was not moved left of the first\r
1881                 // visible item - otherwise the 'invisible' columns are not at the far left\r
1882                 // anymore and we get all kinds of redrawing problems.\r
1883                 && (header->pitem)\r
1884                 && (header->pitem->iOrder > m_ColumnManager.GetInvisibleCount()))\r
1885     {\r
1886         m_ColumnManager.ColumnMoved (header->iItem, header->pitem->iOrder);\r
1887                 *pResult = FALSE;\r
1888     }\r
1889 \r
1890     Invalidate(FALSE);\r
1891 }\r
1892 \r
1893 void CGitStatusListCtrl::CheckEntry(int index, int nListItems)\r
1894 {\r
1895         Locker lock(m_critSec);\r
1896         //FileEntry * entry = GetListEntry(index);\r
1897         CTGitPath *path=(CTGitPath*)GetItemData(index);\r
1898         ASSERT(path != NULL);\r
1899         if (path == NULL)\r
1900                 return;\r
1901         SetCheck(index, TRUE);\r
1902         //entry = GetListEntry(index);\r
1903         // if an unversioned item was checked, then we need to check if\r
1904         // the parent folders are unversioned too. If the parent folders actually\r
1905         // are unversioned, then check those too.\r
1906 #if 0\r
1907         if (entry->status == git_wc_status_unversioned)\r
1908         {\r
1909                 // we need to check the parent folder too\r
1910                 const CTGitPath& folderpath = entry->path;\r
1911                 for (int i=0; i< nListItems; ++i)\r
1912                 {\r
1913                         FileEntry * testEntry = GetListEntry(i);\r
1914                         ASSERT(testEntry != NULL);\r
1915                         if (testEntry == NULL)\r
1916                                 continue;\r
1917                         if (!testEntry->checked)\r
1918                         {\r
1919                                 if (testEntry->path.IsAncestorOf(folderpath) && (!testEntry->path.IsEquivalentTo(folderpath)))\r
1920                                 {\r
1921                                         SetEntryCheck(testEntry,i,true);\r
1922                                         m_nSelected++;\r
1923                                 }\r
1924                         }\r
1925                 }\r
1926         }\r
1927         bool bShift = !!(GetAsyncKeyState(VK_SHIFT) & 0x8000);\r
1928         if ( (entry->status == git_wc_status_deleted) || (m_bCheckChildrenWithParent) || (bShift) )\r
1929         {\r
1930                 // if a deleted folder gets checked, we have to check all\r
1931                 // children of that folder too.\r
1932                 if (entry->path.IsDirectory())\r
1933                 {\r
1934                         SetCheckOnAllDescendentsOf(entry, true);\r
1935                 }\r
1936 \r
1937                 // if a deleted file or folder gets checked, we have to\r
1938                 // check all parents of this item too.\r
1939                 for (int i=0; i<nListItems; ++i)\r
1940                 {\r
1941                         FileEntry * testEntry = GetListEntry(i);\r
1942                         ASSERT(testEntry != NULL);\r
1943                         if (testEntry == NULL)\r
1944                                 continue;\r
1945                         if (!testEntry->checked)\r
1946                         {\r
1947                                 if (testEntry->path.IsAncestorOf(entry->path) && (!testEntry->path.IsEquivalentTo(entry->path)))\r
1948                                 {\r
1949                                         if ((testEntry->status == git_wc_status_deleted)||(m_bCheckChildrenWithParent))\r
1950                                         {\r
1951                                                 SetEntryCheck(testEntry,i,true);\r
1952                                                 m_nSelected++;\r
1953                                                 // now we need to check all children of this parent folder\r
1954                                                 SetCheckOnAllDescendentsOf(testEntry, true);\r
1955                                         }\r
1956                                 }\r
1957                         }\r
1958                 }\r
1959         }\r
1960 #endif\r
1961         if ( !path->m_Checked )\r
1962         {\r
1963                 path->m_Checked = TRUE;\r
1964                 m_nSelected++;\r
1965         }\r
1966 }\r
1967 \r
1968 void CGitStatusListCtrl::UncheckEntry(int index, int nListItems)\r
1969 {\r
1970         Locker lock(m_critSec);\r
1971         CTGitPath *path=(CTGitPath*)GetItemData(index);\r
1972         ASSERT(path != NULL);\r
1973         if (path == NULL)\r
1974                 return;\r
1975         SetCheck(index, FALSE);\r
1976         //entry = GetListEntry(index);\r
1977         // item was unchecked\r
1978 #if 0\r
1979         if (entry->path.IsDirectory())\r
1980         {\r
1981                 // disable all files within an unselected folder, except when unchecking a folder with property changes\r
1982                 bool bShift = !!(GetAsyncKeyState(VK_SHIFT) & 0x8000);\r
1983                 if ( (entry->status != git_wc_status_modified) || (bShift) )\r
1984                 {\r
1985                         SetCheckOnAllDescendentsOf(entry, false);\r
1986                 }\r
1987         }\r
1988         else if (entry->status == git_wc_status_deleted)\r
1989         {\r
1990                 // a "deleted" file was unchecked, so uncheck all parent folders\r
1991                 // and all children of those parents\r
1992                 for (int i=0; i<nListItems; i++)\r
1993                 {\r
1994                         FileEntry * testEntry = GetListEntry(i);\r
1995                         ASSERT(testEntry != NULL);\r
1996                         if (testEntry == NULL)\r
1997                                 continue;\r
1998                         if (testEntry->checked)\r
1999                         {\r
2000                                 if (testEntry->path.IsAncestorOf(entry->path))\r
2001                                 {\r
2002                                         if (testEntry->status == git_wc_status_deleted)\r
2003                                         {\r
2004                                                 SetEntryCheck(testEntry,i,false);\r
2005                                                 m_nSelected--;\r
2006 \r
2007                                                 SetCheckOnAllDescendentsOf(testEntry, false);\r
2008                                         }\r
2009                                 }\r
2010                         }\r
2011                 }\r
2012         }\r
2013 #endif\r
2014         if ( path->m_Checked )\r
2015         {\r
2016                 path->m_Checked  = FALSE;\r
2017                 m_nSelected--;\r
2018         }\r
2019 }\r
2020 #if 0\r
2021 bool CGitStatusListCtrl::EntryPathCompareNoCase(const FileEntry* pEntry1, const FileEntry* pEntry2)\r
2022 {\r
2023         return pEntry1->path < pEntry2->path;\r
2024 }\r
2025 \r
2026 bool CGitStatusListCtrl::IsEntryVersioned(const FileEntry* pEntry1)\r
2027 {\r
2028         return pEntry1->status != git_wc_status_unversioned;\r
2029 }\r
2030 #endif\r
2031 bool CGitStatusListCtrl::BuildStatistics()\r
2032 {\r
2033 \r
2034         bool bRefetchStatus = false;\r
2035 \r
2036         // now gather some statistics\r
2037         m_nUnversioned = 0;\r
2038         m_nNormal = 0;\r
2039         m_nModified = 0;\r
2040         m_nAdded = 0;\r
2041         m_nDeleted = 0;\r
2042         m_nConflicted = 0;\r
2043         m_nTotal = 0;\r
2044         m_nSelected = 0;\r
2045         \r
2046         for (int i=0; i < (int)m_arStatusArray.size(); ++i)\r
2047         {\r
2048                 int status=((CTGitPath*)m_arStatusArray[i])->m_Action;\r
2049 \r
2050                 if(status&CTGitPath::LOGACTIONS_ADDED)\r
2051                         m_nAdded++;\r
2052                 \r
2053                 if(status&CTGitPath::LOGACTIONS_DELETED)\r
2054                         m_nDeleted++;\r
2055                 \r
2056                 if(status&(CTGitPath::LOGACTIONS_REPLACED|CTGitPath::LOGACTIONS_MODIFIED))\r
2057                         m_nModified++;\r
2058                 \r
2059                 if(status&CTGitPath::LOGACTIONS_CONFLICT)\r
2060                         m_nConflicted++;\r
2061                 \r
2062                 if(status&(CTGitPath::LOGACTIONS_IGNORE|CTGitPath::LOGACTIONS_UNVER))\r
2063                         m_nUnversioned++;\r
2064         \r
2065         \r
2066 \r
2067 //                      } // switch (entry->status)\r
2068 //              } // if (entry)\r
2069         } // for (int i=0; i < (int)m_arStatusArray.size(); ++i)\r
2070         return !bRefetchStatus;\r
2071 \r
2072         return FALSE;\r
2073 }\r
2074 \r
2075 void CGitStatusListCtrl::GetMinMaxRevisions(git_revnum_t& rMin, git_revnum_t& rMax, bool bShownOnly, bool bCheckedOnly)\r
2076 {\r
2077 #if 0\r
2078         Locker lock(m_critSec);\r
2079         rMin = LONG_MAX;\r
2080         rMax = 0;\r
2081 \r
2082         if ((bShownOnly)||(bCheckedOnly))\r
2083         {\r
2084                 for (int i=0; i<GetItemCount(); ++i)\r
2085                 {\r
2086                         const FileEntry * entry = GetListEntry(i);\r
2087 \r
2088                         if ((entry)&&(entry->last_commit_rev))\r
2089                         {\r
2090                                 if ((!bCheckedOnly)||(entry->IsChecked()))\r
2091                                 {\r
2092                                         if (entry->last_commit_rev >= 0)\r
2093                                         {\r
2094                                                 rMin = min(rMin, entry->last_commit_rev);\r
2095                                                 rMax = max(rMax, entry->last_commit_rev);\r
2096                                         }\r
2097                                 }\r
2098                         }\r
2099                 }\r
2100         }\r
2101         else\r
2102         {\r
2103                 for (int i=0; i < (int)m_arStatusArray.size(); ++i)\r
2104                 {\r
2105                         const FileEntry * entry = m_arStatusArray[i];\r
2106                         if ((entry)&&(entry->last_commit_rev))\r
2107                         {\r
2108                                 if (entry->last_commit_rev >= 0)\r
2109                                 {\r
2110                                         rMin = min(rMin, entry->last_commit_rev);\r
2111                                         rMax = max(rMax, entry->last_commit_rev);\r
2112                                 }\r
2113                         }\r
2114                 }\r
2115         }\r
2116         if (rMin == LONG_MAX)\r
2117                 rMin = 0;\r
2118 #endif\r
2119 }\r
2120 \r
2121 int CGitStatusListCtrl::GetGroupFromPoint(POINT * ppt)\r
2122 {\r
2123         // the point must be relative to the upper left corner of the control\r
2124 \r
2125         if (ppt == NULL)\r
2126                 return -1;\r
2127         if (!IsGroupViewEnabled())\r
2128                 return -1;\r
2129 \r
2130         POINT pt = *ppt;\r
2131         pt.x = 10;\r
2132         UINT flags = 0;\r
2133         int nItem = -1;\r
2134         RECT rc;\r
2135         GetWindowRect(&rc);\r
2136         while (((flags & LVHT_BELOW) == 0)&&(pt.y < rc.bottom))\r
2137         {\r
2138                 nItem = HitTest(pt, &flags);\r
2139                 if ((flags & LVHT_ONITEM)||(flags & LVHT_EX_GROUP_HEADER))\r
2140                 {\r
2141                         // the first item below the point\r
2142 \r
2143                         // check if the point is too much right (i.e. if the point\r
2144                         // is farther to the right than the width of the item)\r
2145                         RECT r;\r
2146                         GetItemRect(nItem, &r, LVIR_LABEL);\r
2147                         if (ppt->x > r.right)\r
2148                                 return -1;\r
2149 \r
2150                         LVITEM lv = {0};\r
2151                         lv.mask = LVIF_GROUPID;\r
2152                         lv.iItem = nItem;\r
2153                         GetItem(&lv);\r
2154                         int groupID = lv.iGroupId;\r
2155                         // now we search upwards and check if the item above this one\r
2156                         // belongs to another group. If it belongs to the same group,\r
2157                         // we're not over a group header\r
2158                         while (pt.y >= 0)\r
2159                         {\r
2160                                 pt.y -= 2;\r
2161                                 nItem = HitTest(pt, &flags);\r
2162                                 if ((flags & LVHT_ONITEM)&&(nItem >= 0))\r
2163                                 {\r
2164                                         // the first item below the point\r
2165                                         LVITEM lv = {0};\r
2166                                         lv.mask = LVIF_GROUPID;\r
2167                                         lv.iItem = nItem;\r
2168                                         GetItem(&lv);\r
2169                                         if (lv.iGroupId != groupID)\r
2170                                                 return groupID;\r
2171                                         else\r
2172                                                 return -1;\r
2173                                 }\r
2174                         }\r
2175                         if (pt.y < 0)\r
2176                                 return groupID;\r
2177                         return -1;\r
2178                 }\r
2179                 pt.y += 2;\r
2180         };\r
2181         return -1;\r
2182 }\r
2183 \r
2184 void CGitStatusListCtrl::OnContextMenuGroup(CWnd * /*pWnd*/, CPoint point)\r
2185 {\r
2186         POINT clientpoint = point;\r
2187         ScreenToClient(&clientpoint);\r
2188         if ((IsGroupViewEnabled())&&(GetGroupFromPoint(&clientpoint) >= 0))\r
2189         {\r
2190                 CMenu popup;\r
2191                 if (popup.CreatePopupMenu())\r
2192                 {\r
2193                         CString temp;\r
2194                         temp.LoadString(IDS_STATUSLIST_CHECKGROUP);\r
2195                         popup.AppendMenu(MF_STRING | MF_ENABLED, IDSVNLC_CHECKGROUP, temp);\r
2196                         temp.LoadString(IDS_STATUSLIST_UNCHECKGROUP);\r
2197                         popup.AppendMenu(MF_STRING | MF_ENABLED, IDSVNLC_UNCHECKGROUP, temp);\r
2198                         int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this, 0);\r
2199                         bool bCheck = false;\r
2200                         switch (cmd)\r
2201                         {\r
2202                         case IDSVNLC_CHECKGROUP:\r
2203                                 bCheck = true;\r
2204                                 // fall through here\r
2205                         case IDSVNLC_UNCHECKGROUP:\r
2206                                 {\r
2207                                         int group = GetGroupFromPoint(&clientpoint);\r
2208                                         // go through all items and check/uncheck those assigned to the group\r
2209                                         // but block the OnLvnItemChanged handler\r
2210                                         m_bBlock = true;\r
2211                                         LVITEM lv;\r
2212                                         for (int i=0; i<GetItemCount(); ++i)\r
2213                                         {\r
2214                                                 SecureZeroMemory(&lv, sizeof(LVITEM));\r
2215                                                 lv.mask = LVIF_GROUPID;\r
2216                                                 lv.iItem = i;\r
2217                                                 GetItem(&lv);\r
2218 #if 0\r
2219                                                 if (lv.iGroupId == group)\r
2220                                                 {\r
2221                                                         FileEntry * entry = GetListEntry(i);\r
2222                                                         if (entry)\r
2223                                                         {\r
2224                                                                 bool bOldCheck = !!GetCheck(i);\r
2225                                                                 //SetEntryCheck(entry, i, bCheck);\r
2226                                                                 if (bCheck != bOldCheck)\r
2227                                                                 {\r
2228                                                                         if (bCheck)\r
2229                                                                                 m_nSelected++;\r
2230                                                                         else\r
2231                                                                                 m_nSelected--;\r
2232                                                                 }\r
2233                                                         }\r
2234                                                 }\r
2235 #endif\r
2236                                         }\r
2237                                         GetStatisticsString();\r
2238                                         NotifyCheck();\r
2239                                         m_bBlock = false;\r
2240                                 }\r
2241                                 break;\r
2242                         }\r
2243                 }\r
2244         }\r
2245 }\r
2246 \r
2247 void CGitStatusListCtrl::OnContextMenuList(CWnd * pWnd, CPoint point)\r
2248 {\r
2249 \r
2250         WORD langID = (WORD)CRegStdWORD(_T("Software\\TortoiseGit\\LanguageID"), GetUserDefaultLangID());\r
2251 \r
2252         bool XPorLater = false;\r
2253         OSVERSIONINFOEX inf;\r
2254         SecureZeroMemory(&inf, sizeof(OSVERSIONINFOEX));\r
2255         inf.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);\r
2256         GetVersionEx((OSVERSIONINFO *)&inf);\r
2257         WORD fullver = MAKEWORD(inf.dwMinorVersion, inf.dwMajorVersion);\r
2258         if (fullver >= 0x0501)\r
2259                 XPorLater = true;\r
2260         bool bShift = !!(GetAsyncKeyState(VK_SHIFT) & 0x8000);\r
2261         CTGitPath * filepath;\r
2262 \r
2263         int selIndex = GetSelectionMark();\r
2264         if ((point.x == -1) && (point.y == -1))\r
2265         {\r
2266                 CRect rect;\r
2267                 GetItemRect(selIndex, &rect, LVIR_LABEL);\r
2268                 ClientToScreen(&rect);\r
2269                 point = rect.CenterPoint();\r
2270         }\r
2271         if ((GetSelectedCount() == 0)&&(XPorLater)&&(m_bHasCheckboxes))\r
2272         {\r
2273                 // nothing selected could mean the context menu is requested for\r
2274                 // a group header\r
2275                 OnContextMenuGroup(pWnd, point);\r
2276         }\r
2277         else if (selIndex >= 0)\r
2278         {\r
2279                 //FileEntry * entry = GetListEntry(selIndex);\r
2280 \r
2281                 filepath = (CTGitPath * )GetItemData(selIndex);\r
2282 \r
2283                 ASSERT(filepath != NULL);\r
2284                 if (filepath == NULL)\r
2285                         return;\r
2286 \r
2287                 //const CTGitPath& filepath = entry->path;\r
2288                 int wcStatus = filepath->m_Action;\r
2289                 // entry is selected, now show the popup menu\r
2290                 Locker lock(m_critSec);\r
2291                 CIconMenu popup;\r
2292                 CMenu changelistSubMenu;\r
2293                 CMenu ignoreSubMenu;\r
2294                 if (popup.CreatePopupMenu())\r
2295                 {\r
2296                         //Add Menu for verion controled file\r
2297                         if (!(wcStatus &CTGitPath::LOGACTIONS_UNVER))\r
2298                         {\r
2299                                 if (m_dwContextMenus & SVNSLC_POPCOMPAREWITHBASE)\r
2300                                 {\r
2301                                         popup.AppendMenuIcon(IDSVNLC_COMPARE, IDS_LOG_COMPAREWITHBASE, IDI_DIFF);\r
2302                                         popup.SetDefaultItem(IDSVNLC_COMPARE, FALSE);\r
2303                                 }\r
2304                                 //Select one items\r
2305                                 if (GetSelectedCount() == 1)\r
2306                                 {\r
2307                                         bool bEntryAdded = false;\r
2308                                         //if (entry->remotestatus <= git_wc_status_normal)\r
2309                                         //{\r
2310                                         //      if (wcStatus > git_wc_status_normal)\r
2311                                         //      {\r
2312                                         //              if ((m_dwContextMenus & SVNSLC_POPGNUDIFF)&&(wcStatus != git_wc_status_deleted)&&(wcStatus != git_wc_status_missing))\r
2313                                         //              {\r
2314                                         if(!g_Git.IsInitRepos())\r
2315                                                 popup.AppendMenuIcon(IDSVNLC_GNUDIFF1, IDS_LOG_POPUP_GNUDIFF, IDI_DIFF);\r
2316 \r
2317                                         bEntryAdded = true;\r
2318                                         //              }\r
2319                                         //      }\r
2320                                         //\r
2321                                         //}\r
2322                                         //else if (wcStatus != git_wc_status_deleted)\r
2323                                         //{\r
2324                                         //      if (m_dwContextMenus & SVNSLC_POPCOMPARE)\r
2325                                         //      {\r
2326                                         //              popup.AppendMenuIcon(IDSVNLC_COMPAREWC, IDS_LOG_POPUP_COMPARE, IDI_DIFF);\r
2327                                         //              popup.SetDefaultItem(IDSVNLC_COMPARE, FALSE);\r
2328                                         //              bEntryAdded = true;\r
2329                                         //      }\r
2330                                         //      if (m_dwContextMenus & SVNSLC_POPGNUDIFF)\r
2331                                         //      {\r
2332                                         //              popup.AppendMenuIcon(IDSVNLC_GNUDIFF1, IDS_LOG_POPUP_GNUDIFF, IDI_DIFF);\r
2333                                         //              bEntryAdded = true;\r
2334                                         //      }\r
2335                                         //}\r
2336                                         if (bEntryAdded)\r
2337                                                 popup.AppendMenu(MF_SEPARATOR);\r
2338                                 }\r
2339                                 //else if (GetSelectedCount() > 1)  \r
2340                                 //{\r
2341                                 //      if (m_dwContextMenus & SVNSLC_POPCOMMIT)\r
2342                                 //      {\r
2343                                 //              popup.AppendMenuIcon(IDSVNLC_COMMIT, IDS_STATUSLIST_CONTEXT_COMMIT, IDI_COMMIT);\r
2344                                 //              popup.SetDefaultItem(IDSVNLC_COMPARE, FALSE);\r
2345                                 //      }\r
2346                                 //}\r
2347                         }\r
2348                         \r
2349                         ///Select Multi item\r
2350                         //if (GetSelectedCount() > 0)\r
2351                         //{\r
2352                         //      if ((GetSelectedCount() == 2)&&(m_dwContextMenus & SVNSLC_POPREPAIRMOVE))\r
2353                         //      {\r
2354                         //              POSITION pos = GetFirstSelectedItemPosition();\r
2355                         //              int index = GetNextSelectedItem(pos);\r
2356                         //              if (index >= 0)\r
2357                         //              {\r
2358                         //                      FileEntry * entry = GetListEntry(index);\r
2359                         //                      git_wc_status_kind status1 = git_wc_status_none;\r
2360                         //                      git_wc_status_kind status2 = git_wc_status_none;\r
2361                         //                      if (entry)\r
2362                         //                              status1 = entry->status;\r
2363                         //                      index = GetNextSelectedItem(pos);\r
2364                         //                      if (index >= 0)\r
2365                         //                      {\r
2366                         //                              entry = GetListEntry(index);\r
2367                         //                              if (entry)\r
2368                         //                                      status2 = entry->status;\r
2369                         //                              if ((status1 == git_wc_status_missing && status2 == git_wc_status_unversioned) ||\r
2370                         //                                      (status2 == git_wc_status_missing && status1 == git_wc_status_unversioned))\r
2371                         //                              {\r
2372                         //                                      popup.AppendMenuIcon(IDSVNLC_REPAIRMOVE, IDS_STATUSLIST_CONTEXT_REPAIRMOVE);\r
2373                         //                              }\r
2374                         //                      }\r
2375                         //              }\r
2376                         //      }\r
2377                         //      if (wcStatus > git_wc_status_normal)\r
2378                         //      {\r
2379                         //              if (m_dwContextMenus & SVNSLC_POPREVERT)\r
2380                         //              {\r
2381                         //                      // reverting missing folders is not possible\r
2382                         //                      if (!entry->IsFolder() || (wcStatus != git_wc_status_missing))\r
2383                         //                      {\r
2384                         //                              popup.AppendMenuIcon(IDSVNLC_REVERT, IDS_MENUREVERT, IDI_REVERT);\r
2385                         //                      }\r
2386                         //              }\r
2387                         //      }\r
2388                         //      if (entry->remotestatus > git_wc_status_normal)\r
2389                         //      {\r
2390                         //              if (m_dwContextMenus & SVNSLC_POPUPDATE)\r
2391                         //              {\r
2392                         //                      popup.AppendMenuIcon(IDSVNLC_UPDATE, IDS_MENUUPDATE, IDI_UPDATE);\r
2393                         //              }\r
2394                         //      }\r
2395                         //}\r
2396                         if ((GetSelectedCount() == 1)&&(!wcStatus & CTGitPath::LOGACTIONS_UNVER)\r
2397                                 &&(!wcStatus & CTGitPath::LOGACTIONS_IGNORE))\r
2398                         {\r
2399                                 if (m_dwContextMenus & SVNSLC_POPSHOWLOG)\r
2400                                 {\r
2401                                         popup.AppendMenuIcon(IDSVNLC_LOG, IDS_REPOBROWSE_SHOWLOG, IDI_LOG);\r
2402                                 }\r
2403 //                              if (m_dwContextMenus & SVNSLC_POPBLAME)\r
2404 //                              {\r
2405 //                                      popup.AppendMenuIcon(IDSVNLC_BLAME, IDS_MENUBLAME, IDI_BLAME);\r
2406 //                              }\r
2407                         }\r
2408 //                      if ((wcStatus != git_wc_status_deleted)&&(wcStatus != git_wc_status_missing) && (GetSelectedCount() == 1))\r
2409 //                      {\r
2410                                 if (m_dwContextMenus & SVNSLC_POPOPEN)\r
2411                                 {\r
2412                                         popup.AppendMenuIcon(IDSVNLC_OPEN, IDS_REPOBROWSE_OPEN, IDI_OPEN);\r
2413                                         popup.AppendMenuIcon(IDSVNLC_OPENWITH, IDS_LOG_POPUP_OPENWITH, IDI_OPEN);\r
2414                                 }\r
2415                                 if (m_dwContextMenus & SVNSLC_POPEXPLORE)\r
2416                                 {\r
2417                                         popup.AppendMenuIcon(IDSVNLC_EXPLORE, IDS_STATUSLIST_CONTEXT_EXPLORE, IDI_EXPLORER);\r
2418                                 }\r
2419 //                      }\r
2420                         if (GetSelectedCount() > 0)\r
2421                         {\r
2422 //                              if (((wcStatus == git_wc_status_unversioned)||(wcStatus == git_wc_status_ignored))&&(m_dwContextMenus & SVNSLC_POPDELETE))\r
2423 //                              {\r
2424 //                                      popup.AppendMenuIcon(IDSVNLC_DELETE, IDS_MENUREMOVE, IDI_DELETE);\r
2425 //                              }\r
2426 //                              if ((wcStatus != Git_wc_status_unversioned)&&(wcStatus != git_wc_status_ignored)&&(wcStatus != Git_wc_status_deleted)&&(wcStatus != Git_wc_status_added)&&(m_dwContextMenus & GitSLC_POPDELETE))\r
2427 //                              {\r
2428 //                                      if (bShift)\r
2429 //                                              popup.AppendMenuIcon(IDGitLC_REMOVE, IDS_MENUREMOVEKEEP, IDI_DELETE);\r
2430 //                                      else\r
2431 //                                              popup.AppendMenuIcon(IDGitLC_REMOVE, IDS_MENUREMOVE, IDI_DELETE);\r
2432 //                              }\r
2433                                 if ((wcStatus & CTGitPath::LOGACTIONS_UNVER)/*||(wcStatus == git_wc_status_deleted)*/)\r
2434                                 {\r
2435                                         if (m_dwContextMenus & SVNSLC_POPADD)\r
2436                                         {\r
2437                                                 //if ( entry->IsFolder() )\r
2438                                                 //{\r
2439                                                 //      popup.AppendMenuIcon(IDSVNLC_ADD_RECURSIVE, IDS_STATUSLIST_CONTEXT_ADD_RECURSIVE, IDI_ADD);\r
2440                                                 //}\r
2441                                                 //else\r
2442                                                 {\r
2443                                                         popup.AppendMenuIcon(IDSVNLC_ADD, IDS_STATUSLIST_CONTEXT_ADD, IDI_ADD);\r
2444                                                 }\r
2445                                         }\r
2446                                 //}\r
2447                                 //if ( (wcStatus == git_wc_status_unversioned) || (wcStatus == git_wc_status_deleted) )\r
2448                                 //{\r
2449                                         if (m_dwContextMenus & SVNSLC_POPIGNORE)\r
2450                                         {\r
2451 \r
2452                                                 CTGitPathList ignorelist;\r
2453                                                 FillListOfSelectedItemPaths(ignorelist);\r
2454                                                 //check if all selected entries have the same extension\r
2455                                                 bool bSameExt = true;\r
2456                                                 CString sExt;\r
2457                                                 for (int i=0; i<ignorelist.GetCount(); ++i)\r
2458                                                 {\r
2459                                                         if (sExt.IsEmpty() && (i==0))\r
2460                                                                 sExt = ignorelist[i].GetFileExtension();\r
2461                                                         else if (sExt.CompareNoCase(ignorelist[i].GetFileExtension())!=0)\r
2462                                                                 bSameExt = false;\r
2463                                                 }\r
2464                                                 if (bSameExt)\r
2465                                                 {\r
2466                                                         if (ignoreSubMenu.CreateMenu())\r
2467                                                         {\r
2468                                                                 CString ignorepath;\r
2469                                                                 if (ignorelist.GetCount()==1)\r
2470                                                                         ignorepath = ignorelist[0].GetFileOrDirectoryName();\r
2471                                                                 else\r
2472                                                                         ignorepath.Format(IDS_MENUIGNOREMULTIPLE, ignorelist.GetCount());\r
2473                                                                 ignoreSubMenu.AppendMenu(MF_STRING | MF_ENABLED, IDSVNLC_IGNORE, ignorepath);\r
2474                                                                 ignorepath = _T("*")+sExt;\r
2475                                                                 ignoreSubMenu.AppendMenu(MF_STRING | MF_ENABLED, IDSVNLC_IGNOREMASK, ignorepath);\r
2476                                                                 CString temp;\r
2477                                                                 temp.LoadString(IDS_MENUIGNORE);\r
2478                                                                 popup.InsertMenu((UINT)-1, MF_BYPOSITION | MF_POPUP, (UINT_PTR)ignoreSubMenu.m_hMenu, temp);\r
2479                                                         }\r
2480                                                 }\r
2481                                                 else\r
2482                                                 {\r
2483                                                         CString temp;\r
2484                                                         if (ignorelist.GetCount()==1)\r
2485                                                         {\r
2486                                                                 temp.LoadString(IDS_MENUIGNORE);\r
2487                                                         }\r
2488                                                         else\r
2489                                                         {\r
2490                                                                 temp.Format(IDS_MENUIGNOREMULTIPLE, ignorelist.GetCount());\r
2491                                                         }\r
2492                                                         popup.AppendMenuIcon(IDSVNLC_IGNORE, temp, IDI_IGNORE);\r
2493                                                 }\r
2494                                         }\r
2495                                 }\r
2496                         }\r
2497 #if 0\r
2498                         if (((wcStatus == git_wc_status_conflicted)||(entry->isConflicted)))\r
2499                         {\r
2500                                 if ((m_dwContextMenus & SVNSLC_POPCONFLICT)||(m_dwContextMenus & SVNSLC_POPRESOLVE))\r
2501                                         popup.AppendMenu(MF_SEPARATOR);\r
2502 \r
2503                                 if ((m_dwContextMenus & SVNSLC_POPCONFLICT)&&(entry->textstatus == git_wc_status_conflicted))\r
2504                                 {\r
2505                                         popup.AppendMenuIcon(IDSVNLC_EDITCONFLICT, IDS_MENUCONFLICT, IDI_CONFLICT);\r
2506                                 }\r
2507                                 if (m_dwContextMenus & SVNSLC_POPRESOLVE)\r
2508                                 {\r
2509                                         popup.AppendMenuIcon(IDSVNLC_RESOLVECONFLICT, IDS_STATUSLIST_CONTEXT_RESOLVED, IDI_RESOLVE);\r
2510                                 }\r
2511                                 if ((m_dwContextMenus & SVNSLC_POPRESOLVE)&&(entry->textstatus == git_wc_status_conflicted))\r
2512                                 {\r
2513                                         popup.AppendMenuIcon(IDSVNLC_RESOLVETHEIRS, IDS_SVNPROGRESS_MENUUSETHEIRS, IDI_RESOLVE);\r
2514                                         popup.AppendMenuIcon(IDSVNLC_RESOLVEMINE, IDS_SVNPROGRESS_MENUUSEMINE, IDI_RESOLVE);\r
2515                                 }\r
2516                         }\r
2517 #endif\r
2518 #if 0                   \r
2519                         if (GetSelectedCount() > 0)\r
2520                         {\r
2521 \r
2522                                 if ((!entry->IsFolder())&&(wcStatus >= git_wc_status_normal)\r
2523                                         &&(wcStatus!=git_wc_status_missing)&&(wcStatus!=git_wc_status_deleted)\r
2524                                         &&(wcStatus!=git_wc_status_added))\r
2525                                 {\r
2526                                         popup.AppendMenu(MF_SEPARATOR);\r
2527                                         if ((entry->lock_token.IsEmpty())&&(!entry->IsFolder()))\r
2528                                         {\r
2529                                                 if (m_dwContextMenus & SVNSLC_POPLOCK)\r
2530                                                 {\r
2531                                                         popup.AppendMenuIcon(IDSVNLC_LOCK, IDS_MENU_LOCK, IDI_LOCK);\r
2532                                                 }\r
2533                                         }\r
2534                                         if ((!entry->lock_token.IsEmpty())&&(!entry->IsFolder()))\r
2535                                         {\r
2536                                                 if (m_dwContextMenus & SVNSLC_POPUNLOCK)\r
2537                                                 {\r
2538                                                         popup.AppendMenuIcon(IDSVNLC_UNLOCK, IDS_MENU_UNLOCK, IDI_UNLOCK);\r
2539                                                 }\r
2540                                         }\r
2541                                 }\r
2542 \r
2543                                 if ((!entry->IsFolder())&&((!entry->lock_token.IsEmpty())||(!entry->lock_remotetoken.IsEmpty())))\r
2544                                 {\r
2545                                         if (m_dwContextMenus & SVNSLC_POPUNLOCKFORCE)\r
2546                                         {\r
2547                                                 popup.AppendMenuIcon(IDSVNLC_UNLOCKFORCE, IDS_MENU_UNLOCKFORCE, IDI_UNLOCK);\r
2548                                         }\r
2549                                 }\r
2550 \r
2551                                 if (wcStatus != git_wc_status_missing && wcStatus != git_wc_status_deleted &&wcStatus!=git_wc_status_unversioned)\r
2552                                 {\r
2553                                         popup.AppendMenu(MF_SEPARATOR);\r
2554                                         popup.AppendMenuIcon(IDSVNLC_PROPERTIES, IDS_STATUSLIST_CONTEXT_PROPERTIES, IDI_PROPERTIES);\r
2555                                 }\r
2556                                 popup.AppendMenu(MF_SEPARATOR);\r
2557                                 popup.AppendMenuIcon(IDSVNLC_COPY, IDS_STATUSLIST_CONTEXT_COPY, IDI_COPYCLIP);\r
2558                                 popup.AppendMenuIcon(IDSVNLC_COPYEXT, IDS_STATUSLIST_CONTEXT_COPYEXT, IDI_COPYCLIP);\r
2559                                 if ((m_dwContextMenus & SVNSLC_POPCHANGELISTS)&&(XPorLater)\r
2560                                         &&(wcStatus != git_wc_status_unversioned)&&(wcStatus != git_wc_status_none))\r
2561                                 {\r
2562                                         popup.AppendMenu(MF_SEPARATOR);\r
2563                                         // changelist commands\r
2564                                         size_t numChangelists = GetNumberOfChangelistsInSelection();\r
2565                                         if (numChangelists > 0)\r
2566                                         {\r
2567                                                 popup.AppendMenuIcon(IDSVNLC_REMOVEFROMCS, IDS_STATUSLIST_CONTEXT_REMOVEFROMCS);\r
2568                                         }\r
2569                                         if ((!entry->IsFolder())&&(changelistSubMenu.CreateMenu()))\r
2570                                         {\r
2571                                                 CString temp;\r
2572                                                 temp.LoadString(IDS_STATUSLIST_CONTEXT_CREATECS);\r
2573                                                 changelistSubMenu.AppendMenu(MF_STRING | MF_ENABLED, IDSVNLC_CREATECS, temp);\r
2574 \r
2575                                                 if (entry->changelist.Compare(SVNSLC_IGNORECHANGELIST))\r
2576                                                 {\r
2577                                                         changelistSubMenu.AppendMenu(MF_SEPARATOR);\r
2578                                                         changelistSubMenu.AppendMenu(MF_STRING | MF_ENABLED, IDSVNLC_CREATEIGNORECS, SVNSLC_IGNORECHANGELIST);\r
2579                                                 }\r
2580 \r
2581                                                 if (m_changelists.size() > 0)\r
2582                                                 {\r
2583                                                         // find the changelist names\r
2584                                                         bool bNeedSeparator = true;\r
2585                                                         int cmdID = IDSVNLC_MOVETOCS;\r
2586                                                         for (std::map<CString, int>::const_iterator it = m_changelists.begin(); it != m_changelists.end(); ++it)\r
2587                                                         {\r
2588                                                                 if ((entry->changelist.Compare(it->first))&&(it->first.Compare(SVNSLC_IGNORECHANGELIST)))\r
2589                                                                 {\r
2590                                                                         if (bNeedSeparator)\r
2591                                                                         {\r
2592                                                                                 changelistSubMenu.AppendMenu(MF_SEPARATOR);\r
2593                                                                                 bNeedSeparator = false;\r
2594                                                                         }\r
2595                                                                         changelistSubMenu.AppendMenu(MF_STRING | MF_ENABLED, cmdID, it->first);\r
2596                                                                         cmdID++;\r
2597                                                                 }\r
2598                                                         }\r
2599                                                 }\r
2600                                                 temp.LoadString(IDS_STATUSLIST_CONTEXT_MOVETOCS);\r
2601                                                 popup.AppendMenu(MF_POPUP|MF_STRING, (UINT_PTR)changelistSubMenu.GetSafeHmenu(), temp);\r
2602                                         }\r
2603                                 }\r
2604                         }\r
2605 #endif\r
2606                         int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this, 0);\r
2607 \r
2608                         m_bBlock = TRUE;\r
2609                         AfxGetApp()->DoWaitCursor(1);\r
2610                         int iItemCountBeforeMenuCmd = GetItemCount();\r
2611                         bool bForce = false;\r
2612                         switch (cmd)\r
2613                         {\r
2614                         case IDSVNLC_OPEN:\r
2615                                 {\r
2616                                         CString file;\r
2617                                         if(this->m_CurrentVersion.IsEmpty() || m_CurrentVersion == GIT_REV_ZERO)\r
2618                                         {\r
2619                                                 file= filepath->GetWinPath();\r
2620                                         }else\r
2621                                         {\r
2622                                                 CString temppath;\r
2623                                                 GetTempPath(temppath);\r
2624                                                 file.Format(_T("%s%s_%s%s"),\r
2625                                                         temppath,                                               \r
2626                                                         filepath->GetBaseFilename(),\r
2627                                                         m_CurrentVersion.Left(6),\r
2628                                                         filepath->GetFileExtension());\r
2629 \r
2630                                         }\r
2631                                         int ret = (int)ShellExecute(this->m_hWnd, NULL,file, NULL, NULL, SW_SHOW);\r
2632                                         if (ret <= HINSTANCE_ERROR)\r
2633                                         {\r
2634                                                 CString cmd = _T("RUNDLL32 Shell32,OpenAs_RunDLL ");\r
2635                                                 cmd += file;\r
2636                                                 CAppUtils::LaunchApplication(cmd, NULL, false);\r
2637                                         }\r
2638                                 }\r
2639                                 break;\r
2640                         case IDSVNLC_OPENWITH:\r
2641                                 {\r
2642                                         CString file;\r
2643                                         if(m_CurrentVersion.IsEmpty() || m_CurrentVersion == GIT_REV_ZERO)\r
2644                                         {\r
2645                                                 file= filepath->GetWinPath();\r
2646                                         }else\r
2647                                         {\r
2648                                                 CString temppath;\r
2649                                                 GetTempPath(temppath);\r
2650                                                 file.Format(_T("%s%s_%s%s"),\r
2651                                                         temppath,                                               \r
2652                                                         filepath->GetBaseFilename(),\r
2653                                                         m_CurrentVersion.Left(6),\r
2654                                                         filepath->GetFileExtension());\r
2655 \r
2656                                         }\r
2657 \r
2658                                         CString cmd = _T("RUNDLL32 Shell32,OpenAs_RunDLL ");\r
2659                                         cmd += file + _T(" ");\r
2660                                         CAppUtils::LaunchApplication(cmd, NULL, false);\r
2661                                 }\r
2662                                 break;\r
2663                         case IDSVNLC_EXPLORE:\r
2664                                 {\r
2665                                         ShellExecute(this->m_hWnd, _T("explore"), filepath->GetWinPath(), NULL, NULL, SW_SHOW);\r
2666                                 }\r
2667                                 break;\r
2668                         case IDSVNLC_COMPARE:\r
2669                                 {\r
2670                                         POSITION pos = GetFirstSelectedItemPosition();\r
2671                                         while ( pos )\r
2672                                         {\r
2673                                                 int index = GetNextSelectedItem(pos);\r
2674                                                 StartDiff(index);\r
2675                                         }\r
2676                                 }\r
2677                                 break;\r
2678                         case IDSVNLC_GNUDIFF1:\r
2679                                 {\r
2680                                 //      SVNDiff diff(NULL, this->m_hWnd, true);\r
2681                                 //\r
2682                                 //      if (entry->remotestatus <= git_wc_status_normal)\r
2683                                 //              CAppUtils::StartShowUnifiedDiff(m_hWnd, entry->path, SVNRev::REV_BASE, entry->path, SVNRev::REV_WC);\r
2684                                 //      else\r
2685                                 //              CAppUtils::StartShowUnifiedDiff(m_hWnd, entry->path, SVNRev::REV_WC, entry->path, SVNRev::REV_HEAD);\r
2686                                         if(m_CurrentVersion.IsEmpty() || m_CurrentVersion == GIT_REV_ZERO)\r
2687                                                 CAppUtils::StartShowUnifiedDiff(m_hWnd,*filepath,GitRev::GetWorkingCopy(),\r
2688                                                                                                                         *filepath,GitRev::GetHead());\r
2689                                         else\r
2690                                                 CAppUtils::StartShowUnifiedDiff(m_hWnd,*filepath,m_CurrentVersion,\r
2691                                                                                                                         *filepath,m_CurrentVersion+_T("~1"));\r
2692                                 }\r
2693                                 break;\r
2694                         case IDSVNLC_ADD:\r
2695                                 {       // The add went ok, but we now need to run through the selected items again\r
2696                                         // and update their status\r
2697                                         POSITION pos = GetFirstSelectedItemPosition();\r
2698                                         int index;\r
2699                                         while ((index = GetNextSelectedItem(pos)) >= 0)\r
2700                                         {\r
2701                                                 CTGitPath * path=(CTGitPath*)GetItemData(index);\r
2702                                                 CString cmd;\r
2703                                                 cmd.Format(_T("git.exe add %s"),path->GetGitPathString());\r
2704                                                 CString output;\r
2705                                                 if(!g_Git.Run(cmd,&output))\r
2706                                                 {\r
2707                                                         path->m_Action = CTGitPath::LOGACTIONS_ADDED;\r
2708                                                         SetEntryCheck(path,index,true);\r
2709                                                         SetItemGroup(index,0);\r
2710                                                         this->m_StatusFileList.AddPath(*path);\r
2711                                                         this->m_UnRevFileList.RemoveItem(*path);\r
2712                                                         this->m_IgnoreFileList.RemoveItem(*path);\r
2713                                                         Show(this->m_dwShow,0,true,true);\r
2714                                                 }\r
2715                                         }\r
2716                                         \r
2717                                 }\r
2718                                 break;\r
2719 #if 0\r
2720                         case IDSVNLC_COPY:\r
2721                                 CopySelectedEntriesToClipboard(0);\r
2722                                 break;\r
2723                         case IDSVNLC_COPYEXT:\r
2724                                 CopySelectedEntriesToClipboard((DWORD)-1);\r
2725                                 break;\r
2726                         case IDSVNLC_PROPERTIES:\r
2727                                 {\r
2728                                         CTSVNPathList targetList;\r
2729                                         FillListOfSelectedItemPaths(targetList);\r
2730                                         CEditPropertiesDlg dlg;\r
2731                                         dlg.SetPathList(targetList);\r
2732                                         dlg.DoModal();\r
2733                                         if (dlg.HasChanged())\r
2734                                         {\r
2735                                                 // since the user might have changed/removed/added\r
2736                                                 // properties recursively, we don't really know\r
2737                                                 // which items have changed their status.\r
2738                                                 // So tell the parent to do a refresh.\r
2739                                                 CWnd* pParent = GetParent();\r
2740                                                 if (NULL != pParent && NULL != pParent->GetSafeHwnd())\r
2741                                                 {\r
2742                                                         pParent->SendMessage(SVNSLNM_NEEDSREFRESH);\r
2743                                                 }\r
2744                                         }\r
2745                                 }\r
2746                                 break;\r
2747                         case IDSVNLC_COMMIT:\r
2748                                 {\r
2749                                         CTSVNPathList targetList;\r
2750                                         FillListOfSelectedItemPaths(targetList);\r
2751                                         CTSVNPath tempFile = CTempFiles::Instance().GetTempFilePath(false);\r
2752                                         VERIFY(targetList.WriteToFile(tempFile.GetWinPathString()));\r
2753                                         CString commandline = CPathUtils::GetAppDirectory();\r
2754                                         commandline += _T("TortoiseProc.exe /command:commit /pathfile:\"");\r
2755                                         commandline += tempFile.GetWinPathString();\r
2756                                         commandline += _T("\"");\r
2757                                         commandline += _T(" /deletepathfile");\r
2758                                         CAppUtils::LaunchApplication(commandline, NULL, false);\r
2759                                 }\r
2760                                 break;\r
2761                         case IDSVNLC_REVERT:\r
2762                                 {\r
2763                                         // If at least one item is not in the status "added"\r
2764                                         // we ask for a confirmation\r
2765                                         BOOL bConfirm = FALSE;\r
2766                                         POSITION pos = GetFirstSelectedItemPosition();\r
2767                                         int index;\r
2768                                         while ((index = GetNextSelectedItem(pos)) >= 0)\r
2769                                         {\r
2770                                                 FileEntry * fentry = GetListEntry(index);\r
2771                                                 if (fentry->textstatus != git_wc_status_added)\r
2772                                                 {\r
2773                                                         bConfirm = TRUE;\r
2774                                                         break;\r
2775                                                 }\r
2776                                         }       \r
2777 \r
2778                                         CString str;\r
2779                                         str.Format(IDS_PROC_WARNREVERT,GetSelectedCount());\r
2780 \r
2781                                         if (!bConfirm || CMessageBox::Show(this->m_hWnd, str, _T("TortoiseSVN"), MB_YESNO | MB_ICONQUESTION)==IDYES)\r
2782                                         {\r
2783                                                 CTSVNPathList targetList;\r
2784                                                 FillListOfSelectedItemPaths(targetList);\r
2785 \r
2786                                                 // make sure that the list is reverse sorted, so that\r
2787                                                 // children are removed before any parents\r
2788                                                 targetList.SortByPathname(true);\r
2789 \r
2790                                                 SVN git;\r
2791 \r
2792                                                 // put all reverted files in the trashbin, except the ones with 'added'\r
2793                                                 // status because they are not restored by the revert.\r
2794                                                 CTSVNPathList delList;\r
2795                                                 POSITION pos = GetFirstSelectedItemPosition();\r
2796                                                 int index;\r
2797                                                 while ((index = GetNextSelectedItem(pos)) >= 0)\r
2798                                                 {\r
2799                                                         FileEntry * entry = GetListEntry(index);\r
2800                                                         if (entry->status != git_wc_status_added)\r
2801                                                                 delList.AddPath(entry->GetPath());\r
2802                                                 }\r
2803                                                 if (DWORD(CRegDWORD(_T("Software\\TortoiseSVN\\RevertWithRecycleBin"), TRUE)))\r
2804                                                         delList.DeleteAllFiles(true);\r
2805 \r
2806                                                 if (!git.Revert(targetList, CStringArray(), FALSE))\r
2807                                                 {\r
2808                                                         CMessageBox::Show(this->m_hWnd, git.GetLastErrorMessage(), _T("TortoiseSVN"), MB_ICONERROR);\r
2809                                                 }\r
2810                                                 else\r
2811                                                 {\r
2812                                                         // since the entries got reverted we need to remove\r
2813                                                         // them from the list too, if no remote changes are shown,\r
2814                                                         // if the unmodified files are not shown\r
2815                                                         // and if the item is not part of a changelist\r
2816                                                         POSITION pos;\r
2817                                                         SetRedraw(FALSE);\r
2818                                                         while ((pos = GetFirstSelectedItemPosition())!=0)\r
2819                                                         {\r
2820                                                                 int index;\r
2821                                                                 index = GetNextSelectedItem(pos);\r
2822                                                                 FileEntry * fentry = m_arStatusArray[m_arListArray[index]];\r
2823                                                                 if ( fentry->IsFolder() )\r
2824                                                                 {\r
2825                                                                         // refresh!\r
2826                                                                         CWnd* pParent = GetParent();\r
2827                                                                         if (NULL != pParent && NULL != pParent->GetSafeHwnd())\r
2828                                                                         {\r
2829                                                                                 pParent->SendMessage(SVNSLNM_NEEDSREFRESH);\r
2830                                                                         }\r
2831                                                                         break;\r
2832                                                                 }\r
2833 \r
2834                                                                 BOOL bAdded = (fentry->textstatus == git_wc_status_added);\r
2835                                                                 fentry->status = git_wc_status_normal;\r
2836                                                                 fentry->propstatus = git_wc_status_normal;\r
2837                                                                 fentry->textstatus = git_wc_status_normal;\r
2838                                                                 fentry->copied = false;\r
2839                                                                 fentry->isConflicted = false;\r
2840                                                                 if ((fentry->GetChangeList().IsEmpty()&&(fentry->remotestatus <= git_wc_status_normal))||(m_dwShow & SVNSLC_SHOWNORMAL))\r
2841                                                                 {\r
2842                                                                         if ( bAdded )\r
2843                                                                         {\r
2844                                                                                 // reverting added items makes them unversioned, not 'normal'\r
2845                                                                                 if (fentry->IsFolder())\r
2846                                                                                         fentry->propstatus = git_wc_status_none;\r
2847                                                                                 else\r
2848                                                                                         fentry->propstatus = git_wc_status_unversioned;\r
2849                                                                                 fentry->status = git_wc_status_unversioned;\r
2850                                                                                 fentry->textstatus = git_wc_status_unversioned;\r
2851                                                                                 SetItemState(index, 0, LVIS_SELECTED);\r
2852                                                                                 SetEntryCheck(fentry, index, false);\r
2853                                                                         }\r
2854                                                                         else if ((fentry->switched)||(m_dwShow & SVNSLC_SHOWNORMAL))\r
2855                                                                         {\r
2856                                                                                 SetItemState(index, 0, LVIS_SELECTED);\r
2857                                                                         }\r
2858                                                                         else\r
2859                                                                         {\r
2860                                                                                 m_nTotal--;\r
2861                                                                                 if (GetCheck(index))\r
2862                                                                                         m_nSelected--;\r
2863                                                                                 RemoveListEntry(index);\r
2864                                                                                 Invalidate();\r
2865                                                                         }\r
2866                                                                 }\r
2867                                                                 else\r
2868                                                                 {\r
2869                                                                         SetItemState(index, 0, LVIS_SELECTED);\r
2870                                                                 }\r
2871                                                         }\r
2872                                                         SetRedraw(TRUE);\r
2873                                                         SaveColumnWidths();\r
2874                                                         Show(m_dwShow, 0, m_bShowFolders);\r
2875                                                         NotifyCheck();\r
2876                                                 }\r
2877                                         }\r
2878                                 }\r
2879                                 break;\r
2880                         case IDSVNLC_COMPARE:\r
2881                                 {\r
2882                                         POSITION pos = GetFirstSelectedItemPosition();\r
2883                                         while ( pos )\r
2884                                         {\r
2885                                                 int index = GetNextSelectedItem(pos);\r
2886                                                 StartDiff(index);\r
2887                                         }\r
2888                                 }\r
2889                                 break;\r
2890                         case IDSVNLC_COMPAREWC:\r
2891                                 {\r
2892                                         POSITION pos = GetFirstSelectedItemPosition();\r
2893                                         while ( pos )\r
2894                                         {\r
2895                                                 int index = GetNextSelectedItem(pos);\r
2896                                                 FileEntry * entry = GetListEntry(index);\r
2897                                                 ASSERT(entry != NULL);\r
2898                                                 if (entry == NULL)\r
2899                                                         continue;\r
2900                                                 SVNDiff diff(NULL, m_hWnd, true);\r
2901                                                 diff.SetAlternativeTool(!!(GetAsyncKeyState(VK_SHIFT) & 0x8000));\r
2902                                                 git_revnum_t baseRev = entry->Revision;\r
2903                                                 diff.DiffFileAgainstBase(\r
2904                                                         entry->path, baseRev, entry->textstatus, entry->propstatus);\r
2905                                         }\r
2906                                 }\r
2907                                 break;\r
2908                         case IDSVNLC_GNUDIFF1:\r
2909                                 {\r
2910                                         SVNDiff diff(NULL, this->m_hWnd, true);\r
2911 \r
2912                                         if (entry->remotestatus <= git_wc_status_normal)\r
2913                                                 CAppUtils::StartShowUnifiedDiff(m_hWnd, entry->path, SVNRev::REV_BASE, entry->path, SVNRev::REV_WC);\r
2914                                         else\r
2915                                                 CAppUtils::StartShowUnifiedDiff(m_hWnd, entry->path, SVNRev::REV_WC, entry->path, SVNRev::REV_HEAD);\r
2916                                 }\r
2917                                 break;\r
2918                         case IDSVNLC_UPDATE:\r
2919                                 {\r
2920                                         CTSVNPathList targetList;\r
2921                                         FillListOfSelectedItemPaths(targetList);\r
2922                                         bool bAllExist = true;\r
2923                                         for (int i=0; i<targetList.GetCount(); ++i)\r
2924                                         {\r
2925                                                 if (!targetList[i].Exists())\r
2926                                                 {\r
2927                                                         bAllExist = false;\r
2928                                                         break;\r
2929                                                 }\r
2930                                         }\r
2931                                         if (bAllExist)\r
2932                                         {\r
2933                                                 CSVNProgressDlg dlg;\r
2934                                                 dlg.SetCommand(CSVNProgressDlg::SVNProgress_Update);\r
2935                                                 dlg.SetPathList(targetList);\r
2936                                                 dlg.SetRevision(SVNRev::REV_HEAD);\r
2937                                                 dlg.DoModal();\r
2938                                         }\r
2939                                         else\r
2940                                         {\r
2941                                                 CString sTempFile = CTempFiles::Instance().GetTempFilePath(false).GetWinPathString();\r
2942                                                 targetList.WriteToFile(sTempFile, false);\r
2943                                                 CString sCmd;\r
2944                                                 sCmd.Format(_T("\"%s\" /command:update /rev /pathfile:\"%s\" /deletepathfile"),\r
2945                                                         (LPCTSTR)(CPathUtils::GetAppDirectory()+_T("TortoiseProc.exe")), (LPCTSTR)sTempFile);\r
2946 \r
2947                                                 CAppUtils::LaunchApplication(sCmd, NULL, false);\r
2948                                         }\r
2949                                 }\r
2950                                 break;\r
2951                         case IDSVNLC_LOG:\r
2952                                 {\r
2953                                         CString sCmd;\r
2954                                         sCmd.Format(_T("\"%s\" /command:log /path:\"%s\""),\r
2955                                                 (LPCTSTR)(CPathUtils::GetAppDirectory()+_T("TortoiseProc.exe")), filepath.GetWinPath());\r
2956 \r
2957                                         if (!filepath.IsUrl())\r
2958                                         {\r
2959                                                 sCmd += _T(" /propspath:\"");\r
2960                                                 sCmd += filepath.GetWinPathString();\r
2961                                                 sCmd += _T("\"");\r
2962                                         }       \r
2963 \r
2964                                         CAppUtils::LaunchApplication(sCmd, NULL, false);\r
2965                                 }\r
2966                                 break;\r
2967                         case IDSVNLC_BLAME:\r
2968                                 {\r
2969                                         CString sCmd;\r
2970                                         sCmd.Format(_T("\"%s\" /command:blame /path:\"%s\""),\r
2971                                                 (LPCTSTR)(CPathUtils::GetAppDirectory()+_T("TortoiseProc.exe")), filepath.GetWinPath());\r
2972 \r
2973                                         if (!filepath.IsUrl())\r
2974                                         {\r
2975                                                 sCmd += _T(" /propspath:\"");\r
2976                                                 sCmd += filepath.GetWinPathString();\r
2977                                                 sCmd += _T("\"");\r
2978                                         }       \r
2979 \r
2980                                         CAppUtils::LaunchApplication(sCmd, NULL, false);\r
2981                                 }\r
2982                                 break;\r
2983                         case IDSVNLC_OPEN:\r
2984                                 {\r
2985                                         int ret = (int)ShellExecute(this->m_hWnd, NULL, filepath.GetWinPath(), NULL, NULL, SW_SHOW);\r
2986                                         if (ret <= HINSTANCE_ERROR)\r
2987                                         {\r
2988                                                 CString cmd = _T("RUNDLL32 Shell32,OpenAs_RunDLL ");\r
2989                                                 cmd += filepath.GetWinPathString();\r
2990                                                 CAppUtils::LaunchApplication(cmd, NULL, false);\r
2991                                         }\r
2992                                 }\r
2993                                 break;\r
2994                         case IDSVNLC_OPENWITH:\r
2995                                 {\r
2996                                         CString cmd = _T("RUNDLL32 Shell32,OpenAs_RunDLL ");\r
2997                                         cmd += filepath.GetWinPathString() + _T(" ");\r
2998                                         CAppUtils::LaunchApplication(cmd, NULL, false);\r
2999                                 }\r
3000                                 break;\r
3001                         case IDSVNLC_EXPLORE:\r
3002                                 {\r
3003                                         ShellExecute(this->m_hWnd, _T("explore"), filepath.GetDirectory().GetWinPath(), NULL, NULL, SW_SHOW);\r
3004                                 }\r
3005                                 break;\r
3006                         case IDSVNLC_REMOVE:\r
3007                                 {\r
3008                                         SVN git;\r
3009                                         CTSVNPathList itemsToRemove;\r
3010                                         FillListOfSelectedItemPaths(itemsToRemove);\r
3011 \r
3012                                         // We must sort items before removing, so that files are always removed\r
3013                                         // *before* their parents\r
3014                                         itemsToRemove.SortByPathname(true);\r
3015 \r
3016                                         bool bSuccess = false;\r
3017                                         if (git.Remove(itemsToRemove, FALSE, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000)))\r
3018                                         {\r
3019                                                 bSuccess = true;\r
3020                                         }\r
3021                                         else\r
3022                                         {\r
3023                                                 if ((git.Err->apr_err == SVN_ERR_UNVERSIONED_RESOURCE) ||\r
3024                                                         (git.Err->apr_err == SVN_ERR_CLIENT_MODIFIED))\r
3025                                                 {\r
3026                                                         CString msg, yes, no, yestoall;\r
3027                                                         msg.Format(IDS_PROC_REMOVEFORCE, (LPCTSTR)git.GetLastErrorMessage());\r
3028                                                         yes.LoadString(IDS_MSGBOX_YES);\r
3029                                                         no.LoadString(IDS_MSGBOX_NO);\r
3030                                                         yestoall.LoadString(IDS_PROC_YESTOALL);\r
3031                                                         UINT ret = CMessageBox::Show(m_hWnd, msg, _T("TortoiseSVN"), 2, IDI_ERROR, yes, no, yestoall);\r
3032                                                         if ((ret == 1)||(ret==3))\r
3033                                                         {\r
3034                                                                 if (!git.Remove(itemsToRemove, TRUE, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000)))\r
3035                                                                 {\r
3036                                                                         CMessageBox::Show(m_hWnd, git.GetLastErrorMessage(), _T("TortoiseSVN"), MB_ICONERROR);\r
3037                                                                 }\r
3038                                                                 else\r
3039                                                                         bSuccess = true;\r
3040                                                         }\r
3041                                                 }\r
3042                                                 else\r
3043                                                         CMessageBox::Show(m_hWnd, git.GetLastErrorMessage(), _T("TortoiseSVN"), MB_ICONERROR);\r
3044                                         }\r
3045                                         if (bSuccess)\r
3046                                         {\r
3047                                                 // The remove went ok, but we now need to run through the selected items again\r
3048                                                 // and update their status\r
3049                                                 POSITION pos = GetFirstSelectedItemPosition();\r
3050                                                 int index;\r
3051                                                 std::vector<int> entriesToRemove;\r
3052                                                 while ((index = GetNextSelectedItem(pos)) >= 0)\r
3053                                                 {\r
3054                                                         FileEntry * e = GetListEntry(index);\r
3055                                                         if (!bShift &&\r
3056                                                                 ((e->textstatus == git_wc_status_unversioned)||\r
3057                                                                 (e->textstatus == git_wc_status_none)||\r
3058                                                                 (e->textstatus == git_wc_status_ignored)))\r
3059                                                         {\r
3060                                                                 if (GetCheck(index))\r
3061                                                                         m_nSelected--;\r
3062                                                                 m_nTotal--;\r
3063                                                                 entriesToRemove.push_back(index);\r
3064                                                         }\r
3065                                                         else\r
3066                                                         {\r
3067                                                                 e->textstatus = git_wc_status_deleted;\r
3068                                                                 e->status = git_wc_status_deleted;\r
3069                                                                 SetEntryCheck(e,index,true);\r
3070                                                         }\r
3071                                                 }\r
3072                                                 for (std::vector<int>::reverse_iterator it = entriesToRemove.rbegin(); it != entriesToRemove.rend(); ++it)\r
3073                                                 {\r
3074                                                         RemoveListEntry(*it);\r
3075                                                 }\r
3076                                         }\r
3077                                         SaveColumnWidths();\r
3078                                         Show(m_dwShow, 0, m_bShowFolders);\r
3079                                         NotifyCheck();\r
3080                                 }\r
3081                                 break;\r
3082                         case IDSVNLC_DELETE:\r
3083                                 {\r
3084                                         CTSVNPathList pathlist;\r
3085                                         FillListOfSelectedItemPaths(pathlist);\r
3086                                         pathlist.RemoveChildren();\r
3087                                         CString filelist;\r
3088                                         for (INT_PTR i=0; i<pathlist.GetCount(); ++i)\r
3089                                         {\r
3090                                                 filelist += pathlist[i].GetWinPathString();\r
3091                                                 filelist += _T("|");\r
3092                                         }\r
3093                                         filelist += _T("|");\r
3094                                         int len = filelist.GetLength();\r
3095                                         TCHAR * buf = new TCHAR[len+2];\r
3096                                         _tcscpy_s(buf, len+2, filelist);\r
3097                                         for (int i=0; i<len; ++i)\r
3098                                                 if (buf[i] == '|')\r
3099                                                         buf[i] = 0;\r
3100                                         SHFILEOPSTRUCT fileop;\r
3101                                         fileop.hwnd = this->m_hWnd;\r
3102                                         fileop.wFunc = FO_DELETE;\r
3103                                         fileop.pFrom = buf;\r
3104                                         fileop.pTo = NULL;\r
3105                                         fileop.fFlags = FOF_NO_CONNECTED_ELEMENTS | ((GetAsyncKeyState(VK_SHIFT) & 0x8000) ? 0 : FOF_ALLOWUNDO);\r
3106                                         fileop.lpszProgressTitle = _T("deleting file");\r
3107                                         int result = SHFileOperation(&fileop);\r
3108                                         delete [] buf;\r
3109 \r
3110                                         if ( (result==0) && (!fileop.fAnyOperationsAborted) )\r
3111                                         {\r
3112                                                 SetRedraw(FALSE);\r
3113                                                 POSITION pos = NULL;\r
3114                                                 CTSVNPathList deletedlist;      // to store list of deleted folders\r
3115                                                 while ((pos = GetFirstSelectedItemPosition()) != 0)\r
3116                                                 {\r
3117                                                         int index = GetNextSelectedItem(pos);\r
3118                                                         if (GetCheck(index))\r
3119                                                                 m_nSelected--;\r
3120                                                         m_nTotal--;\r
3121                                                         FileEntry * fentry = GetListEntry(index);\r
3122                                                         if ((fentry)&&(fentry->isfolder))\r
3123                                                                 deletedlist.AddPath(fentry->path);\r
3124                                                         RemoveListEntry(index);\r
3125                                                 }\r
3126                                                 // now go through the list of deleted folders\r
3127                                                 // and remove all their children from the list too!\r
3128                                                 int nListboxEntries = GetItemCount();\r
3129                                                 for (int folderindex = 0; folderindex < deletedlist.GetCount(); ++folderindex)\r
3130                                                 {\r
3131                                                         CTSVNPath folderpath = deletedlist[folderindex];\r
3132                                                         for (int i=0; i<nListboxEntries; ++i)\r
3133                                                         {\r
3134                                                                 FileEntry * entry = GetListEntry(i);\r
3135                                                                 if (folderpath.IsAncestorOf(entry->path))\r
3136                                                                 {\r
3137                                                                         RemoveListEntry(i--);\r
3138                                                                         nListboxEntries--;\r
3139                                                                 }\r
3140                                                         }\r
3141                                                 }\r
3142                                                 SetRedraw(TRUE);\r
3143                                         }\r
3144                                 }\r
3145                                 break;\r
3146                         case IDSVNLC_IGNOREMASK:\r
3147                                 {\r
3148                                         CString name = _T("*")+filepath.GetFileExtension();\r
3149                                         CTSVNPathList ignorelist;\r
3150                                         FillListOfSelectedItemPaths(ignorelist, true);\r
3151                                         std::set<CTSVNPath> parentlist;\r
3152                                         for (int i=0; i<ignorelist.GetCount(); ++i)\r
3153                                         {\r
3154                                                 parentlist.insert(ignorelist[i].GetContainingDirectory());\r
3155                                         }\r
3156                                         std::set<CTSVNPath>::iterator it;\r
3157                                         std::vector<CString> toremove;\r
3158                                         SetRedraw(FALSE);\r
3159                                         for (it = parentlist.begin(); it != parentlist.end(); ++it)\r
3160                                         {\r
3161                                                 CTSVNPath parentFolder = (*it).GetDirectory();\r
3162                                                 SVNProperties props(parentFolder, SVNRev::REV_WC, false);\r
3163                                                 CStringA value;\r
3164                                                 for (int i=0; i<props.GetCount(); i++)\r
3165                                                 {\r
3166                                                         CString propname(props.GetItemName(i).c_str());\r
3167                                                         if (propname.CompareNoCase(_T("git:ignore"))==0)\r
3168                                                         {\r
3169                                                                 stdstring stemp;\r
3170                                                                 // treat values as normal text even if they're not\r
3171                                                                 value = (char *)props.GetItemValue(i).c_str();\r
3172                                                         }\r
3173                                                 }\r
3174                                                 if (value.IsEmpty())\r
3175                                                         value = name;\r
3176                                                 else\r
3177                                                 {\r
3178                                                         value = value.Trim("\n\r");\r
3179                                                         value += "\n";\r
3180                                                         value += name;\r
3181                                                         value.Remove('\r');\r
3182                                                 }\r
3183                                                 if (!props.Add(_T("git:ignore"), (LPCSTR)value))\r
3184                                                 {\r
3185                                                         CString temp;\r
3186                                                         temp.Format(IDS_ERR_FAILEDIGNOREPROPERTY, (LPCTSTR)name);\r
3187                                                         CMessageBox::Show(this->m_hWnd, temp, _T("TortoiseSVN"), MB_ICONERROR);\r
3188                                                 }\r
3189                                                 else\r
3190                                                 {\r
3191                                                         CTSVNPath basepath;\r
3192                                                         int nListboxEntries = GetItemCount();\r
3193                                                         for (int i=0; i<nListboxEntries; ++i)\r
3194                                                         {\r
3195                                                                 FileEntry * entry = GetListEntry(i);\r
3196                                                                 ASSERT(entry != NULL);\r
3197                                                                 if (entry == NULL)\r
3198                                                                         continue;\r
3199                                                                 if (basepath.IsEmpty())\r
3200                                                                         basepath = entry->basepath;\r
3201                                                                 // since we ignored files with a mask (e.g. *.exe)\r
3202                                                                 // we have to find find all files in the same\r
3203                                                                 // folder (IsAncestorOf() returns TRUE for _all_ children,\r
3204                                                                 // not just the immediate ones) which match the\r
3205                                                                 // mask and remove them from the list too.\r
3206                                                                 if ((entry->status == git_wc_status_unversioned)&&(parentFolder.IsAncestorOf(entry->path)))\r
3207                                                                 {\r
3208                                                                         CString f = entry->path.GetSVNPathString();\r
3209                                                                         if (f.Mid(parentFolder.GetSVNPathString().GetLength()).Find('/')<=0)\r
3210                                                                         {\r
3211                                                                                 if (CStringUtils::WildCardMatch(name, f))\r
3212                                                                                 {\r
3213                                                                                         if (GetCheck(i))\r
3214                                                                                                 m_nSelected--;\r
3215                                                                                         m_nTotal--;\r
3216                                                                                         toremove.push_back(f);\r
3217                                                                                 }\r
3218                                                                         }\r
3219                                                                 }\r
3220                                                         }\r
3221                                                         if (!m_bIgnoreRemoveOnly)\r
3222                                                         {\r
3223                                                                 SVNStatus status;\r
3224                                                                 git_wc_status2_t * s;\r
3225                                                                 CTSVNPath gitPath;\r
3226                                                                 s = status.GetFirstFileStatus(parentFolder, gitPath, false, git_depth_empty);\r
3227                                                                 if (s!=0)\r
3228                                                                 {\r
3229                                                                         // first check if the folder isn't already present in the list\r
3230                                                                         bool bFound = false;\r
3231                                                                         for (int i=0; i<nListboxEntries; ++i)\r
3232                                                                         {\r
3233                                                                                 FileEntry * entry = GetListEntry(i);\r
3234                                                                                 if (entry->path.IsEquivalentTo(gitPath))\r
3235                                                                                 {\r
3236                                                                                         bFound = true;\r
3237                                                                                         break;\r
3238                                                                                 }\r
3239                                                                         }\r
3240                                                                         if (!bFound)\r
3241                                                                         {\r
3242                                                                                 FileEntry * entry = new FileEntry();\r
3243                                                                                 entry->path = gitPath;\r
3244                                                                                 entry->basepath = basepath;\r
3245                                                                                 entry->status = SVNStatus::GetMoreImportant(s->text_status, s->prop_status);\r
3246                                                                                 entry->textstatus = s->text_status;\r
3247                                                                                 entry->propstatus = s->prop_status;\r
3248                                                                                 entry->remotestatus = SVNStatus::GetMoreImportant(s->repos_text_status, s->repos_prop_status);\r
3249                                                                                 entry->remotetextstatus = s->repos_text_status;\r
3250                                                                                 entry->remotepropstatus = s->repos_prop_status;\r
3251                                                                                 entry->inunversionedfolder = false;\r
3252                                                                                 entry->checked = true;\r
3253                                                                                 entry->inexternal = false;\r
3254                                                                                 entry->direct = false;\r
3255                                                                                 entry->isfolder = true;\r
3256                                                                                 entry->last_commit_date = 0;\r
3257                                                                                 entry->last_commit_rev = 0;\r
3258                                                                                 entry->remoterev = 0;\r
3259                                                                                 if (s->entry)\r
3260                                                                                 {\r
3261                                                                                         if (s->entry->url)\r
3262                                                                                         {\r
3263                                                                                                 entry->url = CUnicodeUtils::GetUnicode(CPathUtils::PathUnescape(s->entry->url));\r
3264                                                                                         }\r
3265                                                                                 }\r
3266                                                                                 if (s->entry && s->entry->present_props)\r
3267                                                                                 {\r
3268                                                                                         entry->present_props = s->entry->present_props;\r
3269                                                                                 }\r
3270                                                                                 m_arStatusArray.push_back(entry);\r
3271                                                                                 m_arListArray.push_back(m_arStatusArray.size()-1);\r
3272                                                                                 AddEntry(entry, langID, GetItemCount());\r
3273                                                                         }\r
3274                                                                 }\r
3275                                                         }\r
3276                                                 }\r
3277                                         }\r
3278                                         for (std::vector<CString>::iterator it = toremove.begin(); it != toremove.end(); ++it)\r
3279                                         {\r
3280                                                 int nListboxEntries = GetItemCount();\r
3281                                                 for (int i=0; i<nListboxEntries; ++i)\r
3282                                                 {\r
3283                                                         if (GetListEntry(i)->path.GetSVNPathString().Compare(*it)==0)\r
3284                                                         {\r
3285                                                                 RemoveListEntry(i);\r
3286                                                                 break;\r
3287                                                         }\r
3288                                                 }\r
3289                                         }\r
3290                                         SetRedraw(TRUE);\r
3291                                 }\r
3292                                 break;\r
3293                         case IDSVNLC_IGNORE:\r
3294                                 {\r
3295                                         CTSVNPathList ignorelist;\r
3296                                         std::vector<CString> toremove;\r
3297                                         FillListOfSelectedItemPaths(ignorelist, true);\r
3298                                         SetRedraw(FALSE);\r
3299                                         for (int j=0; j<ignorelist.GetCount(); ++j)\r
3300                                         {\r
3301                                                 int nListboxEntries = GetItemCount();\r
3302                                                 for (int i=0; i<nListboxEntries; ++i)\r
3303                                                 {\r
3304                                                         if (GetListEntry(i)->GetPath().IsEquivalentTo(ignorelist[j]))\r
3305                                                         {\r
3306                                                                 selIndex = i;\r
3307                                                                 break;\r
3308                                                         }\r
3309                                                 }\r
3310                                                 CString name = CPathUtils::PathPatternEscape(ignorelist[j].GetFileOrDirectoryName());\r
3311                                                 CTSVNPath parentfolder = ignorelist[j].GetContainingDirectory();\r
3312                                                 SVNProperties props(parentfolder, SVNRev::REV_WC, false);\r
3313                                                 CStringA value;\r
3314                                                 for (int i=0; i<props.GetCount(); i++)\r
3315                                                 {\r
3316                                                         CString propname(props.GetItemName(i).c_str());\r
3317                                                         if (propname.CompareNoCase(_T("git:ignore"))==0)\r
3318                                                         {\r
3319                                                                 stdstring stemp;\r
3320                                                                 // treat values as normal text even if they're not\r
3321                                                                 value = (char *)props.GetItemValue(i).c_str();\r
3322                                                         }\r
3323                                                 }\r
3324                                                 if (value.IsEmpty())\r
3325                                                         value = name;\r
3326                                                 else\r
3327                                                 {\r
3328                                                         value = value.Trim("\n\r");\r
3329                                                         value += "\n";\r
3330                                                         value += name;\r
3331                                                         value.Remove('\r');\r
3332                                                 }\r
3333                                                 if (!props.Add(_T("git:ignore"), (LPCSTR)value))\r
3334                                                 {\r
3335                                                         CString temp;\r
3336                                                         temp.Format(IDS_ERR_FAILEDIGNOREPROPERTY, (LPCTSTR)name);\r
3337                                                         CMessageBox::Show(this->m_hWnd, temp, _T("TortoiseSVN"), MB_ICONERROR);\r
3338                                                         break;\r
3339                                                 }\r
3340                                                 if (GetCheck(selIndex))\r
3341                                                         m_nSelected--;\r
3342                                                 m_nTotal--;\r
3343 \r
3344                                                 // now, if we ignored a folder, remove all its children\r
3345                                                 if (ignorelist[j].IsDirectory())\r
3346                                                 {\r
3347                                                         for (int i=0; i<(int)m_arListArray.size(); ++i)\r
3348                                                         {\r
3349                                                                 FileEntry * entry = GetListEntry(i);\r
3350                                                                 if (entry->status == git_wc_status_unversioned)\r
3351                                                                 {\r
3352                                                                         if (!ignorelist[j].IsEquivalentTo(entry->GetPath())&&(ignorelist[j].IsAncestorOf(entry->GetPath())))\r
3353                                                                         {\r
3354                                                                                 entry->status = git_wc_status_ignored;\r
3355                                                                                 entry->textstatus = git_wc_status_ignored;\r
3356                                                                                 if (GetCheck(i))\r
3357                                                                                         m_nSelected--;\r
3358                                                                                 toremove.push_back(entry->GetPath().GetSVNPathString());\r
3359                                                                         }\r
3360                                                                 }\r
3361                                                         }\r
3362                                                 }\r
3363 \r
3364                                                 CTSVNPath basepath = m_arStatusArray[m_arListArray[selIndex]]->basepath;\r
3365 \r
3366                                                 FileEntry * entry = m_arStatusArray[m_arListArray[selIndex]];\r
3367                                                 if ( entry->status == git_wc_status_unversioned ) // keep "deleted" items\r
3368                                                         toremove.push_back(entry->GetPath().GetSVNPathString());\r
3369 \r
3370                                                 if (!m_bIgnoreRemoveOnly)\r
3371                                                 {\r
3372                                                         SVNStatus status;\r
3373                                                         git_wc_status2_t * s;\r
3374                                                         CTSVNPath gitPath;\r
3375                                                         s = status.GetFirstFileStatus(parentfolder, gitPath, false, git_depth_empty);\r
3376                                                         // first check if the folder isn't already present in the list\r
3377                                                         bool bFound = false;\r
3378                                                         nListboxEntries = GetItemCount();\r
3379                                                         for (int i=0; i<nListboxEntries; ++i)\r
3380                                                         {\r
3381                                                                 FileEntry * entry = GetListEntry(i);\r
3382                                                                 if (entry->path.IsEquivalentTo(gitPath))\r
3383                                                                 {\r
3384                                                                         bFound = true;\r
3385                                                                         break;\r
3386                                                                 }\r
3387                                                         }\r
3388                                                         if (!bFound)\r
3389                                                         {\r
3390                                                                 if (s!=0)\r
3391                                                                 {\r
3392                                                                         FileEntry * entry = new FileEntry();\r
3393                                                                         entry->path = gitPath;\r
3394                                                                         entry->basepath = basepath;\r
3395                                                                         entry->status = SVNStatus::GetMoreImportant(s->text_status, s->prop_status);\r
3396                                                                         entry->textstatus = s->text_status;\r
3397                                                                         entry->propstatus = s->prop_status;\r
3398                                                                         entry->remotestatus = SVNStatus::GetMoreImportant(s->repos_text_status, s->repos_prop_status);\r
3399                                                                         entry->remotetextstatus = s->repos_text_status;\r
3400                                                                         entry->remotepropstatus = s->repos_prop_status;\r
3401                                                                         entry->inunversionedfolder = FALSE;\r
3402                                                                         entry->checked = true;\r
3403                                                                         entry->inexternal = false;\r
3404                                                                         entry->direct = false;\r
3405                                                                         entry->isfolder = true;\r
3406                                                                         entry->last_commit_date = 0;\r
3407                                                                         entry->last_commit_rev = 0;\r
3408                                                                         entry->remoterev = 0;\r
3409                                                                         if (s->entry)\r
3410                                                                         {\r
3411                                                                                 if (s->entry->url)\r
3412                                                                                 {\r
3413                                                                                         entry->url = CUnicodeUtils::GetUnicode(CPathUtils::PathUnescape(s->entry->url));\r
3414                                                                                 }\r
3415                                                                         }\r
3416                                                                         if (s->entry && s->entry->present_props)\r
3417                                                                         {\r
3418                                                                                 entry->present_props = s->entry->present_props;\r
3419                                                                         }\r
3420                                                                         m_arStatusArray.push_back(entry);\r
3421                                                                         m_arListArray.push_back(m_arStatusArray.size()-1);\r
3422                                                                         AddEntry(entry, langID, GetItemCount());\r
3423                                                                 }\r
3424                                                         }\r
3425                                                 }\r
3426                                         }\r
3427                                         for (std::vector<CString>::iterator it = toremove.begin(); it != toremove.end(); ++it)\r
3428                                         {\r
3429                                                 int nListboxEntries = GetItemCount();\r
3430                                                 for (int i=0; i<nListboxEntries; ++i)\r
3431                                                 {\r
3432                                                         if (GetListEntry(i)->path.GetSVNPathString().Compare(*it)==0)\r
3433                                                         {\r
3434                                                                 RemoveListEntry(i);\r
3435                                                                 break;\r
3436                                                         }\r
3437                                                 }\r
3438                                         }\r
3439                                         SetRedraw(TRUE);\r
3440                                 }\r
3441                                 break;\r
3442                         case IDSVNLC_EDITCONFLICT:\r
3443                                 SVNDiff::StartConflictEditor(filepath);\r
3444                                 break;\r
3445                         case IDSVNLC_RESOLVECONFLICT:\r
3446                         case IDSVNLC_RESOLVEMINE:\r
3447                         case IDSVNLC_RESOLVETHEIRS:\r
3448                                 {\r
3449                                         git_wc_conflict_choice_t result = git_wc_conflict_choose_merged;\r
3450                                         switch (cmd)\r
3451                                         {\r
3452                                         case IDSVNLC_RESOLVETHEIRS:\r
3453                                                 result = git_wc_conflict_choose_theirs_full;\r
3454                                                 break;\r
3455                                         case IDSVNLC_RESOLVEMINE:\r
3456                                                 result = git_wc_conflict_choose_mine_full;\r
3457                                                 break;\r
3458                                         case IDSVNLC_RESOLVECONFLICT:\r
3459                                                 result = git_wc_conflict_choose_merged;\r
3460                                                 break;\r
3461                                         }\r
3462                                         if (CMessageBox::Show(m_hWnd, IDS_PROC_RESOLVE, IDS_APPNAME, MB_ICONQUESTION | MB_YESNO)==IDYES)\r
3463                                         {\r
3464                                                 SVN git;\r
3465                                                 POSITION pos = GetFirstSelectedItemPosition();\r
3466                                                 while (pos != 0)\r
3467                                                 {\r
3468                                                         int index;\r
3469                                                         index = GetNextSelectedItem(pos);\r
3470                                                         FileEntry * fentry = m_arStatusArray[m_arListArray[index]];\r
3471                                                         if (!git.Resolve(fentry->GetPath(), result, FALSE))\r
3472                                                         {\r
3473                                                                 CMessageBox::Show(m_hWnd, git.GetLastErrorMessage(), _T("TortoiseSVN"), MB_ICONERROR);\r
3474                                                         }\r
3475                                                         else\r
3476                                                         {\r
3477                                                                 fentry->status = git_wc_status_modified;\r
3478                                                                 fentry->textstatus = git_wc_status_modified;\r
3479                                                                 fentry->isConflicted = false;\r
3480                                                         }\r
3481                                                 }\r
3482                                                 Show(m_dwShow, 0, m_bShowFolders);\r
3483                                         }\r
3484                                 }\r
3485                                 break;\r
3486                         case IDSVNLC_ADD:\r
3487                                 {\r
3488                                         SVN git;\r
3489                                         CTSVNPathList itemsToAdd;\r
3490                                         FillListOfSelectedItemPaths(itemsToAdd);\r
3491 \r
3492                                         // We must sort items before adding, so that folders are always added\r
3493                                         // *before* any of their children\r
3494                                         itemsToAdd.SortByPathname();\r
3495 \r
3496                                         ProjectProperties props;\r
3497                                         props.ReadPropsPathList(itemsToAdd);\r
3498                                         if (git.Add(itemsToAdd, &props, git_depth_empty, TRUE, TRUE, TRUE))\r
3499                                         {\r
3500                                                 // The add went ok, but we now need to run through the selected items again\r
3501                                                 // and update their status\r
3502                                                 POSITION pos = GetFirstSelectedItemPosition();\r
3503                                                 int index;\r
3504                                                 while ((index = GetNextSelectedItem(pos)) >= 0)\r
3505                                                 {\r
3506                                                         FileEntry * e = GetListEntry(index);\r
3507                                                         e->textstatus = git_wc_status_added;\r
3508                                                         e->propstatus = git_wc_status_none;\r
3509                                                         e->status = git_wc_status_added;\r
3510                                                         SetEntryCheck(e,index,true);\r
3511                                                 }\r
3512                                         }\r
3513                                         else\r
3514                                         {\r
3515                                                 CMessageBox::Show(m_hWnd, git.GetLastErrorMessage(), _T("TortoiseSVN"), MB_ICONERROR);\r
3516                                         }\r
3517                                         SaveColumnWidths();\r
3518                                         Show(m_dwShow, 0, m_bShowFolders);\r
3519                                         NotifyCheck();\r
3520                                 }\r
3521                                 break;\r
3522                         case IDSVNLC_ADD_RECURSIVE:\r
3523                                 {\r
3524                                         CTSVNPathList itemsToAdd;\r
3525                                         FillListOfSelectedItemPaths(itemsToAdd);\r
3526 \r
3527                                         CAddDlg dlg;\r
3528                                         dlg.m_pathList = itemsToAdd;\r
3529                                         if (dlg.DoModal() == IDOK)\r
3530                                         {\r
3531                                                 if (dlg.m_pathList.GetCount() == 0)\r
3532                                                         break;\r
3533                                                 CSVNProgressDlg progDlg;\r
3534                                                 progDlg.SetCommand(CSVNProgressDlg::SVNProgress_Add);\r
3535                                                 progDlg.SetPathList(dlg.m_pathList);\r
3536                                                 ProjectProperties props;\r
3537                                                 props.ReadPropsPathList(dlg.m_pathList);\r
3538                                                 progDlg.SetProjectProperties(props);\r
3539                                                 progDlg.SetItemCount(dlg.m_pathList.GetCount());\r
3540                                                 progDlg.DoModal();\r
3541 \r
3542                                                 // refresh!\r
3543                                                 CWnd* pParent = GetParent();\r
3544                                                 if (NULL != pParent && NULL != pParent->GetSafeHwnd())\r
3545                                                 {\r
3546                                                         pParent->SendMessage(SVNSLNM_NEEDSREFRESH);\r
3547                                                 }\r
3548                                         }\r
3549                                 }\r
3550                                 break;\r
3551                         case IDSVNLC_LOCK:\r
3552                                 {\r
3553                                         CTSVNPathList itemsToLock;\r
3554                                         FillListOfSelectedItemPaths(itemsToLock);\r
3555                                         CInputDlg inpDlg;\r
3556                                         inpDlg.m_sTitle.LoadString(IDS_MENU_LOCK);\r
3557                                         CStringUtils::RemoveAccelerators(inpDlg.m_sTitle);\r
3558                                         inpDlg.m_sHintText.LoadString(IDS_LOCK_MESSAGEHINT);\r
3559                                         inpDlg.m_sCheckText.LoadString(IDS_LOCK_STEALCHECK);\r
3560                                         ProjectProperties props;\r
3561                                         props.ReadPropsPathList(itemsToLock);\r
3562                                         props.nMinLogSize = 0;          // the lock message is optional, so no minimum!\r
3563                                         inpDlg.m_pProjectProperties = &props;\r
3564                                         if (inpDlg.DoModal()==IDOK)\r
3565                                         {\r
3566                                                 CSVNProgressDlg progDlg;\r
3567                                                 progDlg.SetCommand(CSVNProgressDlg::SVNProgress_Lock);\r
3568                                                 progDlg.SetOptions(inpDlg.m_iCheck ? ProgOptLockForce : ProgOptNone);\r
3569                                                 progDlg.SetPathList(itemsToLock);\r
3570                                                 progDlg.SetCommitMessage(inpDlg.m_sInputText);\r
3571                                                 progDlg.DoModal();\r
3572                                                 // refresh!\r
3573                                                 CWnd* pParent = GetParent();\r
3574                                                 if (NULL != pParent && NULL != pParent->GetSafeHwnd())\r
3575                                                 {\r
3576                                                         pParent->SendMessage(SVNSLNM_NEEDSREFRESH);\r
3577                                                 }\r
3578                                         }\r
3579                                 }\r
3580                                 break;\r
3581                         case IDSVNLC_UNLOCKFORCE:\r
3582                                 bForce = true;\r
3583                         case IDSVNLC_UNLOCK:\r
3584                                 {\r
3585                                         CTSVNPathList itemsToUnlock;\r
3586                                         FillListOfSelectedItemPaths(itemsToUnlock);\r
3587                                         CSVNProgressDlg progDlg;\r
3588                                         progDlg.SetCommand(CSVNProgressDlg::SVNProgress_Unlock);\r
3589                                         progDlg.SetOptions(bForce ? ProgOptLockForce : ProgOptNone);\r
3590                                         progDlg.SetPathList(itemsToUnlock);\r
3591                                         progDlg.DoModal();\r
3592                                         // refresh!\r
3593                                         CWnd* pParent = GetParent();\r
3594                                         if (NULL != pParent && NULL != pParent->GetSafeHwnd())\r
3595                                         {\r
3596                                                 pParent->SendMessage(SVNSLNM_NEEDSREFRESH);\r
3597                                         }\r
3598                                 }\r
3599                                 break;\r
3600                         case IDSVNLC_REPAIRMOVE:\r
3601                                 {\r
3602                                         POSITION pos = GetFirstSelectedItemPosition();\r
3603                                         int index = GetNextSelectedItem(pos);\r
3604                                         FileEntry * entry1 = NULL;\r
3605                                         FileEntry * entry2 = NULL;\r
3606                                         if (index >= 0)\r
3607                                         {\r
3608                                                 entry1 = GetListEntry(index);\r
3609                                                 git_wc_status_kind status1 = git_wc_status_none;\r
3610                                                 git_wc_status_kind status2 = git_wc_status_none;\r
3611                                                 if (entry1)\r
3612                                                 {\r
3613                                                         status1 = entry1->status;\r
3614                                                         index = GetNextSelectedItem(pos);\r
3615                                                         if (index >= 0)\r
3616                                                         {\r
3617                                                                 entry2 = GetListEntry(index);\r
3618                                                                 if (entry2)\r
3619                                                                 {\r
3620                                                                         status2 = entry2->status;\r
3621                                                                         if (status2 == git_wc_status_missing && status1 == git_wc_status_unversioned)\r
3622                                                                         {\r
3623                                                                                 FileEntry * tempentry = entry1;\r
3624                                                                                 entry1 = entry2;\r
3625                                                                                 entry2 = tempentry;\r
3626                                                                         }\r
3627                                                                         // entry1 was renamed to entry2 but outside of Subversion\r
3628                                                                         // fix this by moving entry2 back to entry1 first,\r
3629                                                                         // then do an git-move from entry1 to entry2\r
3630                                                                         if (MoveFile(entry2->GetPath().GetWinPath(), entry1->GetPath().GetWinPath()))\r
3631                                                                         {\r
3632                                                                                 SVN git;\r
3633                                                                                 if (!git.Move(CTSVNPathList(entry1->GetPath()), entry2->GetPath(), TRUE))\r
3634                                                                                 {\r
3635                                                                                         CMessageBox::Show(m_hWnd, git.GetLastErrorMessage(), _T("TortoiseSVN"), MB_ICONERROR);\r
3636                                                                                 }\r
3637                                                                                 else\r
3638                                                                                 {\r
3639                                                                                         // check the previously unversioned item\r
3640                                                                                         entry1->checked = true;\r
3641                                                                                         // fixing the move was successful. We have to adjust the new status of the\r
3642                                                                                         // files.\r
3643                                                                                         // Since we don't know if the moved/renamed file had local modifications or not,\r
3644                                                                                         // we can't guess the new status. That means we have to refresh...\r
3645                                                                                         CWnd* pParent = GetParent();\r
3646                                                                                         if (NULL != pParent && NULL != pParent->GetSafeHwnd())\r
3647                                                                                         {\r
3648                                                                                                 pParent->SendMessage(SVNSLNM_NEEDSREFRESH);\r
3649                                                                                         }\r
3650                                                                                 }\r
3651                                                                         }\r
3652                                                                         else\r
3653                                                                         {\r
3654                                                                                 LPVOID lpMsgBuf;\r
3655                                                                                 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | \r
3656                                                                                         FORMAT_MESSAGE_FROM_SYSTEM | \r
3657                                                                                         FORMAT_MESSAGE_IGNORE_INSERTS,\r
3658                                                                                         NULL,\r
3659                                                                                         GetLastError(),\r
3660                                                                                         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language\r
3661                                                                                         (LPTSTR) &lpMsgBuf,\r
3662                                                                                         0,\r
3663                                                                                         NULL \r
3664                                                                                         );\r
3665                                                                                 MessageBox((LPCTSTR)lpMsgBuf, _T("Error"), MB_OK | MB_ICONINFORMATION );\r
3666                                                                                 LocalFree( lpMsgBuf );\r
3667                                                                         }\r
3668                                                                 }\r
3669                                                         }\r
3670                                                 }\r
3671                                         }\r
3672                                 }\r
3673                                 break;\r
3674                         case IDSVNLC_REMOVEFROMCS:\r
3675                                 {\r
3676                                         CTSVNPathList changelistItems;\r
3677                                         FillListOfSelectedItemPaths(changelistItems);\r
3678                                         SVN git;\r
3679                                         SetRedraw(FALSE);\r
3680                                         if (git.RemoveFromChangeList(changelistItems, CStringArray(), git_depth_empty))\r
3681                                         {\r
3682                                                 // The changelists were removed, but we now need to run through the selected items again\r
3683                                                 // and update their changelist\r
3684                                                 POSITION pos = GetFirstSelectedItemPosition();\r
3685                                                 int index;\r
3686                                                 std::vector<int> entriesToRemove;\r
3687                                                 while ((index = GetNextSelectedItem(pos)) >= 0)\r
3688                                                 {\r
3689                                                         FileEntry * e = GetListEntry(index);\r
3690                                                         if (e)\r
3691                                                         {\r
3692                                                                 e->changelist.Empty();\r
3693                                                                 if (e->status == git_wc_status_normal)\r
3694                                                                 {\r
3695                                                                         // remove the entry completely\r
3696                                                                         entriesToRemove.push_back(index);\r
3697                                                                 }\r
3698                                                                 else\r
3699                                                                         SetItemGroup(index, 0);\r
3700                                                         }\r
3701                                                 }\r
3702                                                 for (std::vector<int>::reverse_iterator it = entriesToRemove.rbegin(); it != entriesToRemove.rend(); ++it)\r
3703                                                 {\r
3704                                                         RemoveListEntry(*it);\r
3705                                                 }\r
3706                                                 // TODO: Should we go through all entries here and check if we also could\r
3707                                                 // remove the changelist from m_changelists ?\r
3708                                         }\r
3709                                         else\r
3710                                         {\r
3711                                                 CMessageBox::Show(m_hWnd, git.GetLastErrorMessage(), _T("TortoiseSVN"), MB_ICONERROR);\r
3712                                         }\r
3713                                         SetRedraw(TRUE);\r
3714                                 }\r
3715                                 break;\r
3716                         case IDSVNLC_CREATEIGNORECS:\r
3717                                 CreateChangeList(SVNSLC_IGNORECHANGELIST);\r
3718                                 break;\r
3719                         case IDSVNLC_CREATECS:\r
3720                                 {\r
3721                                         CCreateChangelistDlg dlg;\r
3722                                         if (dlg.DoModal() == IDOK)\r
3723                                         {\r
3724                                                 CreateChangeList(dlg.m_sName);\r
3725                                         }\r
3726                                 }\r
3727                                 break;\r
3728                         default:\r
3729                                 {\r
3730                                         if (cmd < IDSVNLC_MOVETOCS)\r
3731                                                 break;\r
3732                                         CTSVNPathList changelistItems;\r
3733                                         FillListOfSelectedItemPaths(changelistItems);\r
3734 \r
3735                                         // find the changelist name\r
3736                                         CString sChangelist;\r
3737                                         int cmdID = IDSVNLC_MOVETOCS;\r
3738                                         SetRedraw(FALSE);\r
3739                                         for (std::map<CString, int>::const_iterator it = m_changelists.begin(); it != m_changelists.end(); ++it)\r
3740                                         {\r
3741                                                 if ((it->first.Compare(SVNSLC_IGNORECHANGELIST))&&(entry->changelist.Compare(it->first)))\r
3742                                                 {\r
3743                                                         if (cmd == cmdID)\r
3744                                                         {\r
3745                                                                 sChangelist = it->first;\r
3746                                                         }\r
3747                                                         cmdID++;\r
3748                                                 }\r
3749                                         }\r
3750                                         if (!sChangelist.IsEmpty())\r
3751                                         {\r
3752                                                 SVN git;\r
3753                                                 if (git.AddToChangeList(changelistItems, sChangelist, git_depth_empty))\r
3754                                                 {\r
3755                                                         // The changelists were moved, but we now need to run through the selected items again\r
3756                                                         // and update their changelist\r
3757                                                         POSITION pos = GetFirstSelectedItemPosition();\r
3758                                                         int index;\r
3759                                                         while ((index = GetNextSelectedItem(pos)) >= 0)\r
3760                                                         {\r
3761                                                                 FileEntry * e = GetListEntry(index);\r
3762                                                                 e->changelist = sChangelist;\r
3763                                                                 if (!e->IsFolder())\r
3764                                                                 {\r
3765                                                                         if (m_changelists.find(e->changelist)!=m_changelists.end())\r
3766                                                                                 SetItemGroup(index, m_changelists[e->changelist]);\r
3767                                                                         else\r
3768                                                                                 SetItemGroup(index, 0);\r
3769                                                                 }\r
3770                                                         }\r
3771                                                 }\r
3772                                                 else\r
3773                                                 {\r
3774                                                         CMessageBox::Show(m_hWnd, git.GetLastErrorMessage(), _T("TortoiseSVN"), MB_ICONERROR);\r
3775                                                 }\r
3776                                         }\r
3777                                         SetRedraw(TRUE);\r
3778                                 }\r
3779                                 break;\r
3780 #endif\r
3781 \r
3782                         } // switch (cmd)\r
3783                         m_bBlock = FALSE;\r
3784                         AfxGetApp()->DoWaitCursor(-1);\r
3785                         GetStatisticsString();\r
3786                         int iItemCountAfterMenuCmd = GetItemCount();\r
3787                         //if (iItemCountAfterMenuCmd != iItemCountBeforeMenuCmd)\r
3788                         //{\r
3789                         //      CWnd* pParent = GetParent();\r
3790                         //      if (NULL != pParent && NULL != pParent->GetSafeHwnd())\r
3791                         //      {\r
3792                         //              pParent->SendMessage(SVNSLNM_ITEMCOUNTCHANGED);\r
3793                         //      }\r
3794                         //}\r
3795                 } // if (popup.CreatePopupMenu())\r
3796         } // if (selIndex >= 0)\r
3797 \r
3798 }\r
3799 \r
3800 void CGitStatusListCtrl::OnContextMenuHeader(CWnd * pWnd, CPoint point)\r
3801 {\r
3802         bool XPorLater = false;\r
3803         OSVERSIONINFOEX inf;\r
3804         SecureZeroMemory(&inf, sizeof(OSVERSIONINFOEX));\r
3805         inf.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);\r
3806         GetVersionEx((OSVERSIONINFO *)&inf);\r
3807         WORD fullver = MAKEWORD(inf.dwMinorVersion, inf.dwMajorVersion);\r
3808         if (fullver >= 0x0501)\r
3809                 XPorLater = true;\r
3810 \r
3811         CHeaderCtrl * pHeaderCtrl = (CHeaderCtrl *)pWnd;\r
3812         if ((point.x == -1) && (point.y == -1))\r
3813         {\r
3814                 CRect rect;\r
3815                 pHeaderCtrl->GetItemRect(0, &rect);\r
3816                 ClientToScreen(&rect);\r
3817                 point = rect.CenterPoint();\r
3818         }\r
3819         Locker lock(m_critSec);\r
3820         CMenu popup;\r
3821         if (popup.CreatePopupMenu())\r
3822         {\r
3823                 int columnCount = m_ColumnManager.GetColumnCount();\r
3824 \r
3825                 CString temp;\r
3826                 UINT uCheckedFlags = MF_STRING | MF_ENABLED | MF_CHECKED;\r
3827                 UINT uUnCheckedFlags = MF_STRING | MF_ENABLED;\r
3828 \r
3829                 // build control menu\r
3830 \r
3831                 if (XPorLater)\r
3832                 {\r
3833                         temp.LoadString(IDS_STATUSLIST_SHOWGROUPS);\r
3834                         popup.AppendMenu(IsGroupViewEnabled() ? uCheckedFlags : uUnCheckedFlags, columnCount, temp);\r
3835                 }\r
3836 \r
3837                 if (m_ColumnManager.AnyUnusedProperties())\r
3838                 {\r
3839                         temp.LoadString(IDS_STATUSLIST_REMOVEUNUSEDPROPS);\r
3840                         popup.AppendMenu(uUnCheckedFlags, columnCount+1, temp);\r
3841                 }\r
3842 \r
3843                 temp.LoadString(IDS_STATUSLIST_RESETCOLUMNORDER);\r
3844                 popup.AppendMenu(uUnCheckedFlags, columnCount+2, temp);\r
3845                 popup.AppendMenu(MF_SEPARATOR);\r
3846 \r
3847                 // standard columns\r
3848 \r
3849                 for (int i = 1; i < SVNSLC_NUMCOLUMNS; ++i)\r
3850                 {\r
3851                         popup.AppendMenu ( m_ColumnManager.IsVisible(i) \r
3852                                 ? uCheckedFlags \r
3853                                 : uUnCheckedFlags\r
3854                                 , i\r
3855                                 , m_ColumnManager.GetName(i));\r
3856                 }\r
3857 \r
3858                 // user-prop columns:\r
3859                 // find relevant ones and sort 'em\r
3860 \r
3861                 std::map<CString, int> sortedProps;\r
3862                 for (int i = SVNSLC_NUMCOLUMNS; i < columnCount; ++i)\r
3863                         if (m_ColumnManager.IsRelevant(i))\r
3864                                 sortedProps[m_ColumnManager.GetName(i)] = i;\r
3865 \r
3866                 if (!sortedProps.empty())\r
3867                 {\r
3868                         // add 'em to the menu\r
3869 \r
3870                         popup.AppendMenu(MF_SEPARATOR);\r
3871 \r
3872                         typedef std::map<CString, int>::const_iterator CIT;\r
3873                         for ( CIT iter = sortedProps.begin(), end = sortedProps.end()\r
3874                                 ; iter != end\r
3875                                 ; ++iter)\r
3876                         {\r
3877                                 popup.AppendMenu ( m_ColumnManager.IsVisible(iter->second) \r
3878                                         ? uCheckedFlags \r
3879                                         : uUnCheckedFlags\r
3880                                         , iter->second\r
3881                                         , iter->first);\r
3882                         }\r
3883                 }\r
3884 \r
3885                 // show menu & let user pick an entry\r
3886 \r
3887                 int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this, 0);\r
3888                 if ((cmd >= 1)&&(cmd < columnCount))\r
3889                 {\r
3890                         m_ColumnManager.SetVisible (cmd, !m_ColumnManager.IsVisible(cmd));\r
3891                 } \r
3892                 else if (cmd == columnCount)\r
3893                 {\r
3894                         EnableGroupView(!IsGroupViewEnabled());\r
3895                 } \r
3896                 else if (cmd == columnCount+1)\r
3897                 {\r
3898                         m_ColumnManager.RemoveUnusedProps();\r
3899                 } \r
3900                 else if (cmd == columnCount+2)\r
3901                 {\r
3902                         m_ColumnManager.ResetColumns (m_dwDefaultColumns);\r
3903                 }\r
3904         }\r
3905 }\r
3906 \r
3907 void CGitStatusListCtrl::OnContextMenu(CWnd* pWnd, CPoint point)\r
3908 {\r
3909 \r
3910         if (pWnd == this)\r
3911         {\r
3912                 OnContextMenuList(pWnd, point);\r
3913         } // if (pWnd == this)\r
3914         else if (pWnd == GetHeaderCtrl())\r
3915         {\r
3916                 OnContextMenuHeader(pWnd, point);\r
3917         }\r
3918 }\r
3919 \r
3920 void CGitStatusListCtrl::CreateChangeList(const CString& name)\r
3921 {\r
3922 #if 0\r
3923         CTGitPathList changelistItems;\r
3924         FillListOfSelectedItemPaths(changelistItems);\r
3925         Git git;\r
3926         if (git.AddToChangeList(changelistItems, name, git_depth_empty))\r
3927         {\r
3928                 TCHAR groupname[1024];\r
3929                 LVGROUP grp = {0};\r
3930                 grp.cbSize = sizeof(LVGROUP);\r
3931                 grp.mask = LVGF_ALIGN | LVGF_GROUPID | LVGF_HEADER;\r
3932                 _tcsncpy_s(groupname, 1024, name, 1023);\r
3933                 grp.pszHeader = groupname;\r
3934                 grp.iGroupId = (int)m_changelists.size();\r
3935                 grp.uAlign = LVGA_HEADER_LEFT;\r
3936                 m_changelists[name] = InsertGroup(-1, &grp);\r
3937 \r
3938                 PrepareGroups(true);\r
3939 \r
3940                 POSITION pos = GetFirstSelectedItemPosition();\r
3941                 int index;\r
3942                 while ((index = GetNextSelectedItem(pos)) >= 0)\r
3943                 {\r
3944                         FileEntry * e = GetListEntry(index);\r
3945                         e->changelist = name;\r
3946                         SetEntryCheck(e, index, FALSE);\r
3947                 }\r
3948 \r
3949                 for (index = 0; index < GetItemCount(); ++index)\r
3950                 {\r
3951                         FileEntry * e = GetListEntry(index);\r
3952                         if (m_changelists.find(e->changelist)!=m_changelists.end())\r
3953                                 SetItemGroup(index, m_changelists[e->changelist]);\r
3954                         else\r
3955                                 SetItemGroup(index, 0);\r
3956                 }\r
3957         }\r
3958         else\r
3959         {\r
3960                 CMessageBox::Show(m_hWnd, git.GetLastErrorMessage(), _T("Tortoisegit"), MB_ICONERROR);\r
3961         }\r
3962 #endif\r
3963 }\r
3964 \r
3965 void CGitStatusListCtrl::OnNMDblclk(NMHDR *pNMHDR, LRESULT *pResult)\r
3966 {\r
3967 \r
3968         Locker lock(m_critSec);\r
3969         LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);\r
3970         *pResult = 0;\r
3971         if (m_bBlock)\r
3972                 return;\r
3973 #if 0\r
3974         if (pNMLV->iItem < 0)\r
3975         {\r
3976                 if (!IsGroupViewEnabled())\r
3977                         return;\r
3978                 POINT pt;\r
3979                 DWORD ptW = GetMessagePos();\r
3980                 pt.x = GET_X_LPARAM(ptW);\r
3981                 pt.y = GET_Y_LPARAM(ptW);\r
3982                 ScreenToClient(&pt);\r
3983                 int group = GetGroupFromPoint(&pt);\r
3984                 if (group < 0)\r
3985                         return;\r
3986                 // check/uncheck the whole group depending on the check-state \r
3987                 // of the first item in the group\r
3988                 m_bBlock = true;\r
3989                 bool bCheck = false;\r
3990                 bool bFirst = false;\r
3991                 LVITEM lv;\r
3992                 for (int i=0; i<GetItemCount(); ++i)\r
3993                 {\r
3994                         SecureZeroMemory(&lv, sizeof(LVITEM));\r
3995                         lv.mask = LVIF_GROUPID;\r
3996                         lv.iItem = i;\r
3997                         GetItem(&lv);\r
3998                         if (lv.iGroupId == group)\r
3999                         {\r
4000                                 FileEntry * entry = GetListEntry(i);\r
4001                                 if (!bFirst)\r
4002                                 {\r
4003                                         bCheck = !GetCheck(i);\r
4004                                         bFirst = true;\r
4005                                 }\r
4006                                 if (entry)\r
4007                                 {\r
4008                                         bool bOldCheck = !!GetCheck(i);\r
4009                                         SetEntryCheck(entry, i, bCheck);\r
4010                                         if (bCheck != bOldCheck)\r
4011                                         {\r
4012                                                 if (bCheck)\r
4013                                                         m_nSelected++;\r
4014                                                 else\r
4015                                                         m_nSelected--;\r
4016                                         }\r
4017                                 }\r
4018                         }\r
4019                 }\r
4020                 GetStatisticsString();\r
4021                 m_bBlock = false;\r
4022                 NotifyCheck();\r
4023                 return;\r
4024         }\r
4025 #endif\r
4026 //      FileEntry * entry = GetListEntry(pNMLV->iItem);\r
4027 //      if (entry)\r
4028         {\r
4029 //              if (entry->isConflicted)\r
4030 //              {\r
4031 //                      gitDiff::StartConflictEditor(entry->GetPath());\r
4032 //              }\r
4033 //              else\r
4034                 {\r
4035                         StartDiff(pNMLV->iItem);\r
4036                 }\r
4037         }\r
4038 \r
4039 }\r
4040 \r
4041 void CGitStatusListCtrl::StartDiff(int fileindex)\r
4042 {\r
4043         if(fileindex<0)\r
4044                 return;\r
4045         if(this->m_CurrentVersion.IsEmpty() || m_CurrentVersion== GIT_REV_ZERO)\r
4046         {\r
4047                 if(!g_Git.IsInitRepos())\r
4048                         CGitDiff::Diff((CTGitPath*)GetItemData(fileindex),\r
4049                                 CString(GIT_REV_ZERO),\r
4050                                         GitRev::GetHead());\r
4051                 else\r
4052                         CGitDiff::DiffNull((CTGitPath*)GetItemData(fileindex),\r
4053                                 CString(GIT_REV_ZERO));\r
4054         }else\r
4055         {\r
4056                 CGitDiff::Diff((CTGitPath*)GetItemData(fileindex),\r
4057                                 m_CurrentVersion,\r
4058                                         m_CurrentVersion+_T("~1"));\r
4059         }\r
4060 #if 0\r
4061         if (fileindex < 0)\r
4062                 return;\r
4063         FileEntry * entry = GetListEntry(fileindex);\r
4064         ASSERT(entry != NULL);\r
4065         if (entry == NULL)\r
4066                 return;\r
4067         if (((entry->status == git_wc_status_normal)&&(entry->remotestatus <= git_wc_status_normal))||\r
4068                 (entry->status == git_wc_status_unversioned)||(entry->status == git_wc_status_none))\r
4069         {\r
4070                 int ret = (int)ShellExecute(this->m_hWnd, NULL, entry->path.GetWinPath(), NULL, NULL, SW_SHOW);\r
4071                 if (ret <= HINSTANCE_ERROR)\r
4072                 {\r
4073                         CString cmd = _T("RUNDLL32 Shell32,OpenAs_RunDLL ");\r
4074                         cmd += entry->path.GetWinPathString();\r
4075                         CAppUtils::LaunchApplication(cmd, NULL, false);\r
4076                 }\r
4077                 return;\r
4078         }\r
4079 \r
4080         GitDiff diff(NULL, m_hWnd, true);\r
4081         diff.SetAlternativeTool(!!(GetAsyncKeyState(VK_SHIFT) & 0x8000));\r
4082         diff.DiffWCFile(\r
4083                 entry->path, entry->textstatus, entry->propstatus,\r
4084                 entry->remotetextstatus, entry->remotepropstatus);\r
4085 #endif\r
4086 }\r
4087 \r
4088 CString CGitStatusListCtrl::GetStatisticsString()\r
4089 {\r
4090 \r
4091         CString sNormal, sAdded, sDeleted, sModified, sConflicted, sUnversioned;\r
4092         WORD langID = (WORD)(DWORD)CRegStdWORD(_T("Software\\TortoiseGit\\LanguageID"), GetUserDefaultLangID());\r
4093         TCHAR buf[MAX_STATUS_STRING_LENGTH];\r
4094         GitStatus::GetStatusString(AfxGetResourceHandle(), git_wc_status_normal, buf, sizeof(buf)/sizeof(TCHAR), langID);\r
4095         sNormal = buf;\r
4096         GitStatus::GetStatusString(AfxGetResourceHandle(), git_wc_status_added, buf, sizeof(buf)/sizeof(TCHAR), langID);\r
4097         sAdded = buf;\r
4098         GitStatus::GetStatusString(AfxGetResourceHandle(), git_wc_status_deleted, buf, sizeof(buf)/sizeof(TCHAR), langID);\r
4099         sDeleted = buf;\r
4100         GitStatus::GetStatusString(AfxGetResourceHandle(), git_wc_status_modified, buf, sizeof(buf)/sizeof(TCHAR), langID);\r
4101         sModified = buf;\r
4102         GitStatus::GetStatusString(AfxGetResourceHandle(), git_wc_status_conflicted, buf, sizeof(buf)/sizeof(TCHAR), langID);\r
4103         sConflicted = buf;\r
4104         GitStatus::GetStatusString(AfxGetResourceHandle(), git_wc_status_unversioned, buf, sizeof(buf)/sizeof(TCHAR), langID);\r
4105         sUnversioned = buf;\r
4106         CString sToolTip;\r
4107         sToolTip.Format(_T("%s = %d\n%s = %d\n%s = %d\n%s = %d\n%s = %d\n%s = %d"),\r
4108                 (LPCTSTR)sNormal, m_nNormal,\r
4109                 (LPCTSTR)sUnversioned, m_nUnversioned,\r
4110                 (LPCTSTR)sModified, m_nModified,\r
4111                 (LPCTSTR)sAdded, m_nAdded,\r
4112                 (LPCTSTR)sDeleted, m_nDeleted,\r
4113                 (LPCTSTR)sConflicted, m_nConflicted\r
4114                 );\r
4115         CString sStats;\r
4116         sStats.Format(IDS_COMMITDLG_STATISTICSFORMAT, m_nSelected, GetItemCount());\r
4117         if (m_pStatLabel)\r
4118         {\r
4119                 m_pStatLabel->SetWindowText(sStats);\r
4120         }\r
4121 \r
4122         if (m_pSelectButton)\r
4123         {\r
4124                 if (m_nSelected == 0)\r
4125                         m_pSelectButton->SetCheck(BST_UNCHECKED);\r
4126                 else if (m_nSelected != GetItemCount())\r
4127                         m_pSelectButton->SetCheck(BST_INDETERMINATE);\r
4128                 else\r
4129                         m_pSelectButton->SetCheck(BST_CHECKED);\r
4130         }\r
4131 \r
4132         if (m_pConfirmButton)\r
4133         {\r
4134                 m_pConfirmButton->EnableWindow(m_nSelected>0);\r
4135         }\r
4136 \r
4137         return sToolTip;\r
4138 \r
4139 \r
4140 }\r
4141 \r
4142 CTGitPath CGitStatusListCtrl::GetCommonDirectory(bool bStrict)\r
4143 {\r
4144         if (!bStrict)\r
4145         {\r
4146                 // not strict means that the selected folder has priority\r
4147                 if (!m_StatusFileList.GetCommonDirectory().IsEmpty())\r
4148                         return m_StatusFileList.GetCommonDirectory();\r
4149         }\r
4150 \r
4151         CTGitPath commonBaseDirectory;\r
4152         int nListItems = GetItemCount();\r
4153         for (int i=0; i<nListItems; ++i)\r
4154         {\r
4155                 CTGitPath& baseDirectory = *(CTGitPath*)this->GetItemData(i);\r
4156                 if(commonBaseDirectory.IsEmpty())\r
4157                 {\r
4158                         commonBaseDirectory = baseDirectory;\r
4159                 }\r
4160                 else\r
4161                 {\r
4162                         if (commonBaseDirectory.GetWinPathString().GetLength() > baseDirectory.GetWinPathString().GetLength())\r
4163                         {\r
4164                                 if (baseDirectory.IsAncestorOf(commonBaseDirectory))\r
4165                                         commonBaseDirectory = baseDirectory;\r
4166                         }\r
4167                 }\r
4168         }\r
4169         return commonBaseDirectory;\r
4170 }\r
4171 \r
4172 CTGitPath CGitStatusListCtrl::GetCommonURL(bool bStrict)\r
4173 {\r
4174         CTGitPath commonBaseURL;\r
4175 #if 0\r
4176         \r
4177         if (!bStrict)\r
4178         {\r
4179                 // not strict means that the selected folder has priority\r
4180                 if (!m_StatusUrlList.GetCommonDirectory().IsEmpty())\r
4181                         return m_StatusUrlList.GetCommonDirectory();\r
4182         }\r
4183 \r
4184         int nListItems = GetItemCount();\r
4185         for (int i=0; i<nListItems; ++i)\r
4186         {\r
4187                 const CTGitPath& baseURL = CTGitPath(GetListEntry(i)->GetURL());\r
4188                 if (baseURL.IsEmpty())\r
4189                         continue;                       // item has no url\r
4190                 if(commonBaseURL.IsEmpty())\r
4191                 {\r
4192                         commonBaseURL = baseURL;\r
4193                 }\r
4194                 else\r
4195                 {\r
4196                         if (commonBaseURL.GetGitPathString().GetLength() > baseURL.GetGitPathString().GetLength())\r
4197                         {\r
4198                                 if (baseURL.IsAncestorOf(commonBaseURL))\r
4199                                         commonBaseURL = baseURL;\r
4200                         }\r
4201                 }\r
4202         }\r
4203         \r
4204 #endif\r
4205         return commonBaseURL;\r
4206 }\r
4207 \r
4208 void CGitStatusListCtrl::SelectAll(bool bSelect, bool bIncludeNoCommits)\r
4209 {\r
4210         CWaitCursor waitCursor;\r
4211         // block here so the LVN_ITEMCHANGED messages\r
4212         // get ignored\r
4213         m_bBlock = TRUE;\r
4214         SetRedraw(FALSE);\r
4215 \r
4216         int nListItems = GetItemCount();\r
4217         if (bSelect)\r
4218                 m_nSelected = nListItems;\r
4219         else\r
4220                 m_nSelected = 0;\r
4221 \r
4222         for (int i=0; i<nListItems; ++i)\r
4223         {\r
4224                 //FileEntry * entry = GetListEntry(i);\r
4225                 //ASSERT(entry != NULL);\r
4226                 CTGitPath *path = (CTGitPath *) GetItemData(i);\r
4227                 if (path == NULL)\r
4228                         continue;\r
4229                 //if ((bIncludeNoCommits)||(entry->GetChangeList().Compare(SVNSLC_IGNORECHANGELIST)))\r
4230                 SetEntryCheck(path,i,bSelect);\r
4231         }\r
4232 \r
4233         // unblock before redrawing\r
4234         m_bBlock = FALSE;\r
4235         SetRedraw(TRUE);\r
4236         GetStatisticsString();\r
4237         NotifyCheck();\r
4238 }\r
4239 \r
4240 void CGitStatusListCtrl::OnLvnGetInfoTip(NMHDR *pNMHDR, LRESULT *pResult)\r
4241 {\r
4242         LPNMLVGETINFOTIP pGetInfoTip = reinterpret_cast<LPNMLVGETINFOTIP>(pNMHDR);\r
4243         *pResult = 0;\r
4244         if (m_bBlock)\r
4245                 return;\r
4246 #if 0\r
4247         if (GetListEntry(pGetInfoTip->iItem >= 0))\r
4248                 if (pGetInfoTip->cchTextMax > GetListEntry(pGetInfoTip->iItem)->path.GetGitPathString().GetLength())\r
4249                 {\r
4250                         if (GetListEntry(pGetInfoTip->iItem)->GetRelativeGitPath().Compare(GetListEntry(pGetInfoTip->iItem)->path.GetGitPathString())!= 0)\r
4251                                 _tcsncpy_s(pGetInfoTip->pszText, pGetInfoTip->cchTextMax, GetListEntry(pGetInfoTip->iItem)->path.GetGitPathString(), pGetInfoTip->cchTextMax);\r
4252                         else if (GetStringWidth(GetListEntry(pGetInfoTip->iItem)->path.GetGitPathString()) > GetColumnWidth(pGetInfoTip->iItem))\r
4253                                 _tcsncpy_s(pGetInfoTip->pszText, pGetInfoTip->cchTextMax, GetListEntry(pGetInfoTip->iItem)->path.GetGitPathString(), pGetInfoTip->cchTextMax);\r
4254                 }\r
4255 #endif\r
4256 }\r
4257 \r
4258 void CGitStatusListCtrl::OnNMCustomdraw(NMHDR *pNMHDR, LRESULT *pResult)\r
4259 {\r
4260         NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>( pNMHDR );\r
4261 \r
4262         // Take the default processing unless we set this to something else below.\r
4263         *pResult = CDRF_DODEFAULT;\r
4264 \r
4265         // First thing - check the draw stage. If it's the control's prepaint\r
4266         // stage, then tell Windows we want messages for every item.\r
4267 \r
4268         switch (pLVCD->nmcd.dwDrawStage)\r
4269         {\r
4270         case CDDS_PREPAINT:\r
4271                 *pResult = CDRF_NOTIFYITEMDRAW;\r
4272                 break;\r
4273         case CDDS_ITEMPREPAINT:\r
4274                 {\r
4275                         // This is the prepaint stage for an item. Here's where we set the\r
4276                         // item's text color. Our return value will tell Windows to draw the\r
4277                         // item itself, but it will use the new color we set here.\r
4278 \r
4279                         // Tell Windows to paint the control itself.\r
4280                         *pResult = CDRF_DODEFAULT;\r
4281                         if (m_bBlock)\r
4282                                 return;\r
4283 \r
4284                         COLORREF crText = GetSysColor(COLOR_WINDOWTEXT);\r
4285 \r
4286                         if (m_arStatusArray.size() > (DWORD_PTR)pLVCD->nmcd.dwItemSpec)\r
4287                         {\r
4288 \r
4289                                 //FileEntry * entry = GetListEntry((int)pLVCD->nmcd.dwItemSpec);\r
4290                                 CTGitPath *entry=(CTGitPath *)GetItemData((int)pLVCD->nmcd.dwItemSpec);\r
4291                                 if (entry == NULL)\r
4292                                         return;\r
4293 \r
4294                                 // coloring\r
4295                                 // ========\r
4296                                 // black  : unversioned, normal\r
4297                                 // purple : added\r
4298                                 // blue   : modified\r
4299                                 // brown  : missing, deleted, replaced\r
4300                                 // green  : merged (or potential merges)\r
4301                                 // red    : conflicts or sure conflicts\r
4302                                 if(entry->m_Action & CTGitPath::LOGACTIONS_CONFLICT)\r
4303                                 {\r
4304                                         crText = m_Colors.GetColor(CColors::Conflict);\r
4305 \r
4306                                 }else if(entry->m_Action & CTGitPath::LOGACTIONS_MODIFIED)\r
4307                                 {\r
4308                                         crText = m_Colors.GetColor(CColors::Modified);\r
4309 \r
4310                                 }else if(entry->m_Action & CTGitPath::LOGACTIONS_ADDED)\r
4311                                 {\r
4312                                         crText = m_Colors.GetColor(CColors::Added);\r
4313                                 }\r
4314                                 else if(entry->m_Action & CTGitPath::LOGACTIONS_DELETED)\r
4315                                 {\r
4316                                         crText = m_Colors.GetColor(CColors::DeletedNode);\r
4317                                 }\r
4318                                 else if(entry->m_Action & CTGitPath::LOGACTIONS_REPLACED)\r
4319                                 {\r
4320                                         crText = m_Colors.GetColor(CColors::RenamedNode);\r
4321                                 }else\r
4322                                 {\r
4323                                         crText = GetSysColor(COLOR_WINDOWTEXT);\r
4324                                 }\r
4325                                 // Store the color back in the NMLVCUSTOMDRAW struct.\r
4326                                 pLVCD->clrText = crText;\r
4327                         }\r
4328                 }\r
4329                 break;\r
4330         }\r
4331 }\r
4332 \r
4333 BOOL CGitStatusListCtrl::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)\r
4334 {\r
4335         if (pWnd != this)\r
4336                 return CListCtrl::OnSetCursor(pWnd, nHitTest, message);\r
4337         if (!m_bBlock)\r
4338         {\r
4339                 HCURSOR hCur = LoadCursor(NULL, MAKEINTRESOURCE(IDC_ARROW));\r
4340                 SetCursor(hCur);\r
4341                 return CListCtrl::OnSetCursor(pWnd, nHitTest, message);\r
4342         }\r
4343         HCURSOR hCur = LoadCursor(NULL, MAKEINTRESOURCE(IDC_WAIT));\r
4344         SetCursor(hCur);\r
4345         return TRUE;\r
4346 }\r
4347 \r
4348 void CGitStatusListCtrl::RemoveListEntry(int index)\r
4349 {\r
4350 #if 0\r
4351         Locker lock(m_critSec);\r
4352         DeleteItem(index);\r
4353         delete m_arStatusArray[m_arListArray[index]];\r
4354         m_arStatusArray.erase(m_arStatusArray.begin()+m_arListArray[index]);\r
4355         m_arListArray.erase(m_arListArray.begin()+index);\r
4356         for (int i=index; i< (int)m_arListArray.size(); ++i)\r
4357         {\r
4358                 m_arListArray[i]--;\r
4359         }\r
4360 #endif\r
4361 }\r
4362 \r
4363 ///< Set a checkbox on an entry in the listbox\r
4364 // NEVER, EVER call SetCheck directly, because you'll end-up with the checkboxes and the 'checked' flag getting out of sync\r
4365 void CGitStatusListCtrl::SetEntryCheck(CTGitPath* pEntry, int listboxIndex, bool bCheck)\r
4366 {\r
4367         pEntry->m_Checked = bCheck;\r
4368         SetCheck(listboxIndex, bCheck);\r
4369 }\r
4370 \r
4371 #if 0\r
4372 void CGitStatusListCtrl::SetCheckOnAllDescendentsOf(const FileEntry* parentEntry, bool bCheck)\r
4373 {\r
4374 \r
4375         int nListItems = GetItemCount();\r
4376         for (int j=0; j< nListItems ; ++j)\r
4377         {\r
4378                 FileEntry * childEntry = GetListEntry(j);\r
4379                 ASSERT(childEntry != NULL);\r
4380                 if (childEntry == NULL || childEntry == parentEntry)\r
4381                         continue;\r
4382                 if (childEntry->checked != bCheck)\r
4383                 {\r
4384                         if (parentEntry->path.IsAncestorOf(childEntry->path))\r
4385                         {\r
4386                                 SetEntryCheck(childEntry,j,bCheck);\r
4387                                 if(bCheck)\r
4388                                 {\r
4389                                         m_nSelected++;\r
4390                                 }\r
4391                                 else\r
4392                                 {\r
4393                                         m_nSelected--;\r
4394                                 }\r
4395                         }\r
4396                 }\r
4397         }\r
4398 \r
4399 }\r
4400 #endif\r
4401 \r
4402 void CGitStatusListCtrl::WriteCheckedNamesToPathList(CTGitPathList& pathList)\r
4403 {\r
4404 #if 0\r
4405         pathList.Clear();\r
4406         int nListItems = GetItemCount();\r
4407         for (int i=0; i< nListItems; i++)\r
4408         {\r
4409                 const FileEntry* entry = GetListEntry(i);\r
4410                 ASSERT(entry != NULL);\r
4411                 if (entry->IsChecked())\r
4412                 {\r
4413                         pathList.AddPath(entry->path);\r
4414                 }\r
4415         }\r
4416         pathList.SortByPathname();\r
4417 #endif\r
4418 }\r
4419 \r
4420 \r
4421 /// Build a path list of all the selected items in the list (NOTE - SELECTED, not CHECKED)\r
4422 void CGitStatusListCtrl::FillListOfSelectedItemPaths(CTGitPathList& pathList, bool bNoIgnored)\r
4423 {\r
4424         pathList.Clear();\r
4425 \r
4426         POSITION pos = GetFirstSelectedItemPosition();\r
4427         int index;\r
4428         while ((index = GetNextSelectedItem(pos)) >= 0)\r
4429         {\r
4430                 CTGitPath * entry = (CTGitPath*)GetItemData(index);\r
4431                 //if ((bNoIgnored)&&(entry->status == git_wc_status_ignored))\r
4432                 //      continue;\r
4433                 pathList.AddPath(*entry);\r
4434         }\r
4435 }\r
4436 \r
4437 UINT CGitStatusListCtrl::OnGetDlgCode()\r
4438 {\r
4439         // we want to process the return key and not have that one\r
4440         // routed to the default pushbutton\r
4441         return CListCtrl::OnGetDlgCode() | DLGC_WANTALLKEYS;\r
4442 }\r
4443 \r
4444 void CGitStatusListCtrl::OnNMReturn(NMHDR * /*pNMHDR*/, LRESULT *pResult)\r
4445 {\r
4446         *pResult = 0;\r
4447         if (m_bBlock)\r
4448                 return;\r
4449         POSITION pos = GetFirstSelectedItemPosition();\r
4450         while ( pos )\r
4451         {\r
4452                 int index = GetNextSelectedItem(pos);\r
4453                 StartDiff(index);\r
4454         }\r
4455 }\r
4456 \r
4457 void CGitStatusListCtrl::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)\r
4458 {\r
4459         // Since we catch all keystrokes (to have the enter key processed here instead\r
4460         // of routed to the default pushbutton) we have to make sure that other\r
4461         // keys like Tab and Esc still do what they're supposed to do\r
4462         // Tab = change focus to next/previous control\r
4463         // Esc = quit the dialog\r
4464         switch (nChar)\r
4465         {\r
4466         case (VK_TAB):\r
4467                 {\r
4468                         ::PostMessage(GetParent()->GetSafeHwnd(), WM_NEXTDLGCTL, GetKeyState(VK_SHIFT)&0x8000, 0);\r
4469                         return;\r
4470                 }\r
4471                 break;\r
4472         case (VK_ESCAPE):\r
4473                 {\r
4474                         ::SendMessage(GetParent()->GetSafeHwnd(), WM_CLOSE, 0, 0);\r
4475                 }\r
4476                 break;\r
4477         }\r
4478 \r
4479         CListCtrl::OnKeyDown(nChar, nRepCnt, nFlags);\r
4480 }\r
4481 \r
4482 void CGitStatusListCtrl::PreSubclassWindow()\r
4483 {\r
4484         CListCtrl::PreSubclassWindow();\r
4485         EnableToolTips(TRUE);\r
4486         m_Theme.SetWindowTheme(GetSafeHwnd(), L"Explorer", NULL);\r
4487 }\r
4488 \r
4489 INT_PTR CGitStatusListCtrl::OnToolHitTest(CPoint point, TOOLINFO* pTI) const\r
4490 {\r
4491         int row, col;\r
4492         RECT cellrect;\r
4493         row = CellRectFromPoint(point, &cellrect, &col );\r
4494 \r
4495         if (row == -1)\r
4496                 return -1;\r
4497 \r
4498 \r
4499         pTI->hwnd = m_hWnd;\r
4500         pTI->uId = (UINT)((row<<10)+(col&0x3ff)+1);\r
4501         pTI->lpszText = LPSTR_TEXTCALLBACK;\r
4502 \r
4503         pTI->rect = cellrect;\r
4504 \r
4505         return pTI->uId;\r
4506 }\r
4507 \r
4508 int CGitStatusListCtrl::CellRectFromPoint(CPoint& point, RECT *cellrect, int *col) const\r
4509 {\r
4510         int colnum;\r
4511 \r
4512         // Make sure that the ListView is in LVS_REPORT\r
4513         if ((GetWindowLong(m_hWnd, GWL_STYLE) & LVS_TYPEMASK) != LVS_REPORT)\r
4514                 return -1;\r
4515 \r
4516         // Get the top and bottom row visible\r
4517         int row = GetTopIndex();\r
4518         int bottom = row + GetCountPerPage();\r
4519         if (bottom > GetItemCount())\r
4520                 bottom = GetItemCount();\r
4521 \r
4522         // Get the number of columns\r
4523         CHeaderCtrl* pHeader = (CHeaderCtrl*)GetDlgItem(0);\r
4524         int nColumnCount = pHeader->GetItemCount();\r
4525 \r
4526         // Loop through the visible rows\r
4527         for ( ;row <=bottom;row++)\r
4528         {\r
4529                 // Get bounding rect of item and check whether point falls in it.\r
4530                 CRect rect;\r
4531                 GetItemRect(row, &rect, LVIR_BOUNDS);\r
4532                 if (rect.PtInRect(point))\r
4533                 {\r
4534                         // Now find the column\r
4535                         for (colnum = 0; colnum < nColumnCount; colnum++)\r
4536                         {\r
4537                                 int colwidth = GetColumnWidth(colnum);\r
4538                                 if (point.x >= rect.left && point.x <= (rect.left + colwidth))\r
4539                                 {\r
4540                                         RECT rectClient;\r
4541                                         GetClientRect(&rectClient);\r
4542                                         if (col)\r
4543                                                 *col = colnum;\r
4544                                         rect.right = rect.left + colwidth;\r
4545 \r
4546                                         // Make sure that the right extent does not exceed\r
4547                                         // the client area\r
4548                                         if (rect.right > rectClient.right)\r
4549                                                 rect.right = rectClient.right;\r
4550                                         *cellrect = rect;\r
4551                                         return row;\r
4552                                 }\r
4553                                 rect.left += colwidth;\r
4554                         }\r
4555                 }\r
4556         }\r
4557         return -1;\r
4558 }\r
4559 \r
4560 BOOL CGitStatusListCtrl::OnToolTipText(UINT /*id*/, NMHDR *pNMHDR, LRESULT *pResult)\r
4561 {\r
4562 #if 0\r
4563         TOOLTIPTEXTW* pTTTW = (TOOLTIPTEXTW*)pNMHDR;\r
4564         CString strTipText;\r
4565         UINT_PTR nID = pNMHDR->idFrom;\r
4566 \r
4567         if (nID == 0)\r
4568                 return FALSE;\r
4569 \r
4570         UINT_PTR row = ((nID-1) >> 10) & 0x3fffff;\r
4571         UINT_PTR col = (nID-1) & 0x3ff;\r
4572 \r
4573         if (col == 0)\r
4574                 return FALSE;   // no custom tooltip for the path, we use the infotip there!\r
4575 \r
4576         // get the internal column from the visible columns\r
4577         int internalcol = 0;\r
4578         UINT_PTR currentcol = 0;\r
4579     for (;    (currentcol != col) \r
4580            && (internalcol < m_ColumnManager.GetColumnCount()-1)\r
4581          ; ++internalcol)\r
4582         {\r
4583         if (m_ColumnManager.IsVisible (internalcol))\r
4584                         currentcol++;\r
4585         }\r
4586 \r
4587         AFX_MODULE_THREAD_STATE* pModuleThreadState = AfxGetModuleThreadState();\r
4588         CToolTipCtrl* pToolTip = pModuleThreadState->m_pToolTip;\r
4589         pToolTip->SendMessage(TTM_SETMAXTIPWIDTH, 0, 300);\r
4590 \r
4591         *pResult = 0;\r
4592         if ((internalcol == 2)||(internalcol == 4))\r
4593         {\r
4594                 FileEntry *fentry = GetListEntry(row);\r
4595                 if (fentry)\r
4596                 {\r
4597                         if (fentry->copied)\r
4598                         {\r
4599                                 CString url;\r
4600                                 url.Format(IDS_STATUSLIST_COPYFROM, (LPCTSTR)CPathUtils::PathUnescape(fentry->copyfrom_url), (LONG)fentry->copyfrom_rev);\r
4601                                 lstrcpyn(pTTTW->szText, (LPCTSTR)url, 80);\r
4602                                 return TRUE;\r
4603                         }\r
4604                         if (fentry->switched)\r
4605                         {\r
4606                                 CString url;\r
4607                                 url.Format(IDS_STATUSLIST_SWITCHEDTO, (LPCTSTR)CPathUtils::PathUnescape(fentry->url));\r
4608                                 lstrcpyn(pTTTW->szText, (LPCTSTR)url, 80);\r
4609                                 return TRUE;\r
4610                         }\r
4611                         if (fentry->keeplocal)\r
4612                         {\r
4613                                 lstrcpyn(pTTTW->szText, (LPCTSTR)CString(MAKEINTRESOURCE(IDS_STATUSLIST_KEEPLOCAL)), 80);\r
4614                                 return TRUE;\r
4615                         }\r
4616                 }\r
4617         }\r
4618 #endif\r
4619         return FALSE;\r
4620 }\r
4621 \r
4622 void CGitStatusListCtrl::OnPaint()\r
4623 {\r
4624         Default();\r
4625         if ((m_bBusy)||(m_bEmpty))\r
4626         {\r
4627                 CString str;\r
4628                 if (m_bBusy)\r
4629                 {\r
4630                         if (m_sBusy.IsEmpty())\r
4631                                 str.LoadString(IDS_STATUSLIST_BUSYMSG);\r
4632                         else\r
4633                                 str = m_sBusy;\r
4634                 }\r
4635                 else\r
4636                 {\r
4637                         if (m_sEmpty.IsEmpty())\r
4638                                 str.LoadString(IDS_STATUSLIST_EMPTYMSG);\r
4639                         else\r
4640                                 str = m_sEmpty;\r
4641                 }\r
4642                 COLORREF clrText = ::GetSysColor(COLOR_WINDOWTEXT);\r
4643                 COLORREF clrTextBk;\r
4644                 if (IsWindowEnabled())\r
4645                         clrTextBk = ::GetSysColor(COLOR_WINDOW);\r
4646                 else\r
4647                         clrTextBk = ::GetSysColor(COLOR_3DFACE);\r
4648 \r
4649                 CRect rc;\r
4650                 GetClientRect(&rc);\r
4651                 CHeaderCtrl* pHC;\r
4652                 pHC = GetHeaderCtrl();\r
4653                 if (pHC != NULL)\r
4654                 {\r
4655                         CRect rcH;\r
4656                         pHC->GetItemRect(0, &rcH);\r
4657                         rc.top += rcH.bottom;\r
4658                 }\r
4659                 CDC* pDC = GetDC();\r
4660                 {\r
4661                         CMyMemDC memDC(pDC, &rc);\r
4662 \r
4663                         memDC.SetTextColor(clrText);\r
4664                         memDC.SetBkColor(clrTextBk);\r
4665                         memDC.FillSolidRect(rc, clrTextBk);\r
4666                         rc.top += 10;\r
4667                         CGdiObject * oldfont = memDC.SelectStockObject(DEFAULT_GUI_FONT);\r
4668                         memDC.DrawText(str, rc, DT_CENTER | DT_VCENTER |\r
4669                                 DT_WORDBREAK | DT_NOPREFIX | DT_NOCLIP);\r
4670                         memDC.SelectObject(oldfont);\r
4671                 }\r
4672                 ReleaseDC(pDC);\r
4673         }\r
4674 }\r
4675 \r
4676 // prevent users from extending our hidden (size 0) columns\r
4677 void CGitStatusListCtrl::OnHdnBegintrack(NMHDR *pNMHDR, LRESULT *pResult)\r
4678 {\r
4679         LPNMHEADER phdr = reinterpret_cast<LPNMHEADER>(pNMHDR);\r
4680         *pResult = 0;\r
4681         if ((phdr->iItem < 0)||(phdr->iItem >= SVNSLC_NUMCOLUMNS))\r
4682                 return;\r
4683 \r
4684     if (m_ColumnManager.IsVisible (phdr->iItem))\r
4685         {\r
4686                 return;\r
4687         }\r
4688         *pResult = 1;\r
4689 }\r
4690 \r
4691 // prevent any function from extending our hidden (size 0) columns\r
4692 void CGitStatusListCtrl::OnHdnItemchanging(NMHDR *pNMHDR, LRESULT *pResult)\r
4693 {\r
4694         LPNMHEADER phdr = reinterpret_cast<LPNMHEADER>(pNMHDR);\r
4695         *pResult = 0;\r
4696     if ((phdr->iItem < 0)||(phdr->iItem >= m_ColumnManager.GetColumnCount()))\r
4697         {\r
4698                 Default();\r
4699                 return;\r
4700         }\r
4701 \r
4702     // visible columns may be modified \r
4703 \r
4704     if (m_ColumnManager.IsVisible (phdr->iItem))\r
4705         {\r
4706                 Default();\r
4707                 return;\r
4708         }\r
4709 \r
4710     // columns already marked as "invisible" internally may be (re-)sized to 0\r
4711 \r
4712     if (   (phdr->pitem != NULL) \r
4713         && (phdr->pitem->mask == HDI_WIDTH)\r
4714         && (phdr->pitem->cxy == 0))\r
4715         {\r
4716                 Default();\r
4717                 return;\r
4718         }\r
4719 \r
4720         if (   (phdr->pitem != NULL) \r
4721                 && (phdr->pitem->mask != HDI_WIDTH))\r
4722         {\r
4723                 Default();\r
4724                 return;\r
4725         }\r
4726 \r
4727     *pResult = 1;\r
4728 }\r
4729 \r
4730 void CGitStatusListCtrl::OnDestroy()\r
4731 {\r
4732         SaveColumnWidths(true);\r
4733         CListCtrl::OnDestroy();\r
4734 }\r
4735 \r
4736 void CGitStatusListCtrl::OnBeginDrag(NMHDR* /*pNMHDR*/, LRESULT* pResult)\r
4737 {\r
4738 #if 0\r
4739         Locker lock(m_critSec);\r
4740         CDropFiles dropFiles; // class for creating DROPFILES struct\r
4741 \r
4742         int index;\r
4743         POSITION pos = GetFirstSelectedItemPosition();\r
4744         while ( (index = GetNextSelectedItem(pos)) >= 0 )\r
4745         {\r
4746                 FileEntry * fentry = m_arStatusArray[m_arListArray[index]];\r
4747                 CTGitPath path = fentry->GetPath();\r
4748                 dropFiles.AddFile( path.GetWinPathString() );\r
4749         }\r
4750 \r
4751         if ( dropFiles.GetCount()>0 )\r
4752         {\r
4753                 m_bOwnDrag = true;\r
4754                 dropFiles.CreateStructure();\r
4755                 m_bOwnDrag = false;\r
4756         }\r
4757 #endif\r
4758         *pResult = 0;\r
4759 }\r
4760 \r
4761 void CGitStatusListCtrl::SaveColumnWidths(bool bSaveToRegistry /* = false */)\r
4762 {\r
4763         int maxcol = ((CHeaderCtrl*)(GetDlgItem(0)))->GetItemCount()-1;\r
4764         for (int col = 0; col <= maxcol; col++)\r
4765         if (m_ColumnManager.IsVisible (col))\r
4766             m_ColumnManager.ColumnResized (col);\r
4767 \r
4768         if (bSaveToRegistry)\r
4769         m_ColumnManager.WriteSettings();\r
4770 }\r
4771 \r
4772 bool CGitStatusListCtrl::EnableFileDrop()\r
4773 {\r
4774         m_bFileDropsEnabled = true;\r
4775         return true;\r
4776 }\r
4777 \r
4778 bool CGitStatusListCtrl::HasPath(const CTGitPath& path)\r
4779 {\r
4780 #if 0\r
4781         for (size_t i=0; i < m_arStatusArray.size(); i++)\r
4782         {\r
4783                 FileEntry * entry = m_arStatusArray[i];\r
4784                 if (entry->GetPath().IsEquivalentTo(path))\r
4785                         return true;\r
4786         }\r
4787 #endif\r
4788         return false;\r
4789 }\r
4790 \r
4791 bool CGitStatusListCtrl::IsPathShown(const CTGitPath& path)\r
4792 {\r
4793 #if 0\r
4794         int itemCount = GetItemCount();\r
4795         for (int i=0; i < itemCount; i++)\r
4796         {\r
4797                 FileEntry * entry = GetListEntry(i);\r
4798                 if (entry->GetPath().IsEquivalentTo(path))\r
4799                         return true;\r
4800         }\r
4801 #endif\r
4802         return false;\r
4803 }\r
4804 \r
4805 BOOL CGitStatusListCtrl::PreTranslateMessage(MSG* pMsg)\r
4806 {\r
4807         if (pMsg->message == WM_KEYDOWN)\r
4808         {\r
4809                 switch (pMsg->wParam)\r
4810                 {\r
4811                 case 'A':\r
4812                         {\r
4813                                 if (GetAsyncKeyState(VK_CONTROL)&0x8000)\r
4814                                 {\r
4815                                         // select all entries\r
4816                                         for (int i=0; i<GetItemCount(); ++i)\r
4817                                         {\r
4818                                                 SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);\r
4819                                         }\r
4820                                         return TRUE;\r
4821                                 }\r
4822                         }\r
4823                         break;\r
4824                 case 'C':\r
4825                 case VK_INSERT:\r
4826                         {\r
4827                                 if (GetAsyncKeyState(VK_CONTROL)&0x8000)\r
4828                                 {\r
4829                                         // copy all selected paths to the clipboard\r
4830                                         if (GetAsyncKeyState(VK_SHIFT)&0x8000)\r
4831                                                 CopySelectedEntriesToClipboard(SVNSLC_COLSTATUS);\r
4832                                         else\r
4833                                                 CopySelectedEntriesToClipboard(0);\r
4834                                         return TRUE;\r
4835                                 }\r
4836                         }\r
4837                         break;\r
4838                 }\r
4839         }\r
4840 \r
4841         return CListCtrl::PreTranslateMessage(pMsg);\r
4842 }\r
4843 \r
4844 bool CGitStatusListCtrl::CopySelectedEntriesToClipboard(DWORD dwCols)\r
4845 {\r
4846 #if 0\r
4847         static CString ponly(MAKEINTRESOURCE(IDS_STATUSLIST_PROPONLY));\r
4848         static HINSTANCE hResourceHandle(AfxGetResourceHandle());\r
4849         WORD langID = (WORD)CRegStdWORD(_T("Software\\TortoiseGit\\LanguageID"), GetUserDefaultLangID());\r
4850 \r
4851         CString sClipboard;\r
4852         CString temp;\r
4853         TCHAR buf[100];\r
4854         if (GetSelectedCount() == 0)\r
4855                 return false;\r
4856         // first add the column titles as the first line\r
4857         temp.LoadString(IDS_STATUSLIST_COLFILE);\r
4858         sClipboard = temp;\r
4859 \r
4860     DWORD selection = 0;\r
4861     for (int i = 0, count = m_ColumnManager.GetColumnCount(); i < count; ++i)\r
4862         if (   ((dwCols == -1) && m_ColumnManager.IsVisible (i))\r
4863             || ((dwCols != 1) && (i < 32) && ((dwCols & (1 << i)) != 0)))\r
4864         {\r
4865             sClipboard += _T("\t") + m_ColumnManager.GetName(i);\r
4866 \r
4867             if (i < 32)\r
4868                 selection += 1 << i;\r
4869         }\r
4870 \r
4871         sClipboard += _T("\r\n");\r
4872 \r
4873         POSITION pos = GetFirstSelectedItemPosition();\r
4874         int index;\r
4875         while ((index = GetNextSelectedItem(pos)) >= 0)\r
4876         {\r
4877                 FileEntry * entry = GetListEntry(index);\r
4878                 sClipboard += entry->GetDisplayName();\r
4879                 if (selection & SVNSLC_COLFILENAME)\r
4880                 {\r
4881                         sClipboard += _T("\t")+entry->path.GetFileOrDirectoryName();\r
4882                 }\r
4883                 if (selection & SVNSLC_COLEXT)\r
4884                 {\r
4885                         sClipboard += _T("\t")+entry->path.GetFileExtension();\r
4886                 }\r
4887                 if (selection & SVNSLC_COLSTATUS)\r
4888                 {\r
4889                         if (entry->isNested)\r
4890                         {\r
4891                                 temp.LoadString(IDS_STATUSLIST_NESTED);\r
4892                         }\r
4893                         else\r
4894                         {\r
4895                                 GitStatus::GetStatusString(hResourceHandle, entry->status, buf, sizeof(buf)/sizeof(TCHAR), (WORD)langID);\r
4896                                 if ((entry->copied)&&(_tcslen(buf)>1))\r
4897                                         _tcscat_s(buf, 100, _T(" (+)"));\r
4898                                 if ((entry->switched)&&(_tcslen(buf)>1))\r
4899                                         _tcscat_s(buf, 100, _T(" (s)"));\r
4900                                 if ((entry->status == entry->propstatus)&&\r
4901                                         (entry->status != git_wc_status_normal)&&\r
4902                                         (entry->status != git_wc_status_unversioned)&&\r
4903                                         (!GitStatus::IsImportant(entry->textstatus)))\r
4904                                         _tcscat_s(buf, 100, ponly);\r
4905                                 temp = buf;\r
4906                         }\r
4907                         sClipboard += _T("\t")+temp;\r
4908                 }\r
4909                 if (selection & SVNSLC_COLTEXTSTATUS)\r
4910                 {\r
4911                         if (entry->isNested)\r
4912                         {\r
4913                                 temp.LoadString(IDS_STATUSLIST_NESTED);\r
4914                         }\r
4915                         else\r
4916                         {\r
4917                                 GitStatus::GetStatusString(hResourceHandle, entry->textstatus, buf, sizeof(buf)/sizeof(TCHAR), (WORD)langID);\r
4918                                 if ((entry->copied)&&(_tcslen(buf)>1))\r
4919                                         _tcscat_s(buf, 100, _T(" (+)"));\r
4920                                 if ((entry->switched)&&(_tcslen(buf)>1))\r
4921                                         _tcscat_s(buf, 100, _T(" (s)"));\r
4922                                 temp = buf;\r
4923                         }\r
4924                         sClipboard += _T("\t")+temp;\r
4925                 }\r
4926                 if (selection & SVNSLC_COLREMOTESTATUS)\r
4927                 {\r
4928                         if (entry->isNested)\r
4929                         {\r
4930                                 temp.LoadString(IDS_STATUSLIST_NESTED);\r
4931                         }\r
4932                         else\r
4933                         {\r
4934                                 GitStatus::GetStatusString(hResourceHandle, entry->remotestatus, buf, sizeof(buf)/sizeof(TCHAR), (WORD)langID);\r
4935                                 if ((entry->copied)&&(_tcslen(buf)>1))\r
4936                                         _tcscat_s(buf, 100, _T(" (+)"));\r
4937                                 if ((entry->switched)&&(_tcslen(buf)>1))\r
4938                                         _tcscat_s(buf, 100, _T(" (s)"));\r
4939                                 if ((entry->remotestatus == entry->remotepropstatus)&&\r
4940                                         (entry->remotestatus != git_wc_status_none)&&\r
4941                                         (entry->remotestatus != git_wc_status_normal)&&\r
4942                                         (entry->remotestatus != git_wc_status_unversioned)&&\r
4943                                         (!SVNStatus::IsImportant(entry->remotetextstatus)))\r
4944                                         _tcscat_s(buf, 100, ponly);\r
4945                                 temp = buf;\r
4946                         }\r
4947                         sClipboard += _T("\t")+temp;\r
4948                 }\r
4949                 if (selection & GitSLC_COLPROPSTATUS)\r
4950                 {\r
4951                         if (entry->isNested)\r
4952                         {\r
4953                                 temp.Empty();\r
4954                         }\r
4955                         else\r
4956                         {\r
4957                                 GitStatus::GetStatusString(hResourceHandle, entry->propstatus, buf, sizeof(buf)/sizeof(TCHAR), (WORD)langID);\r
4958                                 if ((entry->copied)&&(_tcslen(buf)>1))\r
4959                                         _tcscat_s(buf, 100, _T(" (+)"));\r
4960                                 if ((entry->switched)&&(_tcslen(buf)>1))\r
4961                                         _tcscat_s(buf, 100, _T(" (s)"));\r
4962                                 temp = buf;\r
4963                         }\r
4964                         sClipboard += _T("\t")+temp;\r
4965                 }\r
4966                 if (selection & SVNSLC_COLREMOTETEXT)\r
4967                 {\r
4968                         if (entry->isNested)\r
4969                         {\r
4970                                 temp.Empty();\r
4971                         }\r
4972                         else\r
4973                         {\r
4974                                 GitStatus::GetStatusString(hResourceHandle, entry->remotetextstatus, buf, sizeof(buf)/sizeof(TCHAR), (WORD)langID);\r
4975                                 temp = buf;\r
4976                         }\r
4977                         sClipboard += _T("\t")+temp;\r
4978                 }\r
4979                 if (selection & SVNSLC_COLREMOTEPROP)\r
4980                 {\r
4981                         // SVNSLC_COLREMOTEPROP\r
4982                         if (entry->isNested)\r
4983                         {\r
4984                                 temp.Empty();\r
4985                         }\r
4986                         else\r
4987                         {\r
4988                                 GitStatus::GetStatusString(hResourceHandle, entry->remotepropstatus, buf, sizeof(buf)/sizeof(TCHAR), (WORD)langID);\r
4989                                 temp = buf;\r
4990                         }\r
4991                         sClipboard += _T("\t")+temp;\r
4992                 }\r
4993                 if (selection & SVNSLC_COLURL)\r
4994                         sClipboard += _T("\t")+entry->url;\r
4995                 if (selection & SVNSLC_COLLOCK)\r
4996                 {\r
4997                         if (!m_HeadRev.IsHead())\r
4998                         {\r
4999                                 // we have contacted the repository\r
5000 \r
5001                                 // decision-matrix\r
5002                                 // wc           repository              text\r
5003                                 // ""           ""                              ""\r
5004                                 // ""           UID1                    owner\r
5005                                 // UID1         UID1                    owner\r
5006                                 // UID1         ""                              lock has been broken\r
5007                                 // UID1         UID2                    lock has been stolen\r
5008                                 if (entry->lock_token.IsEmpty() || (entry->lock_token.Compare(entry->lock_remotetoken)==0))\r
5009                                 {\r
5010                                         if (entry->lock_owner.IsEmpty())\r
5011                                                 temp = entry->lock_remoteowner;\r
5012                                         else\r
5013                                                 temp = entry->lock_owner;\r
5014                                 }\r
5015                                 else if (entry->lock_remotetoken.IsEmpty())\r
5016                                 {\r
5017                                         // broken lock\r
5018                                         temp.LoadString(IDS_STATUSLIST_LOCKBROKEN);\r
5019                                 }\r
5020                                 else\r
5021                                 {\r
5022                                         // stolen lock\r
5023                                         temp.Format(IDS_STATUSLIST_LOCKSTOLEN, (LPCTSTR)entry->lock_remoteowner);\r
5024                                 }\r
5025                         }\r
5026                         else\r
5027                                 temp = entry->lock_owner;\r
5028                         sClipboard += _T("\t")+temp;\r
5029                 }\r
5030                 if (selection & SVNSLC_COLLOCKCOMMENT)\r
5031                         sClipboard += _T("\t")+entry->lock_comment;\r
5032                 if (selection & SVNSLC_COLAUTHOR)\r
5033                         sClipboard += _T("\t")+entry->last_commit_author;\r
5034                 if (selection & SVNSLC_COLREVISION)\r
5035                 {\r
5036                         temp.Format(_T("%ld"), entry->last_commit_rev);\r
5037                         if (entry->last_commit_rev == 0)\r
5038                                 temp.Empty();\r
5039                         sClipboard += _T("\t")+temp;\r
5040                 }\r
5041                 if (selection & SVNSLC_COLREMOTEREVISION)\r
5042                 {\r
5043                         temp.Format(_T("%ld"), entry->remoterev);\r
5044                         if (entry->remoterev == 0)\r
5045                                 temp.Empty();\r
5046                         sClipboard += _T("\t")+temp;\r
5047                 }\r
5048                 if (selection & SVNSLC_COLDATE)\r
5049                 {\r
5050                         TCHAR datebuf[SVN_DATE_BUFFER];\r
5051                         apr_time_t date = entry->last_commit_date;\r
5052                         SVN::formatDate(datebuf, date, true);\r
5053                         if (date)\r
5054                                 temp = datebuf;\r
5055                         else\r
5056                                 temp.Empty();\r
5057                         sClipboard += _T("\t")+temp;\r
5058                 }\r
5059                 if (selection & SVNSLC_COLCOPYFROM)\r
5060                 {\r
5061                         if (m_sURL.Compare(entry->copyfrom_url.Left(m_sURL.GetLength()))==0)\r
5062                                 temp = entry->copyfrom_url.Mid(m_sURL.GetLength());\r
5063                         else\r
5064                                 temp = entry->copyfrom_url;\r
5065                         sClipboard += _T("\t")+temp;\r
5066                 }\r
5067 \r
5068         for ( int i = SVNSLC_NUMCOLUMNS, count = m_ColumnManager.GetColumnCount()\r
5069             ; i < count\r
5070             ; ++i)\r
5071         {\r
5072             if ((dwCols == -1) && m_ColumnManager.IsVisible (i))\r
5073             {\r
5074                 CString value \r
5075                     = entry->present_props[m_ColumnManager.GetName(i)];\r
5076                 sClipboard += _T("\t") + value;\r
5077             }\r
5078         }\r
5079 \r
5080                 sClipboard += _T("\r\n");\r
5081         }\r
5082 \r
5083         return CStringUtils::WriteAsciiStringToClipboard(sClipboard);\r
5084 #endif\r
5085         return TRUE;\r
5086 \r
5087 }\r
5088 \r
5089 size_t CGitStatusListCtrl::GetNumberOfChangelistsInSelection()\r
5090 {\r
5091 #if 0\r
5092         std::set<CString> changelists;\r
5093         POSITION pos = GetFirstSelectedItemPosition();\r
5094         int index;\r
5095         while ((index = GetNextSelectedItem(pos)) >= 0)\r
5096         {\r
5097                 FileEntry * entry = GetListEntry(index);\r
5098                 if (!entry->changelist.IsEmpty())\r
5099                         changelists.insert(entry->changelist);\r
5100         }\r
5101         return changelists.size();\r
5102 #endif \r
5103         return 0;\r
5104 }\r
5105 \r
5106 bool CGitStatusListCtrl::PrepareGroups(bool bForce /* = false */)\r
5107 {\r
5108 \r
5109         bool bHasGroups=false;\r
5110         if ( this->m_UnRevFileList.GetCount()>0 || \r
5111                 this->m_IgnoreFileList.GetCount()>0 || bForce)\r
5112         {\r
5113                 bHasGroups = true;\r
5114         }\r
5115 \r
5116         RemoveAllGroups();\r
5117         EnableGroupView(bHasGroups);\r
5118         \r
5119         TCHAR groupname[1024];\r
5120         int groupindex = 0;\r
5121 \r
5122         if(bHasGroups);\r
5123         {\r
5124                 LVGROUP grp = {0};\r
5125                 grp.cbSize = sizeof(LVGROUP);\r
5126                 grp.mask = LVGF_ALIGN | LVGF_GROUPID | LVGF_HEADER;\r
5127                 CString sUnassignedName(_T("Modified File"));\r
5128                 _tcsncpy_s(groupname, 1024, (LPCTSTR)sUnassignedName, 1023);\r
5129                 grp.pszHeader = groupname;\r
5130                 grp.iGroupId = groupindex;\r
5131                 grp.uAlign = LVGA_HEADER_LEFT;\r
5132                 InsertGroup(groupindex++, &grp);\r
5133 \r
5134                 //if(m_UnRevFileList.GetCount()>0)\r
5135                 {\r
5136                         _tcsncpy_s(groupname, 1024, (LPCTSTR)_T("No Version Control"), 1023);\r
5137                         grp.pszHeader = groupname;\r
5138                         grp.iGroupId = groupindex;\r
5139                         grp.uAlign = LVGA_HEADER_LEFT;\r
5140                         InsertGroup(groupindex++, &grp);\r
5141                 }\r
5142 \r
5143                 //if(m_IgnoreFileList.GetCount()>0)\r
5144                 {\r
5145                         _tcsncpy_s(groupname, 1024, (LPCTSTR)_T("Ignored File"), 1023);\r
5146                         grp.pszHeader = groupname;\r
5147                         grp.iGroupId = groupindex;\r
5148                         grp.uAlign = LVGA_HEADER_LEFT;\r
5149                         InsertGroup(groupindex++, &grp);\r
5150                 }\r
5151 \r
5152         }\r
5153 \r
5154 \r
5155         m_bHasIgnoreGroup = false;\r
5156 \r
5157         // now add the items which don't belong to a group\r
5158         LVGROUP grp = {0};\r
5159         grp.cbSize = sizeof(LVGROUP);\r
5160         grp.mask = LVGF_ALIGN | LVGF_GROUPID | LVGF_HEADER;\r
5161         CString sUnassignedName(MAKEINTRESOURCE(IDS_STATUSLIST_UNASSIGNED_CHANGESET));\r
5162         _tcsncpy_s(groupname, 1024, (LPCTSTR)sUnassignedName, 1023);\r
5163         grp.pszHeader = groupname;\r
5164         grp.iGroupId = groupindex;\r
5165         grp.uAlign = LVGA_HEADER_LEFT;\r
5166         InsertGroup(groupindex++, &grp);\r
5167 \r
5168         for (std::map<CString,int>::iterator it = m_changelists.begin(); it != m_changelists.end(); ++it)\r
5169         {\r
5170                 if (it->first.Compare(SVNSLC_IGNORECHANGELIST)!=0)\r
5171                 {\r
5172                         LVGROUP grp = {0};\r
5173                         grp.cbSize = sizeof(LVGROUP);\r
5174                         grp.mask = LVGF_ALIGN | LVGF_GROUPID | LVGF_HEADER;\r
5175                         _tcsncpy_s(groupname, 1024, it->first, 1023);\r
5176                         grp.pszHeader = groupname;\r
5177                         grp.iGroupId = groupindex;\r
5178                         grp.uAlign = LVGA_HEADER_LEFT;\r
5179                         it->second = InsertGroup(groupindex++, &grp);\r
5180                 }\r
5181                 else\r
5182                         m_bHasIgnoreGroup = true;\r
5183         }\r
5184 \r
5185         if (m_bHasIgnoreGroup)\r
5186         {\r
5187                 // and now add the group 'ignore-on-commit'\r
5188                 std::map<CString,int>::iterator it = m_changelists.find(SVNSLC_IGNORECHANGELIST);\r
5189                 if (it != m_changelists.end())\r
5190                 {\r
5191                         grp.cbSize = sizeof(LVGROUP);\r
5192                         grp.mask = LVGF_ALIGN | LVGF_GROUPID | LVGF_HEADER;\r
5193                         _tcsncpy_s(groupname, 1024, SVNSLC_IGNORECHANGELIST, 1023);\r
5194                         grp.pszHeader = groupname;\r
5195                         grp.iGroupId = groupindex;\r
5196                         grp.uAlign = LVGA_HEADER_LEFT;\r
5197                         it->second = InsertGroup(groupindex, &grp);\r
5198                 }\r
5199         }\r
5200 \r
5201         return bHasGroups;\r
5202 }\r
5203 \r
5204 void CGitStatusListCtrl::NotifyCheck()\r
5205 {\r
5206         CWnd* pParent = GetParent();\r
5207         if (NULL != pParent && NULL != pParent->GetSafeHwnd())\r
5208         {\r
5209                 pParent->SendMessage(SVNSLNM_CHECKCHANGED, m_nSelected);\r
5210         }\r
5211 }\r
5212 \r
5213 int CGitStatusListCtrl::UpdateFileList(git_revnum_t hash,CTGitPathList *list)\r
5214 {\r
5215         CString out;\r
5216         this->m_bBusy=TRUE;\r
5217         m_CurrentVersion=hash;\r
5218 \r
5219         if(hash == GIT_REV_ZERO)\r
5220         {\r
5221                 int count = 0;\r
5222                 if(list == NULL)\r
5223                         count = 1;\r
5224                 else\r
5225                         count = list->GetCount();\r
5226 \r
5227                 for(int i=0;i<count;i++)\r
5228                 {       \r
5229                         CString cmdout;\r
5230                         CString cmd;\r
5231                         if(list == NULL)\r
5232                                 cmd=(_T("git.exe diff-index --raw HEAD --numstat -C -M"));\r
5233                         else\r
5234                                 cmd.Format(_T("git.exe diff-index --raw HEAD --numstat -C -M -- \"%s\""),(*list)[i].GetGitPathString());\r
5235 \r
5236                         if(g_Git.Run(cmd,&cmdout))\r
5237                         {\r
5238                                 cmdout.Empty();\r
5239                                 if(g_Git.Run(_T("git.exe rev-parse --revs-only HEAD"),&cmdout))\r
5240                                 {\r
5241                                         CMessageBox::Show(NULL,cmdout,_T("TortoiseGit"),MB_OK);\r
5242                                         return -1;\r
5243                                 }\r
5244                                 if(cmdout.IsEmpty())\r
5245                                         break; //this is initial repositoyr, there are no any history\r
5246 \r
5247                                 CMessageBox::Show(NULL,cmdout,_T("TortoiseGit"),MB_OK);\r
5248                                 return -1;\r
5249 \r
5250                         }\r
5251 \r
5252                         out+=cmdout;\r
5253                 }\r
5254 \r
5255 \r
5256                 this->m_StatusFileList.ParserFromLog(out);\r
5257         }else\r
5258         {\r
5259                 int count = 0;\r
5260                 if(list == NULL)\r
5261                         count = 1;\r
5262                 else\r
5263                         count = list->GetCount();\r
5264 \r
5265                 for(int i=0;i<count;i++)\r
5266                 {       \r
5267                         CString cmdout;\r
5268                         CString cmd;\r
5269                         if(list == NULL)\r
5270                                 cmd.Format(_T("git.exe diff-tree --raw --numstat -C -M %s"),hash);\r
5271                         else\r
5272                                 cmd.Format(_T("git.exe diff-tree --raw  --numstat -C -M %s -- \"%s\""),hash,(*list)[i].GetGitPathString());\r
5273 \r
5274                         g_Git.Run(cmd,&cmdout);\r
5275 \r
5276                         out+=cmdout;\r
5277                 }\r
5278                 this->m_StatusFileList.ParserFromLog(out);\r
5279 \r
5280         }\r
5281         for(int i=0;i<m_StatusFileList.GetCount();i++)\r
5282         {\r
5283                 CTGitPath * gitpatch=(CTGitPath*)&m_StatusFileList[i];\r
5284                 gitpatch->m_Checked = TRUE;\r
5285                 m_arStatusArray.push_back((CTGitPath*)&m_StatusFileList[i]);\r
5286         }\r
5287         this->m_bBusy=FALSE;\r
5288         return 0;\r
5289 }\r
5290 \r
5291 int CGitStatusListCtrl::UpdateWithGitPathList(CTGitPathList &list)\r
5292 {\r
5293         m_arStatusArray.clear();\r
5294         for(int i=0;i<list.GetCount();i++)\r
5295         {\r
5296                 CTGitPath * gitpatch=(CTGitPath*)&list[i];\r
5297                 gitpatch->m_Checked = TRUE;\r
5298                 m_arStatusArray.push_back((CTGitPath*)&list[i]);\r
5299         }\r
5300         return 0;\r
5301 }\r
5302 \r
5303 int CGitStatusListCtrl::UpdateUnRevFileList(CTGitPathList *List)\r
5304 {\r
5305         this->m_UnRevFileList.FillUnRev(CTGitPath::LOGACTIONS_UNVER,List);\r
5306         for(int i=0;i<m_UnRevFileList.GetCount();i++)\r
5307         {\r
5308                 CTGitPath * gitpatch=(CTGitPath*)&m_UnRevFileList[i];\r
5309                 gitpatch->m_Checked = FALSE;\r
5310                 m_arStatusArray.push_back((CTGitPath*)&m_UnRevFileList[i]);\r
5311         }\r
5312         return 0;\r
5313 }\r
5314 \r
5315 int CGitStatusListCtrl::UpdateIgnoreFileList(CTGitPathList *List)\r
5316 {\r
5317         this->m_IgnoreFileList.FillUnRev(CTGitPath::LOGACTIONS_UNVER|CTGitPath::LOGACTIONS_IGNORE,List);\r
5318         for(int i=0;i<m_IgnoreFileList.GetCount();i++)\r
5319         {\r
5320                 CTGitPath * gitpatch=(CTGitPath*)&m_IgnoreFileList[i];\r
5321                 gitpatch->m_Checked = FALSE;\r
5322                 m_arStatusArray.push_back((CTGitPath*)&m_IgnoreFileList[i]);\r
5323         }\r
5324         return 0;\r
5325 }\r
5326 int CGitStatusListCtrl::UpdateFileList(int mask,bool once,CTGitPathList *List)\r
5327 {\r
5328         if(mask&CGitStatusListCtrl::FILELIST_MODIFY)\r
5329         {\r
5330                 if(once || (!(m_FileLoaded&CGitStatusListCtrl::FILELIST_MODIFY)))\r
5331                 {\r
5332                         UpdateFileList(git_revnum_t(GIT_REV_ZERO),List);\r
5333                         m_FileLoaded|=CGitStatusListCtrl::FILELIST_MODIFY;\r
5334                 }\r
5335         }\r
5336         if(mask&CGitStatusListCtrl::FILELIST_UNVER)\r
5337         {\r
5338                 if(once || (!(m_FileLoaded&CGitStatusListCtrl::FILELIST_UNVER)))\r
5339                 {\r
5340                         UpdateUnRevFileList(List);\r
5341                         m_FileLoaded|=CGitStatusListCtrl::FILELIST_UNVER;\r
5342                 }\r
5343         }\r
5344         return 0;\r
5345 }\r
5346 //////////////////////////////////////////////////////////////////////////\r
5347 #if 0\r
5348 bool CGitStatusListCtrlDropTarget::OnDrop(FORMATETC* pFmtEtc, STGMEDIUM& medium, DWORD * /*pdwEffect*/, POINTL pt)\r
5349 {\r
5350         if(pFmtEtc->cfFormat == CF_HDROP && medium.tymed == TYMED_HGLOBAL)\r
5351         {\r
5352                 HDROP hDrop = (HDROP)GlobalLock(medium.hGlobal);\r
5353                 if(hDrop != NULL)\r
5354                 {\r
5355                         TCHAR szFileName[MAX_PATH];\r
5356 \r
5357                         UINT cFiles = DragQueryFile(hDrop, 0xFFFFFFFF, NULL, 0);\r
5358 \r
5359                         POINT clientpoint;\r
5360                         clientpoint.x = pt.x;\r
5361                         clientpoint.y = pt.y;\r
5362                         ScreenToClient(m_hTargetWnd, &clientpoint);\r
5363                         if ((m_pSVNStatusListCtrl->IsGroupViewEnabled())&&(m_pSVNStatusListCtrl->GetGroupFromPoint(&clientpoint) >= 0))\r
5364                         {\r
5365                                 CTSVNPathList changelistItems;\r
5366                                 for(UINT i = 0; i < cFiles; ++i)\r
5367                                 {\r
5368                                         DragQueryFile(hDrop, i, szFileName, sizeof(szFileName));\r
5369                                         changelistItems.AddPath(CTSVNPath(szFileName));\r
5370                                 }\r
5371                                 // find the changelist name\r
5372                                 CString sChangelist;\r
5373                                 LONG_PTR nGroup = m_pSVNStatusListCtrl->GetGroupFromPoint(&clientpoint);\r
5374                                 for (std::map<CString, int>::iterator it = m_pSVNStatusListCtrl->m_changelists.begin(); it != m_pSVNStatusListCtrl->m_changelists.end(); ++it)\r
5375                                         if (it->second == nGroup)\r
5376                                                 sChangelist = it->first;\r
5377                                 if (!sChangelist.IsEmpty())\r
5378                                 {\r
5379                                         SVN git;\r
5380                                         if (git.AddToChangeList(changelistItems, sChangelist, git_depth_empty))\r
5381                                         {\r
5382                                                 for (int l=0; l<changelistItems.GetCount(); ++l)\r
5383                                                 {\r
5384                                                         int index = m_pSVNStatusListCtrl->GetIndex(changelistItems[l]);\r
5385                                                         if (index >= 0)\r
5386                                                         {\r
5387                                                                 CSVNStatusListCtrl::FileEntry * e = m_pSVNStatusListCtrl->GetListEntry(index);\r
5388                                                                 if (e)\r
5389                                                                 {\r
5390                                                                         e->changelist = sChangelist;\r
5391                                                                         if (!e->IsFolder())\r
5392                                                                         {\r
5393                                                                                 if (m_pSVNStatusListCtrl->m_changelists.find(e->changelist)!=m_pSVNStatusListCtrl->m_changelists.end())\r
5394                                                                                         m_pSVNStatusListCtrl->SetItemGroup(index, m_pSVNStatusListCtrl->m_changelists[e->changelist]);\r
5395                                                                                 else\r
5396                                                                                         m_pSVNStatusListCtrl->SetItemGroup(index, 0);\r
5397                                                                         }\r
5398                                                                 }\r
5399                                                         }\r
5400                                                         else\r
5401                                                         {\r
5402                                                                 HWND hParentWnd = GetParent(m_hTargetWnd);\r
5403                                                                 if (hParentWnd != NULL)\r
5404                                                                         ::SendMessage(hParentWnd, CSVNStatusListCtrl::SVNSLNM_ADDFILE, 0, (LPARAM)changelistItems[l].GetWinPath());\r
5405                                                         }\r
5406                                                 }\r
5407                                         }\r
5408                                         else\r
5409                                         {\r
5410                                                 CMessageBox::Show(m_pSVNStatusListCtrl->m_hWnd, git.GetLastErrorMessage(), _T("TortoiseSVN"), MB_ICONERROR);\r
5411                                         }\r
5412                                 }\r
5413                                 else\r
5414                                 {\r
5415                                         SVN git;\r
5416                                         if (git.RemoveFromChangeList(changelistItems, CStringArray(), git_depth_empty))\r
5417                                         {\r
5418                                                 for (int l=0; l<changelistItems.GetCount(); ++l)\r
5419                                                 {\r
5420                                                         int index = m_pSVNStatusListCtrl->GetIndex(changelistItems[l]);\r
5421                                                         if (index >= 0)\r
5422                                                         {\r
5423                                                                 CSVNStatusListCtrl::FileEntry * e = m_pSVNStatusListCtrl->GetListEntry(index);\r
5424                                                                 if (e)\r
5425                                                                 {\r
5426                                                                         e->changelist = sChangelist;\r
5427                                                                         m_pSVNStatusListCtrl->SetItemGroup(index, 0);\r
5428                                                                 }\r
5429                                                         }\r
5430                                                         else\r
5431                                                         {\r
5432                                                                 HWND hParentWnd = GetParent(m_hTargetWnd);\r
5433                                                                 if (hParentWnd != NULL)\r
5434                                                                         ::SendMessage(hParentWnd, CSVNStatusListCtrl::SVNSLNM_ADDFILE, 0, (LPARAM)changelistItems[l].GetWinPath());\r
5435                                                         }\r
5436                                                 }\r
5437                                         }\r
5438                                         else\r
5439                                         {\r
5440                                                 CMessageBox::Show(m_pSVNStatusListCtrl->m_hWnd, git.GetLastErrorMessage(), _T("TortoiseSVN"), MB_ICONERROR);\r
5441                                         }\r
5442                                 }\r
5443                         }\r
5444                         else\r
5445                         {\r
5446                                 for(UINT i = 0; i < cFiles; ++i)\r
5447                                 {\r
5448                                         DragQueryFile(hDrop, i, szFileName, sizeof(szFileName));\r
5449                                         HWND hParentWnd = GetParent(m_hTargetWnd);\r
5450                                         if (hParentWnd != NULL)\r
5451                                                 ::SendMessage(hParentWnd, CSVNStatusListCtrl::SVNSLNM_ADDFILE, 0, (LPARAM)szFileName);\r
5452                                 }\r
5453                         }\r
5454                 }\r
5455                 GlobalUnlock(medium.hGlobal);\r
5456         }\r
5457         return true; //let base free the medium\r
5458 }\r
5459 HRESULT STDMETHODCALLTYPE CSVNStatusListCtrlDropTarget::DragOver(DWORD grfKeyState, POINTL pt, DWORD __RPC_FAR *pdwEffect)\r
5460 {\r
5461         CIDropTarget::DragOver(grfKeyState, pt, pdwEffect);\r
5462         *pdwEffect = DROPEFFECT_COPY;\r
5463         if (m_pSVNStatusListCtrl)\r
5464         {\r
5465                 POINT clientpoint;\r
5466                 clientpoint.x = pt.x;\r
5467                 clientpoint.y = pt.y;\r
5468                 ScreenToClient(m_hTargetWnd, &clientpoint);\r
5469                 if ((m_pSVNStatusListCtrl->IsGroupViewEnabled())&&(m_pSVNStatusListCtrl->GetGroupFromPoint(&clientpoint) >= 0))\r
5470                 {\r
5471                         *pdwEffect = DROPEFFECT_MOVE;\r
5472                 }\r
5473                 else if ((!m_pSVNStatusListCtrl->m_bFileDropsEnabled)||(m_pSVNStatusListCtrl->m_bOwnDrag))\r
5474                 {\r
5475                         *pdwEffect = DROPEFFECT_NONE;\r
5476                 }\r
5477         }\r
5478         return S_OK;\r
5479 }f\r
5480 \r
5481 #endif