src/TortoiseShell/GITPropertyPage.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2003-2008 - TortoiseSVN
   4 // Copyright (C) 2008-2013 - TortoiseGit
   5
   6 // This program is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU General Public License
   8 // as published by the Free Software Foundation; either version 2
   9 // of the License, or (at your option) any later version.
  10
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software Foundation,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 //
  20 #include "stdafx.h"
  21
  22 #include "ShellExt.h"
  23 #include "gitpropertypage.h"
  24 #include "UnicodeUtils.h"
  25 #include "PathUtils.h"
  26 #include "UnicodeUtils.h"
  27 #include "CreateProcessHelper.h"
  28 #include "FormatMessageWrapper.h"
  29 #include "DirFileEnum.h"
  30
  31 typedef CComCritSecLock<CComCriticalSection> CAutoLocker;
  32
  33 #define MAX_STRING_LENGTH       4096    //should be big enough
  34
  35 // Nonmember function prototypes
  36 BOOL CALLBACK PageProc (HWND, UINT, WPARAM, LPARAM);
  37 UINT CALLBACK PropPageCallbackProc ( HWND hwnd, UINT uMsg, LPPROPSHEETPAGE ppsp );
  38
  39 /////////////////////////////////////////////////////////////////////////////
  40 // Dialog procedures and other callback functions
  41
  42 BOOL CALLBACK PageProc (HWND hwnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
  43 {
  44         CGitPropertyPage * sheetpage;
  45
  46         if (uMessage == WM_INITDIALOG)
  47         {
  48                 sheetpage = (CGitPropertyPage*) ((LPPROPSHEETPAGE) lParam)->lParam;
  49                 SetWindowLongPtr (hwnd, GWLP_USERDATA, (LONG_PTR) sheetpage);
  50                 sheetpage->SetHwnd(hwnd);
  51         }
  52         else
  53         {
  54                 sheetpage = (CGitPropertyPage*) GetWindowLongPtr (hwnd, GWLP_USERDATA);
  55         }
  56
  57         if (sheetpage != 0L)
  58                 return sheetpage->PageProc(hwnd, uMessage, wParam, lParam);
  59         else
  60                 return FALSE;
  61 }
  62
  63 UINT CALLBACK PropPageCallbackProc ( HWND /*hwnd*/, UINT uMsg, LPPROPSHEETPAGE ppsp )
  64 {
  65         // Delete the page before closing.
  66         if (PSPCB_RELEASE == uMsg)
  67         {
  68                 CGitPropertyPage* sheetpage = (CGitPropertyPage*) ppsp->lParam;
  69                 if (sheetpage != NULL)
  70                         delete sheetpage;
  71         }
  72         return 1;
  73 }
  74
  75 // *********************** CGitPropertyPage *************************
  76 const UINT CGitPropertyPage::m_UpdateLastCommit = RegisterWindowMessage(_T("TORTOISEGIT_PROP_UPDATELASTCOMMIT"));
  77
  78 CGitPropertyPage::CGitPropertyPage(const std::vector<stdstring> &newFilenames)
  79         :filenames(newFilenames)
  80         ,m_bChanged(false)
  81         , m_hwnd(NULL)
  82 {
  83 }
  84
  85 CGitPropertyPage::~CGitPropertyPage(void)
  86 {
  87 }
  88
  89 void CGitPropertyPage::SetHwnd(HWND newHwnd)
  90 {
  91         m_hwnd = newHwnd;
  92 }
  93
  94 BOOL CGitPropertyPage::PageProc (HWND /*hwnd*/, UINT uMessage, WPARAM wParam, LPARAM lParam)
  95 {
  96         switch (uMessage)
  97         {
  98         case WM_INITDIALOG:
  99                 {
 100                         InitWorkfileView();
 101                         return TRUE;
 102                 }
 103         case WM_NOTIFY:
 104                 {
 105                         LPNMHDR point = (LPNMHDR)lParam;
 106                         int code = point->code;
 107                         //
 108                         // Respond to notifications.
 109                         //
 110                         if (code == PSN_APPLY && m_bChanged)
 111                         {
 112                                 do
 113                                 {
 114                                         CTGitPath path(filenames.front().c_str());
 115                                         CString projectTopDir;
 116                                         if(!path.HasAdminDir(&projectTopDir) || path.IsDirectory())
 117                                                 break;
 118
 119                                         int stripLength = projectTopDir.GetLength();
 120                                         if (projectTopDir[stripLength - 1] != _T('\\'))
 121                                                 ++stripLength;
 122
 123                                         CStringA gitdir = CUnicodeUtils::GetMulti(projectTopDir, CP_UTF8);
 124                                         git_repository *repository = NULL;
 125                                         git_index *index = NULL;
 126
 127                                         int ret = git_repository_open(&repository, gitdir.GetBuffer());
 128                                         gitdir.ReleaseBuffer();
 129                                         if (ret)
 130                                                 break;
 131
 132                                         if (git_repository_index(&index, repository))
 133                                         {
 134                                                 git_repository_free(repository);
 135                                                 break;
 136                                         }
 137
 138                                         BOOL assumeValid = (BOOL)SendMessage(GetDlgItem(m_hwnd, IDC_ASSUMEVALID), BM_GETCHECK, 0, 0);
 139                                         BOOL skipWorktree = (BOOL)SendMessage(GetDlgItem(m_hwnd, IDC_SKIPWORKTREE), BM_GETCHECK, 0, 0);
 140                                         BOOL executable = (BOOL)SendMessage(GetDlgItem(m_hwnd, IDC_EXECUTABLE), BM_GETCHECK, 0, 0);
 141
 142                                         bool changed = false;
 143
 144                                         for (auto it = filenames.cbegin(); it < filenames.cend(); ++it)
 145                                         {
 146                                                 CTGitPath file;
 147                                                 file.SetFromWin(CString(it->c_str()).Mid(stripLength));
 148                                                 CStringA pathA = CUnicodeUtils::GetMulti(file.GetGitPathString(), CP_UTF8);
 149                                                 int idx = git_index_find(index, pathA);
 150                                                 if (idx >= 0)
 151                                                 {
 152                                                         git_index_entry *e = const_cast<git_index_entry *>(git_index_get_byindex(index, idx)); // HACK
 153
 154                                                         if (assumeValid == BST_CHECKED)
 155                                                         {
 156                                                                 if (!(e->flags & GIT_IDXENTRY_VALID))
 157                                                                 {
 158                                                                         e->flags |= GIT_IDXENTRY_VALID;
 159                                                                         changed = true;
 160                                                                 }
 161                                                         }
 162                                                         else if (assumeValid != BST_INDETERMINATE)
 163                                                         {
 164                                                                 if (e->flags & GIT_IDXENTRY_VALID)
 165                                                                 {
 166                                                                         e->flags &= ~GIT_IDXENTRY_VALID;
 167                                                                         changed = true;
 168                                                                 }
 169                                                         }
 170                                                         if (skipWorktree == BST_CHECKED)
 171                                                         {
 172                                                                 if (!(e->flags_extended & GIT_IDXENTRY_SKIP_WORKTREE))
 173                                                                 {
 174                                                                         e->flags_extended |= GIT_IDXENTRY_SKIP_WORKTREE;
 175                                                                         changed = true;
 176                                                                 }
 177                                                         }
 178                                                         else if (skipWorktree != BST_INDETERMINATE)
 179                                                         {
 180                                                                 if (e->flags_extended & GIT_IDXENTRY_SKIP_WORKTREE)
 181                                                                 {
 182                                                                         e->flags_extended &= ~GIT_IDXENTRY_SKIP_WORKTREE;
 183                                                                         changed = true;
 184                                                                 }
 185                                                         }
 186                                                         if (executable == BST_CHECKED)
 187                                                         {
 188                                                                 if (!(e->mode & 0111))
 189                                                                 {
 190                                                                         e->mode |= 0111;
 191                                                                         changed = true;
 192                                                                 }
 193                                                         }
 194                                                         else if (executable != BST_INDETERMINATE)
 195                                                         {
 196                                                                 if (e->mode & 0111)
 197                                                                 {
 198                                                                         e->mode &= ~0111;
 199                                                                         changed = true;
 200                                                                 }
 201                                                         }
 202                                                         if (changed)
 203                                                                 git_index_add(index, e);
 204                                                 }
 205                                         }
 206
 207                                         if (changed)
 208                                         {
 209                                                 if (!git_index_write(index))
 210                                                         m_bChanged = false;
 211                                         }
 212
 213                                         git_index_free(index);
 214                                 } while (0);
 215                         }
 216                         SetWindowLongPtr (m_hwnd, DWLP_MSGRESULT, FALSE);
 217                         return TRUE;
 218                 }
 219                 case WM_DESTROY:
 220                         return TRUE;
 221
 222                 case WM_COMMAND:
 223                 PageProcOnCommand(wParam);
 224                 break;
 225         } // switch (uMessage)
 226
 227         if (uMessage == m_UpdateLastCommit)
 228         {
 229                 DisplayCommit((git_commit *)lParam, IDC_LAST_HASH, IDC_LAST_SUBJECT, IDC_LAST_AUTHOR, IDC_LAST_DATE);
 230                 return TRUE;
 231         }
 232
 233         return FALSE;
 234 }
 235 void CGitPropertyPage::PageProcOnCommand(WPARAM wParam)
 236 {
 237         if(HIWORD(wParam) != BN_CLICKED)
 238                 return;
 239
 240         switch (LOWORD(wParam))
 241         {
 242         case IDC_SHOWLOG:
 243                 {
 244                         tstring gitCmd = _T(" /command:");
 245                         gitCmd += _T("log /path:\"");
 246                         gitCmd += filenames.front().c_str();
 247                         gitCmd += _T("\"");
 248                         RunCommand(gitCmd);
 249                 }
 250                 break;
 251         case IDC_SHOWSETTINGS:
 252                 {
 253                         CTGitPath path(filenames.front().c_str());
 254                         CString projectTopDir;
 255                         if(!path.HasAdminDir(&projectTopDir))
 256                                 return;
 257
 258                         tstring gitCmd = _T(" /command:");
 259                         gitCmd += _T("settings /path:\"");
 260                         gitCmd += projectTopDir;
 261                         gitCmd += _T("\"");
 262                         RunCommand(gitCmd);
 263                 }
 264                 break;
 265         case IDC_ASSUMEVALID:
 266         case IDC_SKIPWORKTREE:
 267         case IDC_EXECUTABLE:
 268                 m_bChanged = true;
 269                 SendMessage(GetParent(m_hwnd), PSM_CHANGED, (WPARAM)m_hwnd, 0);
 270                 break;
 271         }
 272 }
 273
 274 void CGitPropertyPage::RunCommand(const tstring& command)
 275 {
 276         tstring tortoiseProcPath = CPathUtils::GetAppDirectory(g_hmodThisDll) + _T("TortoiseGitProc.exe");
 277         if (CCreateProcessHelper::CreateProcessDetached(tortoiseProcPath.c_str(), const_cast<TCHAR*>(command.c_str())))
 278         {
 279                 // process started - exit
 280                 return;
 281         }
 282
 283         MessageBox(NULL, CFormatMessageWrapper(), _T("TortoiseProc launch failed"), MB_OK | MB_ICONINFORMATION);
 284 }
 285
 286 void CGitPropertyPage::Time64ToTimeString(__time64_t time, TCHAR * buf, size_t buflen)
 287 {
 288         struct tm newtime;
 289         SYSTEMTIME systime;
 290         TCHAR timebuf[MAX_STRING_LENGTH];
 291         TCHAR datebuf[MAX_STRING_LENGTH];
 292
 293         LCID locale = (WORD)CRegStdDWORD(_T("Software\\TortoiseGit\\LanguageID"), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT));
 294         locale = MAKELCID(locale, SORT_DEFAULT);
 295
 296         *buf = '\0';
 297         if (time)
 298         {
 299                 _localtime64_s(&newtime, &time);
 300
 301                 systime.wDay = (WORD)newtime.tm_mday;
 302                 systime.wDayOfWeek = (WORD)newtime.tm_wday;
 303                 systime.wHour = (WORD)newtime.tm_hour;
 304                 systime.wMilliseconds = 0;
 305                 systime.wMinute = (WORD)newtime.tm_min;
 306                 systime.wMonth = (WORD)newtime.tm_mon+1;
 307                 systime.wSecond = (WORD)newtime.tm_sec;
 308                 systime.wYear = (WORD)newtime.tm_year+1900;
 309                 if (CRegStdDWORD(_T("Software\\TortoiseGit\\LogDateFormat")) == 1)
 310                         GetDateFormat(locale, DATE_SHORTDATE, &systime, NULL, datebuf, MAX_STRING_LENGTH);
 311                 else
 312                         GetDateFormat(locale, DATE_LONGDATE, &systime, NULL, datebuf, MAX_STRING_LENGTH);
 313                 GetTimeFormat(locale, 0, &systime, NULL, timebuf, MAX_STRING_LENGTH);
 314                 *buf = '\0';
 315                 _tcsncat_s(buf, buflen, timebuf, MAX_STRING_LENGTH-1);
 316                 _tcsncat_s(buf, buflen, _T(", "), MAX_STRING_LENGTH-1);
 317                 _tcsncat_s(buf, buflen, datebuf, MAX_STRING_LENGTH-1);
 318         }
 319 }
 320
 321 struct TreewalkStruct
 322 {
 323         const char *folder;
 324         const char *name;
 325         git_oid oid;
 326 };
 327
 328 static int TreewalkCB_FindFileRecentCommit(const char *root, const git_tree_entry *entry, void *payload)
 329 {
 330         TreewalkStruct *treewalkstruct = (TreewalkStruct *)payload;
 331         char folder[MAX_PATH];
 332         strcpy(folder, root);
 333         strcat(folder, git_tree_entry_name(entry));
 334         strcat(folder, "/");
 335         if (strstr(treewalkstruct->folder, folder))
 336                 return 0;
 337
 338         if (!strcmp(treewalkstruct->folder, root))
 339         {
 340                 if (!strcmp(git_tree_entry_name(entry), treewalkstruct->name))
 341                 {
 342                         git_oid_cpy(&treewalkstruct->oid, git_tree_entry_id(entry));
 343                         return -1;
 344                 }
 345
 346                 return 1;
 347         }
 348
 349         return 1;
 350 }
 351
 352 static git_commit * FindFileRecentCommit(git_repository *repository, CString path)
 353 {
 354         git_commit *commit = NULL, *commit2 = NULL;
 355         git_revwalk *walk;
 356         if (git_revwalk_new(&walk, repository))
 357                 return NULL;
 358
 359         CStringA pathA = CUnicodeUtils::GetUTF8(path);
 360         const char *pathC = pathA.GetBuffer();
 361         char folder[MAX_PATH], file[MAX_PATH];
 362         const char *slash = strrchr(pathC, '/');
 363         if (slash)
 364         {
 365                 strncpy(folder, pathC, slash - pathC + 1);
 366                 folder[slash - pathC + 1] = '\0';
 367                 strcpy(file, slash + 1);
 368         }
 369         else
 370         {
 371                 folder[0] = '\0';
 372                 strcpy(file, pathC);
 373         }
 374         pathA.ReleaseBuffer();
 375
 376         TreewalkStruct treewalkstruct = { folder, file };
 377         TreewalkStruct treewalkstruct2 = { folder, file };
 378
 379         try
 380         {
 381                 if (git_revwalk_push_head(walk))
 382                         throw "git_revwalk_push_head";
 383
 384                 git_oid oid;
 385                 while (!git_revwalk_next(&oid, walk))
 386                 {
 387                         if (commit != NULL)
 388                         {
 389                                 git_commit_free(commit);
 390                                 commit = NULL;
 391                         }
 392
 393                         if (git_commit_lookup(&commit, repository, &oid))
 394                         {
 395                                 commit = NULL;
 396                                 throw "git_commit_lookup 1";
 397                         }
 398
 399                         git_tree *tree;
 400                         if (git_commit_tree(&tree, commit))
 401                                 throw "git_commit_tree 1";
 402
 403                         memset(&treewalkstruct.oid.id, 0, sizeof(treewalkstruct.oid.id));
 404                         int ret = git_tree_walk(tree, GIT_TREEWALK_PRE, TreewalkCB_FindFileRecentCommit, &treewalkstruct);
 405                         git_tree_free(tree);
 406                         if (ret < 0 && ret != GIT_EUSER)
 407                                 throw "git_tree_walk 1";
 408
 409                         // check if file not found
 410                         if (git_oid_iszero(&treewalkstruct.oid))
 411                         {
 412                                 git_commit_free(commit);
 413                                 commit = NULL;
 414                                 break;
 415                         }
 416
 417                         bool diff = true;
 418                         // for merge point, check if it is different to all parents, if yes then there are real change in the merge point.
 419                         // if no parent then of course it is different
 420                         for (unsigned int i = 0; i < git_commit_parentcount(commit); ++i)
 421                         {
 422                                 if (git_commit_parent(&commit2, commit, i))
 423                                 {
 424                                         commit2 = NULL;
 425                                         throw "git_commit_parent";
 426                                 }
 427
 428                                 if (git_commit_tree(&tree, commit2))
 429                                         throw "git_commit_tree 2";
 430
 431                                 git_commit_free(commit2);
 432                                 memset(&treewalkstruct2.oid.id, 0, sizeof(treewalkstruct2.oid.id));
 433                                 int ret = git_tree_walk(tree, GIT_TREEWALK_PRE, TreewalkCB_FindFileRecentCommit, &treewalkstruct2);
 434                                 git_tree_free(tree);
 435                                 if (ret < 0 && ret != GIT_EUSER)
 436                                         throw "git_tree_walk 2";
 437
 438                                 if (!git_oid_cmp(&treewalkstruct.oid, &treewalkstruct2.oid))
 439                                         diff = false;
 440                                 else if (git_revwalk_hide(walk, git_commit_parent_id(commit, i)))
 441                                         throw "git_revwalk_hide";
 442                         }
 443
 444                         if (diff)
 445                                 break;
 446                 }
 447         }
 448         catch (...)
 449         {
 450                 if (commit != NULL)
 451                 {
 452                         git_commit_free(commit);
 453                         commit = NULL;
 454                 }
 455                 if (commit2 != NULL)
 456                 {
 457                         git_commit_free(commit2);
 458                         commit2 = NULL;
 459                 }
 460         }
 461
 462         git_revwalk_free(walk);
 463         return commit;
 464 }
 465
 466 void CGitPropertyPage::DisplayCommit(git_commit * commit, UINT hashLabel, UINT subjectLabel, UINT authorLabel, UINT dateLabel)
 467 {
 468         if (commit == NULL)
 469         {
 470                 SetDlgItemText(m_hwnd, hashLabel, _T(""));
 471                 SetDlgItemText(m_hwnd, subjectLabel, _T(""));
 472                 SetDlgItemText(m_hwnd, authorLabel, _T(""));
 473                 SetDlgItemText(m_hwnd, dateLabel, _T(""));
 474                 return;
 475         }
 476
 477         int encode = CP_UTF8;
 478         const char * encodingString = git_commit_message_encoding(commit);
 479         if (encodingString != NULL)
 480         {
 481                 CString str;
 482                 g_Git.StringAppend(&str, (BYTE*)encodingString, CP_UTF8);
 483                 encode = CUnicodeUtils::GetCPCode(str);
 484         }
 485
 486         const git_signature * author = git_commit_author(commit);
 487         CString authorName;
 488         g_Git.StringAppend(&authorName, (BYTE*)author->name, encode);
 489
 490         CString message;
 491         g_Git.StringAppend(&message, (BYTE*)git_commit_message(commit), encode);
 492
 493         int start = 0;
 494         message = message.Tokenize(L"\n", start);
 495
 496         SetDlgItemText(m_hwnd, hashLabel, CGitHash((char*)(git_commit_id(commit)->id)).ToString());
 497         SetDlgItemText(m_hwnd, subjectLabel, message);
 498         SetDlgItemText(m_hwnd, authorLabel, authorName);
 499
 500         CString authorDate;
 501         Time64ToTimeString(author->when.time, authorDate.GetBufferSetLength(200), 200);
 502         SetDlgItemText(m_hwnd, dateLabel, authorDate);
 503 }
 504
 505 int CGitPropertyPage::LogThread()
 506 {
 507         CTGitPath path(filenames.front().c_str());
 508
 509         CAutoLocker lock(g_Git.m_critGitDllSec); // HACK for libgit2
 510
 511         CString ProjectTopDir;
 512         if(!path.HasAdminDir(&ProjectTopDir))
 513                 return 0;
 514
 515         CStringA gitdir = CUnicodeUtils::GetMulti(ProjectTopDir, CP_UTF8);
 516         git_repository *repository = NULL;
 517
 518         int ret = git_repository_open(&repository, gitdir.GetBuffer());
 519         gitdir.ReleaseBuffer();
 520         if (ret)
 521                 return 0;
 522
 523         int stripLength = ProjectTopDir.GetLength();
 524         if (ProjectTopDir[stripLength - 1] != _T('\\'))
 525                 ++stripLength;
 526
 527         CTGitPath relatepath;
 528         relatepath.SetFromWin(path.GetWinPathString().Mid(stripLength));
 529
 530         git_commit *commit = FindFileRecentCommit(repository, relatepath.GetGitPathString());
 531         if (commit != NULL)
 532         {
 533                 SendMessage(m_hwnd, m_UpdateLastCommit, NULL, (LPARAM)commit);
 534                 git_commit_free(commit);
 535         }
 536         else
 537         {
 538                 SendMessage(m_hwnd, m_UpdateLastCommit, NULL, NULL);
 539         }
 540
 541         git_repository_free(repository);
 542
 543         return 0;
 544 }
 545
 546 void CGitPropertyPage::LogThreadEntry(void *param)
 547 {
 548         ((CGitPropertyPage*)param)->LogThread();
 549 }
 550
 551 void CGitPropertyPage::InitWorkfileView()
 552 {
 553         if (filenames.empty())
 554                 return;
 555
 556         CTGitPath path(filenames.front().c_str());
 557
 558         CString ProjectTopDir;
 559         if(!path.HasAdminDir(&ProjectTopDir))
 560                 return;
 561
 562         CStringA gitdir = CUnicodeUtils::GetMulti(ProjectTopDir, CP_UTF8);
 563         git_repository *repository = NULL;
 564
 565         int ret = git_repository_open(&repository, gitdir.GetBuffer());
 566         gitdir.ReleaseBuffer();
 567         if (ret)
 568                 return;
 569
 570         CGit git;
 571
 572         git.SetCurrentDir(ProjectTopDir);
 573         CString username;
 574         git.Run(_T("git.exe config user.name"), &username, CP_UTF8);
 575         CString useremail;
 576         git.Run(_T("git.exe config user.email"), &useremail, CP_UTF8);
 577         CString autocrlf;
 578         git.Run(_T("git.exe config core.autocrlf"), &autocrlf, CP_UTF8);
 579         CString safecrlf;
 580         git.Run(_T("git.exe config core.safecrlf"), &safecrlf, CP_UTF8);
 581
 582         CString branch;
 583         CString remotebranch;
 584
 585         if (!g_Git.GetCurrentBranchFromFile(ProjectTopDir, branch))
 586         {
 587                 CString cmd, remote;
 588                 cmd.Format(_T("git.exe config branch.%s.merge"), branch.Trim());
 589                 git.Run(cmd, &remotebranch, CP_UTF8);
 590                 cmd.Format(_T("git.exe config branch.%s.remote"), branch.Trim());
 591                 git.Run(cmd, &remote, CP_UTF8);
 592                 remote.Trim();
 593                 remotebranch.Trim();
 594                 if((!remote.IsEmpty()) && (!remotebranch.IsEmpty()))
 595                 {
 596                         remotebranch = remotebranch.Mid(11);
 597                         remotebranch = remote + _T("/") + remotebranch;
 598                 }
 599         }
 600         else
 601                 branch = _T("detached HEAD");
 602
 603         if (autocrlf.Trim().IsEmpty())
 604                 autocrlf = _T("false");
 605         if (safecrlf.Trim().IsEmpty())
 606                 safecrlf = _T("false");
 607
 608         SetDlgItemText(m_hwnd,IDC_CONFIG_USERNAME,username.Trim());
 609         SetDlgItemText(m_hwnd,IDC_CONFIG_USEREMAIL,useremail.Trim());
 610         SetDlgItemText(m_hwnd,IDC_CONFIG_AUTOCRLF,autocrlf.Trim());
 611         SetDlgItemText(m_hwnd,IDC_CONFIG_SAFECRLF,safecrlf.Trim());
 612
 613         SetDlgItemText(m_hwnd,IDC_SHELL_CURRENT_BRANCH,branch.Trim());
 614         remotebranch.Trim().Replace(_T("\n"), _T("; "));
 615         SetDlgItemText(m_hwnd,IDC_SHELL_REMOTE_BRANCH, remotebranch);
 616
 617         git_oid oid;
 618         git_commit *HEADcommit = NULL;
 619         if (!git_reference_name_to_id(&oid, repository, "HEAD") && !git_commit_lookup(&HEADcommit, repository, &oid) && HEADcommit != NULL)
 620         {
 621                 DisplayCommit(HEADcommit, IDC_HEAD_HASH, IDC_HEAD_SUBJECT, IDC_HEAD_AUTHOR, IDC_HEAD_DATE);
 622                 git_commit_free(HEADcommit);
 623         }
 624
 625         {
 626                 int stripLength = ProjectTopDir.GetLength();
 627                 if (ProjectTopDir[stripLength - 1] != _T('\\'))
 628                         ++stripLength;
 629
 630                 bool allAreFiles = true;
 631                 for (auto it = filenames.cbegin(); it < filenames.cend(); ++it)
 632                 {
 633                         if (PathIsDirectory(it->c_str()))
 634                         {
 635                                 allAreFiles = false;
 636                                 break;
 637                         }
 638                 }
 639                 if (allAreFiles)
 640                 {
 641                         size_t assumevalid = 0;
 642                         size_t skipworktree = 0;
 643                         size_t executable = 0;
 644                         do
 645                         {
 646                                 git_index *index = NULL;
 647
 648                                 if (git_repository_index(&index, repository))
 649                                         break;
 650
 651                                 for (auto it = filenames.cbegin(); it < filenames.cend(); ++it)
 652                                 {
 653                                         CTGitPath file;
 654                                         file.SetFromWin(CString(it->c_str()).Mid(stripLength));
 655                                         CStringA pathA = CUnicodeUtils::GetMulti(file.GetGitPathString(), CP_UTF8);
 656                                         int idx = git_index_find(index, pathA);
 657                                         if (idx >= 0)
 658                                         {
 659                                                 const git_index_entry *e = git_index_get_byindex(index, idx);
 660
 661                                                 if (e->flags & GIT_IDXENTRY_VALID)
 662                                                         ++assumevalid;
 663
 664                                                 if (e->flags_extended & GIT_IDXENTRY_SKIP_WORKTREE)
 665                                                         ++skipworktree;
 666
 667                                                 if (e->mode & 0111)
 668                                                         ++executable;
 669                                         }
 670                                         else
 671                                         {
 672                                                 // do not show checkboxes for unversioned files
 673                                                 ShowWindow(GetDlgItem(m_hwnd, IDC_ASSUMEVALID), SW_HIDE);
 674                                                 ShowWindow(GetDlgItem(m_hwnd, IDC_SKIPWORKTREE), SW_HIDE);
 675                                                 ShowWindow(GetDlgItem(m_hwnd, IDC_EXECUTABLE), SW_HIDE);
 676                                                 break;
 677                                         }
 678                                 }
 679                                 git_index_free(index);
 680                         } while (0);
 681
 682                         if (assumevalid != 0 && assumevalid != filenames.size())
 683                         {
 684                                 SendMessage(GetDlgItem(m_hwnd, IDC_ASSUMEVALID), BM_SETSTYLE, (DWORD)GetWindowLong(GetDlgItem(m_hwnd, IDC_ASSUMEVALID), GWL_STYLE) & ~BS_AUTOCHECKBOX | BS_AUTO3STATE, 0);
 685                                 SendMessage(GetDlgItem(m_hwnd, IDC_ASSUMEVALID), BM_SETCHECK, BST_INDETERMINATE, 0);
 686                         }
 687                         else
 688                                 SendMessage(GetDlgItem(m_hwnd, IDC_ASSUMEVALID), BM_SETCHECK, (assumevalid == 0) ? BST_UNCHECKED : BST_CHECKED, 0);
 689
 690                         if (skipworktree != 0 && skipworktree != filenames.size())
 691                         {
 692                                 SendMessage(GetDlgItem(m_hwnd, IDC_SKIPWORKTREE), BM_SETSTYLE, (DWORD)GetWindowLong(GetDlgItem(m_hwnd, IDC_SKIPWORKTREE), GWL_STYLE) & ~BS_AUTOCHECKBOX | BS_AUTO3STATE, 0);
 693                                 SendMessage(GetDlgItem(m_hwnd, IDC_SKIPWORKTREE), BM_SETCHECK, BST_INDETERMINATE, 0);
 694                         }
 695                         else
 696                                 SendMessage(GetDlgItem(m_hwnd, IDC_SKIPWORKTREE), BM_SETCHECK, (skipworktree == 0) ? BST_UNCHECKED : BST_CHECKED, 0);
 697
 698                         if (executable != 0 && executable != filenames.size())
 699                         {
 700                                 SendMessage(GetDlgItem(m_hwnd, IDC_EXECUTABLE), BM_SETSTYLE, (DWORD)GetWindowLong(GetDlgItem(m_hwnd, IDC_EXECUTABLE), GWL_STYLE) & ~BS_AUTOCHECKBOX | BS_AUTO3STATE, 0);
 701                                 SendMessage(GetDlgItem(m_hwnd, IDC_EXECUTABLE), BM_SETCHECK, BST_INDETERMINATE, 0);
 702                         }
 703                         else
 704                                 SendMessage(GetDlgItem(m_hwnd, IDC_EXECUTABLE), BM_SETCHECK, (executable == 0) ? BST_UNCHECKED : BST_CHECKED, 0);
 705                 }
 706                 else
 707                 {
 708                         ShowWindow(GetDlgItem(m_hwnd, IDC_ASSUMEVALID), SW_HIDE);
 709                         ShowWindow(GetDlgItem(m_hwnd, IDC_SKIPWORKTREE), SW_HIDE);
 710                         ShowWindow(GetDlgItem(m_hwnd, IDC_EXECUTABLE), SW_HIDE);
 711                 }
 712         }
 713         git_repository_free(repository);
 714
 715         if (filenames.size() == 1)
 716         {
 717                 SetDlgItemText(m_hwnd, IDC_LAST_SUBJECT, CString(MAKEINTRESOURCE(IDS_LOADING)));
 718                 CString adminDir;
 719                 g_GitAdminDir.GetAdminDirPath(ProjectTopDir, adminDir);
 720                 CDirFileEnum dir(adminDir);
 721                 UINT64 size = dir.GetSize();
 722                 // Suppose there is one commit for every 2000 bytes of git metadata
 723                 // Suppose for each commit, it takes 4 units of local variables and stack pointer
 724                 // Provide a minimum of 1MB stack size
 725                 // Maximum stack size: 256MB for 32-bit, 512MB for 64-bit
 726                 UINT stack = 1024 * 1024 + min(64 * 1024 * 1024 * sizeof(void*), (UINT)(size / 2000) * 4 * sizeof(void*));
 727                 _beginthread(LogThreadEntry, stack, this);
 728         }
 729 }
 730
 731
 732 // CShellExt member functions (needed for IShellPropSheetExt)
 733 STDMETHODIMP CShellExt::AddPages(LPFNADDPROPSHEETPAGE lpfnAddPage, LPARAM lParam)
 734 {
 735         __try
 736         {
 737                 return AddPages_Wrap(lpfnAddPage, lParam);
 738         }
 739         __except(CCrashReport::Instance().SendReport(GetExceptionInformation()))
 740         {
 741         }
 742         return E_FAIL;
 743 }
 744
 745 STDMETHODIMP CShellExt::AddPages_Wrap(LPFNADDPROPSHEETPAGE lpfnAddPage, LPARAM lParam)
 746 {
 747         CString ProjectTopDir;
 748
 749         for (std::vector<stdstring>::iterator I = files_.begin(); I != files_.end(); ++I)
 750         {
 751                 /*
 752                 GitStatus svn = GitStatus();
 753                 if (svn.GetStatus(CTGitPath(I->c_str())) == (-2))
 754                         return S_OK;                    // file/directory not under version control
 755
 756                 if (svn.status->entry == NULL)
 757                         return S_OK;
 758                 */
 759                 if( CTGitPath(I->c_str()).HasAdminDir(&ProjectTopDir))
 760                         break;
 761                 else
 762                         return S_OK;
 763         }
 764
 765         if (files_.empty())
 766                 return S_OK;
 767
 768         LoadLangDll();
 769         PROPSHEETPAGE psp;
 770         SecureZeroMemory(&psp, sizeof(PROPSHEETPAGE));
 771         HPROPSHEETPAGE hPage;
 772         CGitPropertyPage *sheetpage = new (std::nothrow) CGitPropertyPage(files_);
 773
 774         psp.dwSize = sizeof (psp);
 775         psp.dwFlags = PSP_USEREFPARENT | PSP_USETITLE | PSP_USEICONID | PSP_USECALLBACK;
 776         psp.hInstance = g_hResInst;
 777         psp.pszTemplate = MAKEINTRESOURCE(IDD_PROPPAGE);
 778         psp.pszIcon = MAKEINTRESOURCE(IDI_APPSMALL);
 779         psp.pszTitle = _T("Git");
 780         psp.pfnDlgProc = (DLGPROC) PageProc;
 781         psp.lParam = (LPARAM) sheetpage;
 782         psp.pfnCallback = PropPageCallbackProc;
 783         psp.pcRefParent = (UINT*)&g_cRefThisDll;
 784
 785         hPage = CreatePropertySheetPage (&psp);
 786
 787         if (hPage != NULL)
 788         {
 789                 if (!lpfnAddPage (hPage, lParam))
 790                 {
 791                         delete sheetpage;
 792                         DestroyPropertySheetPage (hPage);
 793                 }
 794         }
 795
 796         return S_OK;
 797 }
 798
 799 STDMETHODIMP CShellExt::ReplacePage (UINT /*uPageID*/, LPFNADDPROPSHEETPAGE /*lpfnReplaceWith*/, LPARAM /*lParam*/)
 800 {
 801         return E_FAIL;
 802 }