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