src/TortoiseProc/CommitDlg.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control\r
   2 \r
   3 // Copyright (C) 2003-2008 - TortoiseGit\r
   4 \r
   5 // This program is free software; you can redistribute it and/or\r
   6 // modify it under the terms of the GNU General Public License\r
   7 // as published by the Free Software Foundation; either version 2\r
   8 // of the License, or (at your option) any later version.\r
   9 \r
  10 // This program is distributed in the hope that it will be useful,\r
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  13 // GNU General Public License for more details.\r
  14 \r
  15 // You should have received a copy of the GNU General Public License\r
  16 // along with this program; if not, write to the Free Software Foundation,\r
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.\r
  18 //\r
  19 #include "stdafx.h"\r
  20 #include "TortoiseProc.h"\r
  21 #include "CommitDlg.h"\r
  22 #include "DirFileEnum.h"\r
  23 //#include "GitConfig.h"\r
  24 //#include "GitProperties.h"\r
  25 #include "MessageBox.h"\r
  26 #include "AppUtils.h"\r
  27 #include "PathUtils.h"\r
  28 #include "Git.h"\r
  29 #include "Registry.h"\r
  30 #include "GitStatus.h"\r
  31 #include "HistoryDlg.h"\r
  32 #include "Hooks.h"\r
  33 #include "CommonResource.h"\r
  34 #include "UnicodeUtils.h"\r
  35 #include "ProgressDlg.h"\r
  36 #include "ShellUpdater.h"\r
  37 \r
  38 #ifdef _DEBUG\r
  39 #define new DEBUG_NEW\r
  40 #undef THIS_FILE\r
  41 static char THIS_FILE[] = __FILE__;\r
  42 #endif\r
  43 \r
  44 UINT CCommitDlg::WM_AUTOLISTREADY = RegisterWindowMessage(_T("TORTOISEGIT_AUTOLISTREADY_MSG"));\r
  45 \r
  46 IMPLEMENT_DYNAMIC(CCommitDlg, CResizableStandAloneDialog)\r
  47 CCommitDlg::CCommitDlg(CWnd* pParent /*=NULL*/)\r
  48         : CResizableStandAloneDialog(CCommitDlg::IDD, pParent)\r
  49         , m_bRecursive(FALSE)\r
  50         , m_bShowUnversioned(FALSE)\r
  51         , m_bBlock(FALSE)\r
  52         , m_bThreadRunning(FALSE)\r
  53         , m_bRunThread(FALSE)\r
  54         , m_pThread(NULL)\r
  55         , m_bWholeProject(FALSE)\r
  56         , m_bKeepChangeList(TRUE)\r
  57         , m_itemsCount(0)\r
  58         , m_bSelectFilesForCommit(TRUE)\r
  59 {\r
  60         this->m_bCommitAmend=FALSE;\r
  61 }\r
  62 \r
  63 CCommitDlg::~CCommitDlg()\r
  64 {\r
  65         if(m_pThread != NULL)\r
  66         {\r
  67                 delete m_pThread;\r
  68         }\r
  69 }\r
  70 \r
  71 void CCommitDlg::DoDataExchange(CDataExchange* pDX)\r
  72 {\r
  73         CResizableStandAloneDialog::DoDataExchange(pDX);\r
  74         DDX_Control(pDX, IDC_FILELIST, m_ListCtrl);\r
  75         DDX_Control(pDX, IDC_LOGMESSAGE, m_cLogMessage);\r
  76         DDX_Check(pDX, IDC_SHOWUNVERSIONED, m_bShowUnversioned);\r
  77         DDX_Control(pDX, IDC_SELECTALL, m_SelectAll);\r
  78         DDX_Text(pDX, IDC_BUGID, m_sBugID);\r
  79         DDX_Check(pDX, IDC_WHOLE_PROJECT, m_bWholeProject);\r
  80         DDX_Control(pDX, IDC_SPLITTER, m_wndSplitter);\r
  81         DDX_Check(pDX, IDC_KEEPLISTS, m_bKeepChangeList);\r
  82         DDX_Check(pDX,IDC_COMMIT_AMEND,m_bCommitAmend);\r
  83 }\r
  84 \r
  85 BEGIN_MESSAGE_MAP(CCommitDlg, CResizableStandAloneDialog)\r
  86         ON_BN_CLICKED(IDC_SELECTALL, OnBnClickedSelectall)\r
  87         ON_BN_CLICKED(IDHELP, OnBnClickedHelp)\r
  88         ON_BN_CLICKED(IDC_SHOWUNVERSIONED, OnBnClickedShowunversioned)\r
  89 //      ON_BN_CLICKED(IDC_HISTORY, OnBnClickedHistory)\r
  90         ON_BN_CLICKED(IDC_BUGTRAQBUTTON, OnBnClickedBugtraqbutton)\r
  91         ON_EN_CHANGE(IDC_LOGMESSAGE, OnEnChangeLogmessage)\r
  92         ON_REGISTERED_MESSAGE(CGitStatusListCtrl::SVNSLNM_ITEMCOUNTCHANGED, OnGitStatusListCtrlItemCountChanged)\r
  93         ON_REGISTERED_MESSAGE(CGitStatusListCtrl::SVNSLNM_NEEDSREFRESH, OnGitStatusListCtrlNeedsRefresh)\r
  94         ON_REGISTERED_MESSAGE(CGitStatusListCtrl::SVNSLNM_ADDFILE, OnFileDropped)\r
  95         ON_REGISTERED_MESSAGE(CGitStatusListCtrl::SVNSLNM_CHECKCHANGED, &CCommitDlg::OnGitStatusListCtrlCheckChanged)\r
  96         ON_REGISTERED_MESSAGE(WM_AUTOLISTREADY, OnAutoListReady) \r
  97         ON_WM_TIMER()\r
  98     ON_WM_SIZE()\r
  99         ON_STN_CLICKED(IDC_EXTERNALWARNING, &CCommitDlg::OnStnClickedExternalwarning)\r
 100         ON_BN_CLICKED(IDC_SIGNOFF, &CCommitDlg::OnBnClickedSignOff)\r
 101         ON_STN_CLICKED(IDC_COMMITLABEL, &CCommitDlg::OnStnClickedCommitlabel)\r
 102     ON_BN_CLICKED(IDC_COMMIT_AMEND, &CCommitDlg::OnBnClickedCommitAmend)\r
 103     ON_BN_CLICKED(IDC_WHOLE_PROJECT, &CCommitDlg::OnBnClickedWholeProject)\r
 104 END_MESSAGE_MAP()\r
 105 \r
 106 BOOL CCommitDlg::OnInitDialog()\r
 107 {\r
 108         CResizableStandAloneDialog::OnInitDialog();\r
 109         \r
 110         m_regAddBeforeCommit = CRegDWORD(_T("Software\\TortoiseGit\\AddBeforeCommit"), TRUE);\r
 111         m_bShowUnversioned = m_regAddBeforeCommit;\r
 112 \r
 113         m_History.SetMaxHistoryItems((LONG)CRegDWORD(_T("Software\\TortoiseGit\\MaxHistoryItems"), 25));\r
 114 \r
 115         m_regKeepChangelists = CRegDWORD(_T("Software\\TortoiseGit\\KeepChangeLists"), FALSE);\r
 116         m_bKeepChangeList = m_regKeepChangelists;\r
 117 \r
 118 //      GitConfig config;\r
 119 //      m_bWholeProject = config.KeepLocks();\r
 120 \r
 121         UpdateData(FALSE);\r
 122         \r
 123         m_ListCtrl.Init(SVNSLC_COLEXT | SVNSLC_COLSTATUS | SVNSLC_COLADD |SVNSLC_COLDEL, _T("CommitDlg"));\r
 124         m_ListCtrl.SetSelectButton(&m_SelectAll);\r
 125         m_ListCtrl.SetStatLabel(GetDlgItem(IDC_STATISTICS));\r
 126         m_ListCtrl.SetCancelBool(&m_bCancelled);\r
 127         m_ListCtrl.SetEmptyString(IDS_COMMITDLG_NOTHINGTOCOMMIT);\r
 128         m_ListCtrl.EnableFileDrop();\r
 129         m_ListCtrl.SetBackgroundImage(IDI_COMMIT_BKG);\r
 130         \r
 131         //this->DialogEnableWindow(IDC_COMMIT_AMEND,FALSE);\r
 132 //      m_ProjectProperties.ReadPropsPathList(m_pathList);\r
 133         m_cLogMessage.Init(m_ProjectProperties);\r
 134         m_cLogMessage.SetFont((CString)CRegString(_T("Software\\TortoiseGit\\LogFontName"), _T("Courier New")), (DWORD)CRegDWORD(_T("Software\\TortoiseGit\\LogFontSize"), 8));\r
 135         m_cLogMessage.RegisterContextMenuHandler(this);\r
 136 \r
 137         OnEnChangeLogmessage();\r
 138 \r
 139         m_tooltips.Create(this);\r
 140         m_tooltips.AddTool(IDC_EXTERNALWARNING, IDS_COMMITDLG_EXTERNALS);\r
 141         m_tooltips.AddTool(IDC_COMMIT_AMEND,IDS_COMMIT_AMEND_TT);\r
 142 //      m_tooltips.AddTool(IDC_HISTORY, IDS_COMMITDLG_HISTORY_TT);\r
 143         \r
 144         m_SelectAll.SetCheck(BST_INDETERMINATE);\r
 145 \r
 146 #if 0\r
 147         CBugTraqAssociations bugtraq_associations;\r
 148         bugtraq_associations.Load();\r
 149 \r
 150         if (bugtraq_associations.FindProvider(m_pathList, &m_bugtraq_association))\r
 151         {\r
 152                 GetDlgItem(IDC_BUGID)->ShowWindow(SW_HIDE);\r
 153                 GetDlgItem(IDC_BUGIDLABEL)->ShowWindow(SW_HIDE);\r
 154 \r
 155                 CComPtr<IBugTraqProvider> pProvider;\r
 156                 HRESULT hr = pProvider.CoCreateInstance(m_bugtraq_association.GetProviderClass());\r
 157                 if (SUCCEEDED(hr))\r
 158                 {\r
 159                         m_BugTraqProvider = pProvider;\r
 160                         BSTR temp = NULL;\r
 161                         if (SUCCEEDED(hr = pProvider->GetLinkText(GetSafeHwnd(), m_bugtraq_association.GetParameters().AllocSysString(), &temp)))\r
 162                         {\r
 163                                 SetDlgItemText(IDC_BUGTRAQBUTTON, temp);\r
 164                                 GetDlgItem(IDC_BUGTRAQBUTTON)->EnableWindow(TRUE);\r
 165                                 GetDlgItem(IDC_BUGTRAQBUTTON)->ShowWindow(SW_SHOW);\r
 166                         }\r
 167 \r
 168                         SysFreeString(temp);\r
 169                 }\r
 170 \r
 171                 GetDlgItem(IDC_LOGMESSAGE)->SetFocus();\r
 172         }\r
 173         else if (!m_ProjectProperties.sMessage.IsEmpty())\r
 174         {\r
 175                 GetDlgItem(IDC_BUGID)->ShowWindow(SW_SHOW);\r
 176                 GetDlgItem(IDC_BUGIDLABEL)->ShowWindow(SW_SHOW);\r
 177                 if (!m_ProjectProperties.sLabel.IsEmpty())\r
 178                         SetDlgItemText(IDC_BUGIDLABEL, m_ProjectProperties.sLabel);\r
 179                 GetDlgItem(IDC_BUGTRAQBUTTON)->ShowWindow(SW_HIDE);\r
 180                 GetDlgItem(IDC_BUGTRAQBUTTON)->EnableWindow(FALSE);\r
 181                 GetDlgItem(IDC_BUGID)->SetFocus();\r
 182                 CString sBugID = m_ProjectProperties.GetBugIDFromLog(m_sLogMessage);\r
 183                 if (!sBugID.IsEmpty())\r
 184                 {\r
 185                         SetDlgItemText(IDC_BUGID, sBugID);\r
 186                 }\r
 187         }\r
 188         else\r
 189 #endif\r
 190         {\r
 191                 GetDlgItem(IDC_BUGID)->ShowWindow(SW_HIDE);\r
 192                 GetDlgItem(IDC_BUGIDLABEL)->ShowWindow(SW_HIDE);\r
 193                 GetDlgItem(IDC_BUGTRAQBUTTON)->ShowWindow(SW_HIDE);\r
 194                 GetDlgItem(IDC_BUGTRAQBUTTON)->EnableWindow(FALSE);\r
 195                 GetDlgItem(IDC_LOGMESSAGE)->SetFocus();\r
 196         }\r
 197 \r
 198         if (!m_sLogMessage.IsEmpty())\r
 199                 m_cLogMessage.SetText(m_sLogMessage);\r
 200                 \r
 201         GetWindowText(m_sWindowTitle);\r
 202         \r
 203         AdjustControlSize(IDC_SHOWUNVERSIONED);\r
 204         AdjustControlSize(IDC_SELECTALL);\r
 205         AdjustControlSize(IDC_WHOLE_PROJECT);\r
 206 \r
 207         GetClientRect(m_DlgOrigRect);\r
 208         m_cLogMessage.GetClientRect(m_LogMsgOrigRect);\r
 209 \r
 210         AddAnchor(IDC_COMMITLABEL, TOP_LEFT, TOP_RIGHT);\r
 211         AddAnchor(IDC_BUGIDLABEL, TOP_RIGHT);\r
 212         AddAnchor(IDC_BUGID, TOP_RIGHT);\r
 213         AddAnchor(IDC_BUGTRAQBUTTON, TOP_RIGHT);\r
 214         AddAnchor(IDC_COMMIT_TO, TOP_LEFT, TOP_RIGHT);\r
 215         AddAnchor(IDC_MESSAGEGROUP, TOP_LEFT, TOP_RIGHT);\r
 216 //      AddAnchor(IDC_HISTORY, TOP_LEFT);\r
 217         AddAnchor(IDC_LOGMESSAGE, TOP_LEFT, TOP_RIGHT);\r
 218         AddAnchor(IDC_SIGNOFF,   TOP_RIGHT);\r
 219         AddAnchor(IDC_LISTGROUP, TOP_LEFT, BOTTOM_RIGHT);\r
 220         AddAnchor(IDC_SPLITTER, TOP_LEFT, TOP_RIGHT);\r
 221         AddAnchor(IDC_FILELIST, TOP_LEFT, BOTTOM_RIGHT);\r
 222         AddAnchor(IDC_SHOWUNVERSIONED, BOTTOM_LEFT);\r
 223         AddAnchor(IDC_SELECTALL, BOTTOM_LEFT);\r
 224         AddAnchor(IDC_EXTERNALWARNING, BOTTOM_RIGHT);\r
 225         AddAnchor(IDC_STATISTICS, BOTTOM_LEFT, BOTTOM_RIGHT);\r
 226         AddAnchor(IDC_WHOLE_PROJECT, BOTTOM_LEFT);\r
 227         AddAnchor(IDC_KEEPLISTS, BOTTOM_LEFT);\r
 228         AddAnchor(IDOK, BOTTOM_RIGHT);\r
 229         AddAnchor(IDCANCEL, BOTTOM_RIGHT);\r
 230         AddAnchor(IDHELP, BOTTOM_RIGHT);\r
 231         AddAnchor(IDC_COMMIT_AMEND,TOP_LEFT);\r
 232         \r
 233         if (hWndExplorer)\r
 234                 CenterWindow(CWnd::FromHandle(hWndExplorer));\r
 235         EnableSaveRestore(_T("CommitDlg"));\r
 236         DWORD yPos = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\CommitDlgSizer"));\r
 237         RECT rcDlg, rcLogMsg, rcFileList;\r
 238         GetClientRect(&rcDlg);\r
 239         m_cLogMessage.GetWindowRect(&rcLogMsg);\r
 240         ScreenToClient(&rcLogMsg);\r
 241         m_ListCtrl.GetWindowRect(&rcFileList);\r
 242         ScreenToClient(&rcFileList);\r
 243         if (yPos)\r
 244         {\r
 245                 RECT rectSplitter;\r
 246                 m_wndSplitter.GetWindowRect(&rectSplitter);\r
 247                 ScreenToClient(&rectSplitter);\r
 248                 int delta = yPos - rectSplitter.top;\r
 249                 if ((rcLogMsg.bottom + delta > rcLogMsg.top)&&(rcLogMsg.bottom + delta < rcFileList.bottom - 30))\r
 250                 {\r
 251                         m_wndSplitter.SetWindowPos(NULL, 0, yPos, 0, 0, SWP_NOSIZE);\r
 252                         DoSize(delta);\r
 253                 }\r
 254         }\r
 255 \r
 256         // add all directories to the watcher\r
 257         for (int i=0; i<m_pathList.GetCount(); ++i)\r
 258         {\r
 259                 if (m_pathList[i].IsDirectory())\r
 260                         m_pathwatcher.AddPath(m_pathList[i]);\r
 261         }\r
 262 \r
 263         m_updatedPathList = m_pathList;\r
 264 \r
 265         //first start a thread to obtain the file list with the status without\r
 266         //blocking the dialog\r
 267         InterlockedExchange(&m_bBlock, TRUE);\r
 268         m_pThread = AfxBeginThread(StatusThreadEntry, this, THREAD_PRIORITY_NORMAL,0,CREATE_SUSPENDED);\r
 269         if (m_pThread==NULL)\r
 270         {\r
 271                 CMessageBox::Show(this->m_hWnd, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);\r
 272                 InterlockedExchange(&m_bBlock, FALSE);\r
 273         }\r
 274         else\r
 275         {\r
 276                 m_pThread->m_bAutoDelete = FALSE;\r
 277                 m_pThread->ResumeThread();\r
 278         }\r
 279         CRegDWORD err = CRegDWORD(_T("Software\\TortoiseGit\\ErrorOccurred"), FALSE);\r
 280         CRegDWORD historyhint = CRegDWORD(_T("Software\\TortoiseGit\\HistoryHintShown"), FALSE);\r
 281         if ((((DWORD)err)!=FALSE)&&((((DWORD)historyhint)==FALSE)))\r
 282         {\r
 283                 historyhint = TRUE;\r
 284 //              ShowBalloon(IDC_HISTORY, IDS_COMMITDLG_HISTORYHINT_TT, IDI_INFORMATION);\r
 285         }\r
 286         err = FALSE;\r
 287 \r
 288         //this->UpdateData(TRUE);\r
 289         //this->m_bCommitAmend=FALSE;\r
 290         //this->UpdateData(FALSE);\r
 291 \r
 292         return FALSE;  // return TRUE unless you set the focus to a control\r
 293         // EXCEPTION: OCX Property Pages should return FALSE\r
 294 }\r
 295 \r
 296 void CCommitDlg::OnOK()\r
 297 {\r
 298         if (m_bBlock)\r
 299                 return;\r
 300         if (m_bThreadRunning)\r
 301         {\r
 302                 m_bCancelled = true;\r
 303                 InterlockedExchange(&m_bRunThread, FALSE);\r
 304                 WaitForSingleObject(m_pThread->m_hThread, 1000);\r
 305                 if (m_bThreadRunning)\r
 306                 {\r
 307                         // we gave the thread a chance to quit. Since the thread didn't\r
 308                         // listen to us we have to kill it.\r
 309                         TerminateThread(m_pThread->m_hThread, (DWORD)-1);\r
 310                         InterlockedExchange(&m_bThreadRunning, FALSE);\r
 311                 }\r
 312         }\r
 313         this->UpdateData();\r
 314 \r
 315         CString id;\r
 316         GetDlgItemText(IDC_BUGID, id);\r
 317         if (!m_ProjectProperties.CheckBugID(id))\r
 318         {\r
 319                 ShowBalloon(IDC_BUGID, IDS_COMMITDLG_ONLYNUMBERS, IDI_EXCLAMATION);\r
 320                 return;\r
 321         }\r
 322         m_sLogMessage = m_cLogMessage.GetText();\r
 323         if ( m_sLogMessage.IsEmpty() )\r
 324         {\r
 325                 // no message entered, go round again\r
 326                 CMessageBox::Show(this->m_hWnd, IDS_COMMITDLG_NOMESSAGE, IDS_APPNAME, MB_OK | MB_ICONERROR);\r
 327                 return;\r
 328         }\r
 329         if ((m_ProjectProperties.bWarnIfNoIssue) && (id.IsEmpty() && !m_ProjectProperties.HasBugID(m_sLogMessage)))\r
 330         {\r
 331                 if (CMessageBox::Show(this->m_hWnd, IDS_COMMITDLG_NOISSUEWARNING, IDS_APPNAME, MB_YESNO | MB_ICONWARNING)!=IDYES)\r
 332                         return;\r
 333         }\r
 334 \r
 335 #if 0\r
 336         CRegDWORD regUnversionedRecurse (_T("Software\\TortoiseGit\\UnversionedRecurse"), TRUE);\r
 337         if (!(DWORD)regUnversionedRecurse)\r
 338         {\r
 339                 // Find unversioned directories which are marked for commit. The user might expect them\r
 340                 // to be added recursively since he cannot the the files. Let's ask the user if he knows\r
 341                 // what he is doing.\r
 342                 int nListItems = m_ListCtrl.GetItemCount();\r
 343                 for (int j=0; j<nListItems; j++)\r
 344                 {\r
 345                         const CGitStatusListCtrl::FileEntry * entry = m_ListCtrl.GetListEntry(j);\r
 346                         if (entry->IsChecked() && (entry->status == Git_wc_status_unversioned) && entry->IsFolder() )\r
 347                         {\r
 348                                 if (CMessageBox::Show(this->m_hWnd, IDS_COMMITDLG_UNVERSIONEDFOLDERWARNING, IDS_APPNAME, MB_YESNO | MB_ICONWARNING)!=IDYES)\r
 349                                         return;\r
 350                         }\r
 351                 }\r
 352         }\r
 353 #endif\r
 354         m_pathwatcher.Stop();\r
 355         InterlockedExchange(&m_bBlock, TRUE);\r
 356         CDWordArray arDeleted;\r
 357         //first add all the unversioned files the user selected\r
 358         //and check if all versioned files are selected\r
 359         int nchecked = 0;\r
 360         m_bRecursive = true;\r
 361         int nListItems = m_ListCtrl.GetItemCount();\r
 362 \r
 363         CTGitPathList itemsToAdd;\r
 364         CTGitPathList itemsToRemove;\r
 365         //std::set<CString> checkedLists;\r
 366         //std::set<CString> uncheckedLists;\r
 367 \r
 368         //CString checkedfiles;\r
 369         //CString uncheckedfiles;\r
 370 \r
 371         CString cmd;\r
 372         CString out;\r
 373 \r
 374         for (int j=0; j<nListItems; j++)\r
 375         {\r
 376                 //const CGitStatusListCtrl::FileEntry * entry = m_ListCtrl.GetListEntry(j);\r
 377                 CTGitPath *entry = (CTGitPath*)m_ListCtrl.GetItemData(j);\r
 378                 if (entry->m_Checked)\r
 379                 {\r
 380 #if 0\r
 381                         if (entry->status == Git_wc_status_unversioned)\r
 382                         {\r
 383                                 itemsToAdd.AddPath(entry->GetPath());\r
 384                         }\r
 385                         if (entry->status == Git_wc_status_conflicted)\r
 386                         {\r
 387                                 bHasConflicted = true;\r
 388                         }\r
 389                         if (entry->status == Git_wc_status_missing)\r
 390                         {\r
 391                                 itemsToRemove.AddPath(entry->GetPath());\r
 392                         }\r
 393                         if (entry->status == Git_wc_status_deleted)\r
 394                         {\r
 395                                 arDeleted.Add(j);\r
 396                         }\r
 397                         if (entry->IsInExternal())\r
 398                         {\r
 399                                 bCheckedInExternal = true;\r
 400                         }\r
 401 #endif\r
 402                         if( entry->m_Action & CTGitPath::LOGACTIONS_UNVER)\r
 403                                 cmd.Format(_T("git.exe add -f -- \"%s\""),entry->GetGitPathString());\r
 404                         else if ( entry->m_Action & CTGitPath::LOGACTIONS_DELETED)\r
 405                                 cmd.Format(_T("git.exe update-index --remove -- \"%s\""),entry->GetGitPathString());\r
 406                         else\r
 407                                 cmd.Format(_T("git.exe update-index  -- \"%s\""),entry->GetGitPathString());\r
 408 \r
 409                         g_Git.Run(cmd,&out,CP_OEMCP);\r
 410                         nchecked++;\r
 411 \r
 412                         //checkedLists.insert(entry->GetGitPathString());\r
 413 //                      checkedfiles += _T("\"")+entry->GetGitPathString()+_T("\" ");\r
 414                 }\r
 415                 else\r
 416                 {\r
 417                         //uncheckedLists.insert(entry->GetGitPathString());\r
 418                         if(entry->m_Action & CTGitPath::LOGACTIONS_ADDED)\r
 419                         {       //To init git repository, there are not HEAD, so we can use git reset command\r
 420                                 cmd.Format(_T("git.exe rm --cache -- \"%s\""),entry->GetGitPathString());\r
 421                                 g_Git.Run(cmd,&out,CP_OEMCP);   \r
 422                         }\r
 423                         else\r
 424                         {\r
 425                                 cmd.Format(_T("git.exe reset -- %s"),entry->GetGitPathString());\r
 426                                 g_Git.Run(cmd,&out,CP_OEMCP);\r
 427                         }\r
 428 \r
 429                 //      uncheckedfiles += _T("\"")+entry->GetGitPathString()+_T("\" ");\r
 430 #if 0\r
 431                         if ((entry->status != Git_wc_status_unversioned)        &&\r
 432                                 (entry->status != Git_wc_status_ignored))\r
 433                         {\r
 434                                 nUnchecked++;\r
 435                                 uncheckedLists.insert(entry->GetChangeList());\r
 436                                 if (m_bRecursive)\r
 437                                 {\r
 438                                         // This algorithm is for the sake of simplicity of the complexity O(N?\r
 439                                         for (int k=0; k<nListItems; k++)\r
 440                                         {\r
 441                                                 const CGitStatusListCtrl::FileEntry * entryK = m_ListCtrl.GetListEntry(k);\r
 442                                                 if (entryK->IsChecked() && entryK->GetPath().IsAncestorOf(entry->GetPath())  )\r
 443                                                 {\r
 444                                                         // Fall back to a non-recursive commit to prevent items being\r
 445                                                         // committed which aren't checked although its parent is checked\r
 446                                                         // (property change, directory deletion, ... )\r
 447                                                         m_bRecursive = false;\r
 448                                                         break;\r
 449                                                 }\r
 450                                         }\r
 451                                 }\r
 452                         }\r
 453 #endif\r
 454                 }\r
 455 \r
 456                 CShellUpdater::Instance().AddPathForUpdate(*entry);\r
 457         }\r
 458 \r
 459         //if(uncheckedfiles.GetLength()>0)\r
 460         //{\r
 461         //      cmd.Format(_T("git.exe reset -- %s"),uncheckedfiles);\r
 462         //      g_Git.Run(cmd,&out);\r
 463         //}\r
 464 \r
 465         //if(checkedfiles.GetLength()>0)\r
 466         if(nchecked||m_bCommitAmend)\r
 467         {\r
 468         //      cmd.Format(_T("git.exe update-index -- %s"),checkedfiles);\r
 469         //      g_Git.Run(cmd,&out);\r
 470 \r
 471                 CString tempfile=::GetTempFile();\r
 472                 CFile file(tempfile,CFile::modeReadWrite|CFile::modeCreate );\r
 473                 CStringA log=CUnicodeUtils::GetUTF8( m_sLogMessage);\r
 474                 file.Write(log,log.GetLength());\r
 475                 //file.WriteString(m_sLogMessage);\r
 476                 file.Close();\r
 477         \r
 478                 out =_T("");\r
 479                 CString amend;\r
 480                 if(this->m_bCommitAmend)\r
 481                 {\r
 482                         amend=_T("--amend");\r
 483                 }\r
 484                 cmd.Format(_T("git.exe commit %s -F \"%s\""),amend, tempfile);\r
 485                 \r
 486                 CProgressDlg progress;\r
 487                 progress.m_GitCmd=cmd;\r
 488                 progress.m_bShowCommand = FALSE;        // don't show the commit command\r
 489                 progress.m_PreText = out;                       // show any output already generated in log window\r
 490                 progress.DoModal();\r
 491         \r
 492                 CFile::Remove(tempfile);\r
 493         }else\r
 494                 CMessageBox::Show(this->m_hWnd, _T("Nothing Commit"), _T("Commit Finish"), MB_OK | MB_ICONINFORMATION);\r
 495 #if 0\r
 496         if (m_pathwatcher.GetNumberOfChangedPaths() && m_bRecursive)\r
 497         {\r
 498                 // There are paths which got changed (touched at least).\r
 499                 // We have to find out if this affects the selection in the commit dialog\r
 500                 // If it could affect the selection, revert back to a non-recursive commit\r
 501                 CTGitPathList changedList = m_pathwatcher.GetChangedPaths();\r
 502                 changedList.RemoveDuplicates();\r
 503                 for (int i=0; i<changedList.GetCount(); ++i)\r
 504                 {\r
 505                         if (changedList[i].IsAdminDir())\r
 506                         {\r
 507                                 // something inside an admin dir was changed.\r
 508                                 // if it's the entries file, then we have to fully refresh because\r
 509                                 // files may have been added/removed from version control\r
 510                                 if ((changedList[i].GetWinPathString().Right(7).CompareNoCase(_T("entries")) == 0) &&\r
 511                                         (changedList[i].GetWinPathString().Find(_T("\\tmp\\"))<0))\r
 512                                 {\r
 513                                         m_bRecursive = false;\r
 514                                         break;\r
 515                                 }\r
 516                         }\r
 517                         else if (!m_ListCtrl.IsPathShown(changedList[i]))\r
 518                         {\r
 519                                 // a path which is not shown in the list has changed\r
 520                                 CGitStatusListCtrl::FileEntry * entry = m_ListCtrl.GetListEntry(changedList[i]);\r
 521                                 if (entry)\r
 522                                 {\r
 523                                         // check if the changed path would get committed by a recursive commit\r
 524                                         if ((!entry->IsFromDifferentRepository()) &&\r
 525                                                 (!entry->IsInExternal()) &&\r
 526                                                 (!entry->IsNested()) && \r
 527                                                 (!entry->IsChecked()))\r
 528                                         {\r
 529                                                 m_bRecursive = false;\r
 530                                                 break;\r
 531                                         }\r
 532                                 }\r
 533                         }\r
 534                 }\r
 535         }\r
 536 \r
 537 \r
 538         // Now, do all the adds - make sure that the list is sorted so that parents \r
 539         // are added before their children\r
 540         itemsToAdd.SortByPathname();\r
 541         Git Git;\r
 542         if (!Git.Add(itemsToAdd, &m_ProjectProperties, Git_depth_empty, FALSE, FALSE, TRUE))\r
 543         {\r
 544                 CMessageBox::Show(m_hWnd, Git.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);\r
 545                 InterlockedExchange(&m_bBlock, FALSE);\r
 546                 Refresh();\r
 547                 return;\r
 548         }\r
 549 \r
 550         // Remove any missing items\r
 551         // Not sure that this sort is really necessary - indeed, it might be better to do a reverse sort at this point\r
 552         itemsToRemove.SortByPathname();\r
 553         Git.Remove(itemsToRemove, TRUE);\r
 554 \r
 555         //the next step: find all deleted files and check if they're \r
 556         //inside a deleted folder. If that's the case, then remove those\r
 557         //files from the list since they'll get deleted by the parent\r
 558         //folder automatically.\r
 559         m_ListCtrl.Block(TRUE, FALSE);\r
 560         INT_PTR nDeleted = arDeleted.GetCount();\r
 561         for (INT_PTR i=0; i<arDeleted.GetCount(); i++)\r
 562         {\r
 563                 if (m_ListCtrl.GetCheck(arDeleted.GetAt(i)))\r
 564                 {\r
 565                         const CTGitPath& path = m_ListCtrl.GetListEntry(arDeleted.GetAt(i))->GetPath();\r
 566                         if (path.IsDirectory())\r
 567                         {\r
 568                                 //now find all children of this directory\r
 569                                 for (int j=0; j<arDeleted.GetCount(); j++)\r
 570                                 {\r
 571                                         if (i!=j)\r
 572                                         {\r
 573                                                 CGitStatusListCtrl::FileEntry* childEntry = m_ListCtrl.GetListEntry(arDeleted.GetAt(j));\r
 574                                                 if (childEntry->IsChecked())\r
 575                                                 {\r
 576                                                         if (path.IsAncestorOf(childEntry->GetPath()))\r
 577                                                         {\r
 578                                                                 m_ListCtrl.SetEntryCheck(childEntry, arDeleted.GetAt(j), false);\r
 579                                                                 nDeleted--;\r
 580                                                         }\r
 581                                                 }\r
 582                                         }\r
 583                                 }\r
 584                         }\r
 585                 }\r
 586         } \r
 587         m_ListCtrl.Block(FALSE, FALSE);\r
 588 \r
 589         if ((nUnchecked != 0)||(bCheckedInExternal)||(bHasConflicted)||(!m_bRecursive))\r
 590         {\r
 591                 //save only the files the user has checked into the temporary file\r
 592                 m_ListCtrl.WriteCheckedNamesToPathList(m_pathList);\r
 593         }\r
 594         m_ListCtrl.WriteCheckedNamesToPathList(m_selectedPathList);\r
 595         // the item count is used in the progress dialog to show the overall commit\r
 596         // progress.\r
 597         // deleted items only send one notification event, all others send two\r
 598         m_itemsCount = ((m_selectedPathList.GetCount() - nDeleted - itemsToRemove.GetCount()) * 2) + nDeleted + itemsToRemove.GetCount();\r
 599 \r
 600         if ((m_bRecursive)&&(checkedLists.size() == 1))\r
 601         {\r
 602                 // all checked items belong to the same changelist\r
 603                 // find out if there are any unchecked items which belong to that changelist\r
 604                 if (uncheckedLists.find(*checkedLists.begin()) == uncheckedLists.end())\r
 605                         m_sChangeList = *checkedLists.begin();\r
 606         }\r
 607 #endif\r
 608         UpdateData();\r
 609         m_regAddBeforeCommit = m_bShowUnversioned;\r
 610         if (!GetDlgItem(IDC_WHOLE_PROJECT)->IsWindowEnabled())\r
 611                 m_bWholeProject = FALSE;\r
 612         m_regKeepChangelists = m_bKeepChangeList;\r
 613         if (!GetDlgItem(IDC_KEEPLISTS)->IsWindowEnabled())\r
 614                 m_bKeepChangeList = FALSE;\r
 615         InterlockedExchange(&m_bBlock, FALSE);\r
 616         m_sBugID.Trim();\r
 617         if (!m_sBugID.IsEmpty())\r
 618         {\r
 619                 m_sBugID.Replace(_T(", "), _T(","));\r
 620                 m_sBugID.Replace(_T(" ,"), _T(","));\r
 621                 CString sBugID = m_ProjectProperties.sMessage;\r
 622                 sBugID.Replace(_T("%BUGID%"), m_sBugID);\r
 623                 if (m_ProjectProperties.bAppend)\r
 624                         m_sLogMessage += _T("\n") + sBugID + _T("\n");\r
 625                 else\r
 626                         m_sLogMessage = sBugID + _T("\n") + m_sLogMessage;\r
 627         }\r
 628         m_History.AddEntry(m_sLogMessage);\r
 629         m_History.Save();\r
 630 \r
 631         SaveSplitterPos();\r
 632 \r
 633         CResizableStandAloneDialog::OnOK();\r
 634 \r
 635         CShellUpdater::Instance().Flush();\r
 636 }\r
 637 \r
 638 void CCommitDlg::SaveSplitterPos()\r
 639 {\r
 640         if (!IsIconic())\r
 641         {\r
 642                 CRegDWORD regPos = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\CommitDlgSizer"));\r
 643                 RECT rectSplitter;\r
 644                 m_wndSplitter.GetWindowRect(&rectSplitter);\r
 645                 ScreenToClient(&rectSplitter);\r
 646                 regPos = rectSplitter.top;\r
 647         }\r
 648 }\r
 649 \r
 650 UINT CCommitDlg::StatusThreadEntry(LPVOID pVoid)\r
 651 {\r
 652         return ((CCommitDlg*)pVoid)->StatusThread();\r
 653 }\r
 654 \r
 655 UINT CCommitDlg::StatusThread()\r
 656 {\r
 657         //get the status of all selected file/folders recursively\r
 658         //and show the ones which have to be committed to the user\r
 659         //in a list control. \r
 660         InterlockedExchange(&m_bBlock, TRUE);\r
 661         InterlockedExchange(&m_bThreadRunning, TRUE);// so the main thread knows that this thread is still running\r
 662         InterlockedExchange(&m_bRunThread, TRUE);       // if this is set to FALSE, the thread should stop\r
 663         m_bCancelled = false;\r
 664 \r
 665         DialogEnableWindow(IDOK, false);\r
 666         DialogEnableWindow(IDC_SHOWUNVERSIONED, false);\r
 667     DialogEnableWindow(IDC_WHOLE_PROJECT, false);\r
 668         DialogEnableWindow(IDC_SELECTALL, false);\r
 669         GetDlgItem(IDC_EXTERNALWARNING)->ShowWindow(SW_HIDE);\r
 670         DialogEnableWindow(IDC_EXTERNALWARNING, false);\r
 671     // read the list of recent log entries before querying the WC for status\r
 672     // -> the user may select one and modify / update it while we are crawling the WC\r
 673 #if 0\r
 674         if (m_History.GetCount()==0)\r
 675         {\r
 676                 CString reg;\r
 677                 if (m_ListCtrl.m_sUUID.IsEmpty() && m_pathList.GetCount()>0)\r
 678                 {\r
 679                         Git Git;\r
 680                         reg.Format(_T("Software\\TortoiseGit\\History\\commit%s"), (LPCTSTR)Git.GetUUIDFromPath(m_pathList[0]));\r
 681                 }\r
 682                 else\r
 683                         reg.Format(_T("Software\\TortoiseGit\\History\\commit%s"), (LPCTSTR)m_ListCtrl.m_sUUID);\r
 684                 m_History.Load(reg, _T("logmsgs"));\r
 685         }\r
 686 #endif\r
 687     // Initialise the list control with the status of the files/folders below us\r
 688         m_ListCtrl.Clear();\r
 689         BOOL success;\r
 690     if(m_bWholeProject)\r
 691         success=m_ListCtrl.GetStatus(NULL);\r
 692     else\r
 693         success=m_ListCtrl.GetStatus(&m_pathList);\r
 694 \r
 695         //m_ListCtrl.UpdateFileList(git_revnum_t(GIT_REV_ZERO));\r
 696         if(this->m_bShowUnversioned)\r
 697                 m_ListCtrl.UpdateFileList(CGitStatusListCtrl::FILELIST_UNVER,true,&m_pathList);\r
 698         \r
 699         m_ListCtrl.CheckIfChangelistsArePresent(false);\r
 700 \r
 701         DWORD dwShow = SVNSLC_SHOWVERSIONEDBUTNORMALANDEXTERNALSFROMDIFFERENTREPOS | SVNSLC_SHOWLOCKS | SVNSLC_SHOWINCHANGELIST;\r
 702         dwShow |= DWORD(m_regAddBeforeCommit) ? SVNSLC_SHOWUNVERSIONED : 0;\r
 703         if (success)\r
 704         {\r
 705                 if (m_checkedPathList.GetCount())\r
 706                         m_ListCtrl.Show(dwShow, m_checkedPathList);\r
 707                 else\r
 708                 {\r
 709                         DWORD dwCheck = m_bSelectFilesForCommit ? dwShow : 0;\r
 710                         dwCheck &=~(CTGitPath::LOGACTIONS_UNVER); //don't check unversion file default. \r
 711                         m_ListCtrl.Show(dwShow, dwCheck);\r
 712                         m_bSelectFilesForCommit = true;\r
 713                 }\r
 714 \r
 715                 if (m_ListCtrl.HasExternalsFromDifferentRepos())\r
 716                 {\r
 717                         GetDlgItem(IDC_EXTERNALWARNING)->ShowWindow(SW_SHOW);\r
 718                         DialogEnableWindow(IDC_EXTERNALWARNING, TRUE);\r
 719                 }\r
 720                 \r
 721                 SetDlgItemText(IDC_COMMIT_TO, g_Git.GetCurrentBranch());\r
 722                 m_tooltips.AddTool(GetDlgItem(IDC_STATISTICS), m_ListCtrl.GetStatisticsString());\r
 723         }\r
 724         CString logmsg;\r
 725         GetDlgItemText(IDC_LOGMESSAGE, logmsg);\r
 726         DialogEnableWindow(IDOK, logmsg.GetLength() >= m_ProjectProperties.nMinLogSize);\r
 727         if (!success)\r
 728         {\r
 729                 if (!m_ListCtrl.GetLastErrorMessage().IsEmpty())\r
 730                         m_ListCtrl.SetEmptyString(m_ListCtrl.GetLastErrorMessage());\r
 731                 m_ListCtrl.Show(dwShow);\r
 732         }\r
 733         if ((m_ListCtrl.GetItemCount()==0)&&(m_ListCtrl.HasUnversionedItems()))\r
 734         {\r
 735                 if (CMessageBox::Show(m_hWnd, IDS_COMMITDLG_NOTHINGTOCOMMITUNVERSIONED, IDS_APPNAME, MB_ICONINFORMATION | MB_YESNO)==IDYES)\r
 736                 {\r
 737                         m_bShowUnversioned = TRUE;\r
 738                         GetDlgItem(IDC_SHOWUNVERSIONED)->SendMessage(BM_SETCHECK, BST_CHECKED);\r
 739                         DWORD dwShow = (DWORD)(SVNSLC_SHOWVERSIONEDBUTNORMALANDEXTERNALSFROMDIFFERENTREPOS | SVNSLC_SHOWUNVERSIONED | SVNSLC_SHOWLOCKS);\r
 740                         m_ListCtrl.UpdateFileList(CGitStatusListCtrl::FILELIST_UNVER);\r
 741                         m_ListCtrl.Show(dwShow,dwShow&(~CTGitPath::LOGACTIONS_UNVER));\r
 742                 }\r
 743         }\r
 744 \r
 745         CTGitPath commonDir = m_ListCtrl.GetCommonDirectory(false);\r
 746 \r
 747     if(this->m_bWholeProject)   \r
 748         SetWindowText(m_sWindowTitle + _T(" - ") + CString(_T("Whole Project")));\r
 749     else\r
 750             SetWindowText(m_sWindowTitle + _T(" - ") + commonDir.GetWinPathString());\r
 751 \r
 752         m_autolist.clear();\r
 753         // we don't have to block the commit dialog while we fetch the\r
 754         // auto completion list.\r
 755         m_pathwatcher.ClearChangedPaths();\r
 756         InterlockedExchange(&m_bBlock, FALSE);\r
 757         if ((DWORD)CRegDWORD(_T("Software\\TortoiseGit\\Autocompletion"), TRUE)==TRUE)\r
 758         {\r
 759                 m_ListCtrl.Block(TRUE, TRUE);\r
 760                 GetAutocompletionList();\r
 761                 m_ListCtrl.Block(FALSE, FALSE);\r
 762         }\r
 763         if (m_bRunThread)\r
 764         {\r
 765                 DialogEnableWindow(IDC_SHOWUNVERSIONED, true);\r
 766         DialogEnableWindow(IDC_WHOLE_PROJECT, true);\r
 767                 DialogEnableWindow(IDC_SELECTALL, true);\r
 768                 if (m_ListCtrl.HasChangeLists())\r
 769                         DialogEnableWindow(IDC_KEEPLISTS, true);\r
 770                 if (m_ListCtrl.HasLocks())\r
 771                         DialogEnableWindow(IDC_WHOLE_PROJECT, true);\r
 772                 // we have the list, now signal the main thread about it\r
 773                 SendMessage(WM_AUTOLISTREADY);  // only send the message if the thread wasn't told to quit!\r
 774         }\r
 775 \r
 776         InterlockedExchange(&m_bRunThread, FALSE);\r
 777         InterlockedExchange(&m_bThreadRunning, FALSE);\r
 778         // force the cursor to normal\r
 779         RefreshCursor();\r
 780 \r
 781         return 0;\r
 782 }\r
 783 \r
 784 void CCommitDlg::OnCancel()\r
 785 {\r
 786         m_bCancelled = true;\r
 787         if (m_bBlock)\r
 788                 return;\r
 789         m_pathwatcher.Stop();\r
 790         if (m_bThreadRunning)\r
 791         {\r
 792                 InterlockedExchange(&m_bRunThread, FALSE);\r
 793                 WaitForSingleObject(m_pThread->m_hThread, 1000);\r
 794                 if (m_bThreadRunning)\r
 795                 {\r
 796                         // we gave the thread a chance to quit. Since the thread didn't\r
 797                         // listen to us we have to kill it.\r
 798                         TerminateThread(m_pThread->m_hThread, (DWORD)-1);\r
 799                         InterlockedExchange(&m_bThreadRunning, FALSE);\r
 800                 }\r
 801         }\r
 802         UpdateData();\r
 803         m_sBugID.Trim();\r
 804         m_sLogMessage = m_cLogMessage.GetText();\r
 805         if (!m_sBugID.IsEmpty())\r
 806         {\r
 807                 m_sBugID.Replace(_T(", "), _T(","));\r
 808                 m_sBugID.Replace(_T(" ,"), _T(","));\r
 809                 CString sBugID = m_ProjectProperties.sMessage;\r
 810                 sBugID.Replace(_T("%BUGID%"), m_sBugID);\r
 811                 if (m_ProjectProperties.bAppend)\r
 812                         m_sLogMessage += _T("\n") + sBugID + _T("\n");\r
 813                 else\r
 814                         m_sLogMessage = sBugID + _T("\n") + m_sLogMessage;\r
 815         }\r
 816         if (m_ProjectProperties.sLogTemplate.Compare(m_sLogMessage) != 0)\r
 817                 m_History.AddEntry(m_sLogMessage);\r
 818         m_History.Save();\r
 819         SaveSplitterPos();\r
 820         CResizableStandAloneDialog::OnCancel();\r
 821 }\r
 822 \r
 823 void CCommitDlg::OnBnClickedSelectall()\r
 824 {\r
 825         m_tooltips.Pop();       // hide the tooltips\r
 826         UINT state = (m_SelectAll.GetState() & 0x0003);\r
 827         if (state == BST_INDETERMINATE)\r
 828         {\r
 829                 // It is not at all useful to manually place the checkbox into the indeterminate state...\r
 830                 // We will force this on to the unchecked state\r
 831                 state = BST_UNCHECKED;\r
 832                 m_SelectAll.SetCheck(state);\r
 833         }\r
 834         m_ListCtrl.SelectAll(state == BST_CHECKED);\r
 835 }\r
 836 \r
 837 BOOL CCommitDlg::PreTranslateMessage(MSG* pMsg)\r
 838 {\r
 839         if (!m_bBlock)\r
 840                 m_tooltips.RelayEvent(pMsg);\r
 841         if (pMsg->message == WM_KEYDOWN)\r
 842         {\r
 843                 switch (pMsg->wParam)\r
 844                 {\r
 845                 case VK_F5:\r
 846                         {\r
 847                                 if (m_bBlock)\r
 848                                         return CResizableStandAloneDialog::PreTranslateMessage(pMsg);\r
 849                                 Refresh();\r
 850                         }\r
 851                         break;\r
 852                 case VK_RETURN:\r
 853                         {\r
 854                                 if (GetAsyncKeyState(VK_CONTROL)&0x8000)\r
 855                                 {\r
 856                                         if ( GetDlgItem(IDOK)->IsWindowEnabled() )\r
 857                                         {\r
 858                                                 PostMessage(WM_COMMAND, IDOK);\r
 859                                         }\r
 860                                         return TRUE;\r
 861                                 }\r
 862                                 if ( GetFocus()==GetDlgItem(IDC_BUGID) )\r
 863                                 {\r
 864                                         // Pressing RETURN in the bug id control\r
 865                                         // moves the focus to the message\r
 866                                         GetDlgItem(IDC_LOGMESSAGE)->SetFocus();\r
 867                                         return TRUE;\r
 868                                 }\r
 869                         }\r
 870                         break;\r
 871                 }\r
 872         }\r
 873 \r
 874         return CResizableStandAloneDialog::PreTranslateMessage(pMsg);\r
 875 }\r
 876 \r
 877 void CCommitDlg::Refresh()\r
 878 {\r
 879         if (m_bThreadRunning)\r
 880                 return;\r
 881 \r
 882         InterlockedExchange(&m_bBlock, TRUE);\r
 883         m_pThread = AfxBeginThread(StatusThreadEntry, this, THREAD_PRIORITY_NORMAL,0,CREATE_SUSPENDED);\r
 884         if (m_pThread==NULL)\r
 885         {\r
 886                 CMessageBox::Show(this->m_hWnd, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);\r
 887                 InterlockedExchange(&m_bBlock, FALSE);\r
 888         }\r
 889         else\r
 890         {\r
 891                 m_pThread->m_bAutoDelete = FALSE;\r
 892                 m_pThread->ResumeThread();\r
 893         }\r
 894 }\r
 895 \r
 896 void CCommitDlg::OnBnClickedHelp()\r
 897 {\r
 898         OnHelp();\r
 899 }\r
 900 \r
 901 void CCommitDlg::OnBnClickedShowunversioned()\r
 902 {\r
 903         m_tooltips.Pop();       // hide the tooltips\r
 904         UpdateData();\r
 905         m_regAddBeforeCommit = m_bShowUnversioned;\r
 906         if (!m_bBlock)\r
 907         {\r
 908                 DWORD dwShow = m_ListCtrl.GetShowFlags();\r
 909                 if (DWORD(m_regAddBeforeCommit))\r
 910                         dwShow |= SVNSLC_SHOWUNVERSIONED;\r
 911                 else\r
 912                         dwShow &= ~SVNSLC_SHOWUNVERSIONED;\r
 913                 if(dwShow & SVNSLC_SHOWUNVERSIONED)\r
 914                 {\r
 915             if(m_bWholeProject)\r
 916                 m_ListCtrl.GetStatus(NULL,false,false,true);\r
 917             else\r
 918                             m_ListCtrl.GetStatus(&this->m_pathList,false,false,true);\r
 919                 }\r
 920                 m_ListCtrl.Show(dwShow);\r
 921         }\r
 922 }\r
 923 \r
 924 void CCommitDlg::OnStnClickedExternalwarning()\r
 925 {\r
 926         m_tooltips.Popup();\r
 927 }\r
 928 \r
 929 void CCommitDlg::OnEnChangeLogmessage()\r
 930 {\r
 931         UpdateOKButton();\r
 932 }\r
 933 \r
 934 LRESULT CCommitDlg::OnGitStatusListCtrlItemCountChanged(WPARAM, LPARAM)\r
 935 {\r
 936 #if 0\r
 937         if ((m_ListCtrl.GetItemCount() == 0)&&(m_ListCtrl.HasUnversionedItems())&&(!m_bShowUnversioned))\r
 938         {\r
 939                 if (CMessageBox::Show(*this, IDS_COMMITDLG_NOTHINGTOCOMMITUNVERSIONED, IDS_APPNAME, MB_ICONINFORMATION | MB_YESNO)==IDYES)\r
 940                 {\r
 941                         m_bShowUnversioned = TRUE;\r
 942                         DWORD dwShow = GitSLC_SHOWVERSIONEDBUTNORMALANDEXTERNALSFROMDIFFERENTREPOS | GitSLC_SHOWUNVERSIONED | GitSLC_SHOWLOCKS;\r
 943                         m_ListCtrl.Show(dwShow);\r
 944                         UpdateData(FALSE);\r
 945                 }\r
 946         }\r
 947 #endif\r
 948         return 0;\r
 949 }\r
 950 \r
 951 LRESULT CCommitDlg::OnGitStatusListCtrlNeedsRefresh(WPARAM, LPARAM)\r
 952 {\r
 953         Refresh();\r
 954         return 0;\r
 955 }\r
 956 \r
 957 LRESULT CCommitDlg::OnFileDropped(WPARAM, LPARAM /*lParam*/)\r
 958 {\r
 959 #if 0\r
 960         BringWindowToTop();\r
 961         SetForegroundWindow();\r
 962         SetActiveWindow();\r
 963         // if multiple files/folders are dropped\r
 964         // this handler is called for every single item\r
 965         // separately.\r
 966         // To avoid creating multiple refresh threads and\r
 967         // causing crashes, we only add the items to the\r
 968         // list control and start a timer.\r
 969         // When the timer expires, we start the refresh thread,\r
 970         // but only if it isn't already running - otherwise we\r
 971         // restart the timer.\r
 972         CTGitPath path;\r
 973         path.SetFromWin((LPCTSTR)lParam);\r
 974 \r
 975         // just add all the items we get here.\r
 976         // if the item is versioned, the add will fail but nothing\r
 977         // more will happen.\r
 978         Git Git;\r
 979         Git.Add(CTGitPathList(path), &m_ProjectProperties, Git_depth_empty, false, true, true);\r
 980 \r
 981         if (!m_ListCtrl.HasPath(path))\r
 982         {\r
 983                 if (m_pathList.AreAllPathsFiles())\r
 984                 {\r
 985                         m_pathList.AddPath(path);\r
 986                         m_pathList.RemoveDuplicates();\r
 987                         m_updatedPathList.AddPath(path);\r
 988                         m_updatedPathList.RemoveDuplicates();\r
 989                 }\r
 990                 else\r
 991                 {\r
 992                         // if the path list contains folders, we have to check whether\r
 993                         // our just (maybe) added path is a child of one of those. If it is\r
 994                         // a child of a folder already in the list, we must not add it. Otherwise\r
 995                         // that path could show up twice in the list.\r
 996                         bool bHasParentInList = false;\r
 997                         for (int i=0; i<m_pathList.GetCount(); ++i)\r
 998                         {\r
 999                                 if (m_pathList[i].IsAncestorOf(path))\r
1000                                 {\r
1001                                         bHasParentInList = true;\r
1002                                         break;\r
1003                                 }\r
1004                         }\r
1005                         if (!bHasParentInList)\r
1006                         {\r
1007                                 m_pathList.AddPath(path);\r
1008                                 m_pathList.RemoveDuplicates();\r
1009                                 m_updatedPathList.AddPath(path);\r
1010                                 m_updatedPathList.RemoveDuplicates();\r
1011                         }\r
1012                 }\r
1013         }\r
1014         \r
1015         // Always start the timer, since the status of an existing item might have changed\r
1016         SetTimer(REFRESHTIMER, 200, NULL);\r
1017         ATLTRACE(_T("Item %s dropped, timer started\n"), path.GetWinPath());\r
1018 #endif\r
1019         return 0;\r
1020 }\r
1021 \r
1022 LRESULT CCommitDlg::OnAutoListReady(WPARAM, LPARAM)\r
1023 {\r
1024         m_cLogMessage.SetAutoCompletionList(m_autolist, '*');\r
1025         return 0;\r
1026 }\r
1027 \r
1028 //////////////////////////////////////////////////////////////////////////\r
1029 // functions which run in the status thread\r
1030 //////////////////////////////////////////////////////////////////////////\r
1031 \r
1032 void CCommitDlg::ParseRegexFile(const CString& sFile, std::map<CString, CString>& mapRegex)\r
1033 {\r
1034         CString strLine;\r
1035         try\r
1036         {\r
1037                 CStdioFile file(sFile, CFile::typeText | CFile::modeRead | CFile::shareDenyWrite);\r
1038                 while (m_bRunThread && file.ReadString(strLine))\r
1039                 {\r
1040                         int eqpos = strLine.Find('=');\r
1041                         CString rgx;\r
1042                         rgx = strLine.Mid(eqpos+1).Trim();\r
1043 \r
1044                         int pos = -1;\r
1045                         while (((pos = strLine.Find(','))>=0)&&(pos < eqpos))\r
1046                         {\r
1047                                 mapRegex[strLine.Left(pos)] = rgx;\r
1048                                 strLine = strLine.Mid(pos+1).Trim();\r
1049                         }\r
1050                         mapRegex[strLine.Left(strLine.Find('=')).Trim()] = rgx;\r
1051                 }\r
1052                 file.Close();\r
1053         }\r
1054         catch (CFileException* pE)\r
1055         {\r
1056                 TRACE("CFileException loading auto list regex file\n");\r
1057                 pE->Delete();\r
1058                 return;\r
1059         }\r
1060 }\r
1061 void CCommitDlg::GetAutocompletionList()\r
1062 {\r
1063         // the auto completion list is made of strings from each selected files.\r
1064         // the strings used are extracted from the files with regexes found\r
1065         // in the file "autolist.txt".\r
1066         // the format of that file is:\r
1067         // file extensions separated with commas '=' regular expression to use\r
1068         // example:\r
1069         // .h, .hpp = (?<=class[\s])\b\w+\b|(\b\w+(?=[\s ]?\(\);))\r
1070         // .cpp = (?<=[^\s]::)\b\w+\b\r
1071         \r
1072         std::map<CString, CString> mapRegex;\r
1073         CString sRegexFile = CPathUtils::GetAppDirectory();\r
1074         CRegDWORD regtimeout = CRegDWORD(_T("Software\\TortoiseGit\\AutocompleteParseTimeout"), 5);\r
1075         DWORD timeoutvalue = regtimeout*1000;\r
1076         sRegexFile += _T("autolist.txt");\r
1077         if (!m_bRunThread)\r
1078                 return;\r
1079         ParseRegexFile(sRegexFile, mapRegex);\r
1080         SHGetFolderPath(NULL, CSIDL_APPDATA, NULL, SHGFP_TYPE_CURRENT, sRegexFile.GetBuffer(MAX_PATH+1));\r
1081         sRegexFile.ReleaseBuffer();\r
1082         sRegexFile += _T("\\TortoiseGit\\autolist.txt");\r
1083         if (PathFileExists(sRegexFile))\r
1084         {\r
1085                 ParseRegexFile(sRegexFile, mapRegex);\r
1086         }\r
1087         DWORD starttime = GetTickCount();\r
1088 \r
1089         // now we have two arrays of strings, where the first array contains all\r
1090         // file extensions we can use and the second the corresponding regex strings\r
1091         // to apply to those files.\r
1092 \r
1093         // the next step is to go over all files shown in the commit dialog\r
1094         // and scan them for strings we can use\r
1095         int nListItems = m_ListCtrl.GetItemCount();\r
1096 \r
1097         for (int i=0; i<nListItems && m_bRunThread; ++i)\r
1098         {\r
1099                 // stop parsing after timeout\r
1100                 if ((!m_bRunThread) || (GetTickCount() - starttime > timeoutvalue))\r
1101                         return;\r
1102 \r
1103                 CTGitPath *path = (CTGitPath*)m_ListCtrl.GetItemData(i);\r
1104 \r
1105                 if(path == NULL)\r
1106                         continue;\r
1107 \r
1108                 CString sPartPath =path->GetGitPathString();\r
1109                 m_autolist.insert(sPartPath);\r
1110 \r
1111 //              const CGitStatusListCtrl::FileEntry * entry = m_ListCtrl.GetListEntry(i);\r
1112 //              if (!entry)\r
1113 //                      continue;\r
1114                 \r
1115                 // add the path parts to the auto completion list too\r
1116 //              CString sPartPath = entry->GetRelativeGitPath();\r
1117 //              m_autolist.insert(sPartPath);\r
1118 \r
1119 \r
1120                 int pos = 0;\r
1121                 int lastPos = 0;\r
1122                 while ((pos = sPartPath.Find('/', pos)) >= 0)\r
1123                 {\r
1124                         pos++;\r
1125                         lastPos = pos;\r
1126                         m_autolist.insert(sPartPath.Mid(pos));\r
1127                 }\r
1128 \r
1129                 // Last inserted entry is a file name.\r
1130                 // Some users prefer to also list file name without extension.\r
1131                 if (CRegDWORD(_T("Software\\TortoiseGit\\AutocompleteRemovesExtensions"), FALSE))\r
1132                 {\r
1133                         int dotPos = sPartPath.ReverseFind('.');\r
1134                         if ((dotPos >= 0) && (dotPos > lastPos))\r
1135                                 m_autolist.insert(sPartPath.Mid(lastPos, dotPos - lastPos));\r
1136                 }\r
1137 #if 0\r
1138                 if ((entry->status <= Git_wc_status_normal)||(entry->status == Git_wc_status_ignored))\r
1139                         continue;\r
1140 \r
1141                 CString sExt = entry->GetPath().GetFileExtension();\r
1142                 sExt.MakeLower();\r
1143                 // find the regex string which corresponds to the file extension\r
1144                 CString rdata = mapRegex[sExt];\r
1145                 if (rdata.IsEmpty())\r
1146                         continue;\r
1147 \r
1148                 ScanFile(entry->GetPath().GetWinPathString(), rdata);\r
1149                 if ((entry->textstatus != Git_wc_status_unversioned) &&\r
1150                         (entry->textstatus != Git_wc_status_none) &&\r
1151                         (entry->textstatus != Git_wc_status_ignored) &&\r
1152                         (entry->textstatus != Git_wc_status_added) &&\r
1153                         (entry->textstatus != Git_wc_status_normal))\r
1154                 {\r
1155                         CTGitPath basePath = Git::GetPristinePath(entry->GetPath());\r
1156                         if (!basePath.IsEmpty())\r
1157                                 ScanFile(basePath.GetWinPathString(), rdata);\r
1158                 }\r
1159 #endif\r
1160         }\r
1161         ATLTRACE(_T("Auto completion list loaded in %d msec\n"), GetTickCount() - starttime);\r
1162 }\r
1163 \r
1164 void CCommitDlg::ScanFile(const CString& sFilePath, const CString& sRegex)\r
1165 {\r
1166         wstring sFileContent;\r
1167         HANDLE hFile = CreateFile(sFilePath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);\r
1168         if (hFile != INVALID_HANDLE_VALUE)\r
1169         {\r
1170                 DWORD size = GetFileSize(hFile, NULL);\r
1171                 if (size > 1000000L)\r
1172                 {\r
1173                         // no files bigger than 1 Meg\r
1174                         CloseHandle(hFile);\r
1175                         return;\r
1176                 }\r
1177                 // allocate memory to hold file contents\r
1178                 char * buffer = new char[size];\r
1179                 DWORD readbytes;\r
1180                 ReadFile(hFile, buffer, size, &readbytes, NULL);\r
1181                 CloseHandle(hFile);\r
1182                 int opts = 0;\r
1183                 IsTextUnicode(buffer, readbytes, &opts);\r
1184                 if (opts & IS_TEXT_UNICODE_NULL_BYTES)\r
1185                 {\r
1186                         delete [] buffer;\r
1187                         return;\r
1188                 }\r
1189                 if (opts & IS_TEXT_UNICODE_UNICODE_MASK)\r
1190                 {\r
1191                         sFileContent = wstring((wchar_t*)buffer, readbytes/sizeof(WCHAR));\r
1192                 }\r
1193                 if ((opts & IS_TEXT_UNICODE_NOT_UNICODE_MASK)||(opts == 0))\r
1194                 {\r
1195                         int ret = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, (LPCSTR)buffer, readbytes, NULL, 0);\r
1196                         wchar_t * pWideBuf = new wchar_t[ret];\r
1197                         int ret2 = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, (LPCSTR)buffer, readbytes, pWideBuf, ret);\r
1198                         if (ret2 == ret)\r
1199                                 sFileContent = wstring(pWideBuf, ret);\r
1200                         delete [] pWideBuf;\r
1201                 }\r
1202                 delete [] buffer;\r
1203         }\r
1204         if (sFileContent.empty()|| !m_bRunThread)\r
1205         {\r
1206                 return;\r
1207         }\r
1208 \r
1209         try\r
1210         {\r
1211                 const tr1::wregex regCheck(sRegex, tr1::regex_constants::icase | tr1::regex_constants::ECMAScript);\r
1212                 const tr1::wsregex_iterator end;\r
1213                 wstring s = sFileContent;\r
1214                 for (tr1::wsregex_iterator it(s.begin(), s.end(), regCheck); it != end; ++it)\r
1215                 {\r
1216                         const tr1::wsmatch match = *it;\r
1217                         for (size_t i=1; i<match.size(); ++i)\r
1218                         {\r
1219                                 if (match[i].second-match[i].first)\r
1220                                 {\r
1221                                         ATLTRACE(_T("matched keyword : %s\n"), wstring(match[i]).c_str());\r
1222                                         m_autolist.insert(wstring(match[i]).c_str());\r
1223                                 }\r
1224                         }\r
1225                 }\r
1226         }\r
1227         catch (exception) {}\r
1228 }\r
1229 \r
1230 // CSciEditContextMenuInterface\r
1231 void CCommitDlg::InsertMenuItems(CMenu& mPopup, int& nCmd)\r
1232 {\r
1233         CString sMenuItemText(MAKEINTRESOURCE(IDS_COMMITDLG_POPUP_PASTEFILELIST));\r
1234         m_nPopupPasteListCmd = nCmd++;\r
1235         mPopup.AppendMenu(MF_STRING | MF_ENABLED, m_nPopupPasteListCmd, sMenuItemText);\r
1236 }\r
1237 \r
1238 bool CCommitDlg::HandleMenuItemClick(int cmd, CSciEdit * pSciEdit)\r
1239 {\r
1240 \r
1241         if (m_bBlock)\r
1242                 return false;\r
1243         if (cmd == m_nPopupPasteListCmd)\r
1244         {\r
1245                 CString logmsg;\r
1246                 TCHAR buf[MAX_STATUS_STRING_LENGTH];\r
1247                 int nListItems = m_ListCtrl.GetItemCount();\r
1248                 for (int i=0; i<nListItems; ++i)\r
1249                 {\r
1250                         CTGitPath * entry = (CTGitPath*)m_ListCtrl.GetItemData(i);\r
1251                         if (entry&&entry->m_Checked)\r
1252                         {\r
1253                                 CString line;\r
1254                                 CString status = entry->GetActionName();\r
1255                                 if(entry->m_Action & CTGitPath::LOGACTIONS_UNVER)\r
1256                                         status = _T("Add");\r
1257 \r
1258                                 //git_wc_status_kind status = entry->status;\r
1259                                 WORD langID = (WORD)CRegStdWORD(_T("Software\\TortoiseGit\\LanguageID"), GetUserDefaultLangID());\r
1260                                 if (m_ProjectProperties.bFileListInEnglish)\r
1261                                         langID = 1033;\r
1262                                 \r
1263                                 line.Format(_T("%-10s %s\r\n"),status , (LPCTSTR)m_ListCtrl.GetItemText(i,0));\r
1264                                 logmsg += line;\r
1265                         }\r
1266                 }\r
1267                 pSciEdit->InsertText(logmsg);\r
1268                 return true;\r
1269         }\r
1270 \r
1271         return false;\r
1272 }\r
1273 \r
1274 void CCommitDlg::OnTimer(UINT_PTR nIDEvent)\r
1275 {\r
1276         switch (nIDEvent)\r
1277         {\r
1278         case ENDDIALOGTIMER:\r
1279                 KillTimer(ENDDIALOGTIMER);\r
1280                 EndDialog(0);\r
1281                 break;\r
1282         case REFRESHTIMER:\r
1283                 if (m_bThreadRunning)\r
1284                 {\r
1285                         SetTimer(REFRESHTIMER, 200, NULL);\r
1286                         ATLTRACE("Wait some more before refreshing\n");\r
1287                 }\r
1288                 else\r
1289                 {\r
1290                         KillTimer(REFRESHTIMER);\r
1291                         ATLTRACE("Refreshing after items dropped\n");\r
1292                         Refresh();\r
1293                 }\r
1294                 break;\r
1295         }\r
1296         __super::OnTimer(nIDEvent);\r
1297 }\r
1298 \r
1299 void CCommitDlg::OnBnClickedHistory()\r
1300 {\r
1301         m_tooltips.Pop();       // hide the tooltips\r
1302         if (m_pathList.GetCount() == 0)\r
1303                 return;\r
1304 #if 0\r
1305         CHistoryDlg historyDlg;\r
1306         historyDlg.SetHistory(m_History);\r
1307         if (historyDlg.DoModal() != IDOK)\r
1308                 return;\r
1309 \r
1310         CString sMsg = historyDlg.GetSelectedText();\r
1311         if (sMsg != m_cLogMessage.GetText().Left(sMsg.GetLength()))\r
1312         {\r
1313                 CString sBugID = m_ProjectProperties.GetBugIDFromLog(sMsg);\r
1314                 if (!sBugID.IsEmpty())\r
1315                 {\r
1316                         SetDlgItemText(IDC_BUGID, sBugID);\r
1317                 }\r
1318                 if (m_ProjectProperties.sLogTemplate.Compare(m_cLogMessage.GetText())!=0)\r
1319                         m_cLogMessage.InsertText(sMsg, !m_cLogMessage.GetText().IsEmpty());\r
1320                 else\r
1321                         m_cLogMessage.SetText(sMsg);\r
1322         }\r
1323 \r
1324         UpdateOKButton();\r
1325         GetDlgItem(IDC_LOGMESSAGE)->SetFocus();\r
1326 #endif\r
1327 }\r
1328 \r
1329 void CCommitDlg::OnBnClickedBugtraqbutton()\r
1330 {\r
1331 #if 0\r
1332         m_tooltips.Pop();       // hide the tooltips\r
1333         CString sMsg = m_cLogMessage.GetText();\r
1334 \r
1335         if (m_BugTraqProvider == NULL)\r
1336                 return;\r
1337 \r
1338         BSTR parameters = m_bugtraq_association.GetParameters().AllocSysString();\r
1339         BSTR commonRoot = SysAllocString(m_pathList.GetCommonRoot().GetDirectory().GetWinPath());\r
1340         SAFEARRAY *pathList = SafeArrayCreateVector(VT_BSTR, 0, m_pathList.GetCount());\r
1341 \r
1342         for (LONG index = 0; index < m_pathList.GetCount(); ++index)\r
1343                 SafeArrayPutElement(pathList, &index, m_pathList[index].GetGitPathString().AllocSysString());\r
1344 \r
1345         BSTR originalMessage = sMsg.AllocSysString();\r
1346         BSTR temp = NULL;\r
1347 \r
1348         // first try the IBugTraqProvider2 interface\r
1349         CComPtr<IBugTraqProvider2> pProvider2 = NULL;\r
1350         HRESULT hr = m_BugTraqProvider.QueryInterface(&pProvider2);\r
1351         if (SUCCEEDED(hr))\r
1352         {\r
1353                 CString common = m_ListCtrl.GetCommonURL(false).GetGitPathString();\r
1354                 BSTR repositoryRoot = common.AllocSysString();\r
1355                 if (FAILED(hr = pProvider2->GetCommitMessage2(GetSafeHwnd(), parameters, repositoryRoot, commonRoot, pathList, originalMessage, &temp)))\r
1356                 {\r
1357                         CString sErr;\r
1358                         sErr.Format(IDS_ERR_FAILEDISSUETRACKERCOM, m_bugtraq_association.GetProviderName(), _com_error(hr).ErrorMessage());\r
1359                         CMessageBox::Show(m_hWnd, sErr, _T("TortoiseGit"), MB_ICONERROR);\r
1360                 }\r
1361                 else\r
1362                         m_cLogMessage.SetText(temp);\r
1363         }\r
1364         else\r
1365         {\r
1366                 // if IBugTraqProvider2 failed, try IBugTraqProvider\r
1367                 CComPtr<IBugTraqProvider> pProvider = NULL;\r
1368                 HRESULT hr = m_BugTraqProvider.QueryInterface(&pProvider);\r
1369                 if (FAILED(hr))\r
1370                 {\r
1371                         CString sErr;\r
1372                         sErr.Format(IDS_ERR_FAILEDISSUETRACKERCOM, (LPCTSTR)m_bugtraq_association.GetProviderName(), _com_error(hr).ErrorMessage());\r
1373                         CMessageBox::Show(m_hWnd, sErr, _T("TortoiseGit"), MB_ICONERROR);\r
1374                         return;\r
1375                 }\r
1376 \r
1377                 if (FAILED(hr = pProvider->GetCommitMessage(GetSafeHwnd(), parameters, commonRoot, pathList, originalMessage, &temp)))\r
1378                 {\r
1379                         CString sErr;\r
1380                         sErr.Format(IDS_ERR_FAILEDISSUETRACKERCOM, m_bugtraq_association.GetProviderName(), _com_error(hr).ErrorMessage());\r
1381                         CMessageBox::Show(m_hWnd, sErr, _T("TortoiseGit"), MB_ICONERROR);\r
1382                 }\r
1383                 else\r
1384                         m_cLogMessage.SetText(temp);\r
1385         }\r
1386 \r
1387         m_cLogMessage.SetFocus();\r
1388 \r
1389         SysFreeString(temp);\r
1390 #endif\r
1391 }\r
1392 \r
1393 LRESULT CCommitDlg::OnGitStatusListCtrlCheckChanged(WPARAM, LPARAM)\r
1394 {\r
1395         UpdateOKButton();\r
1396         return 0;\r
1397 }\r
1398 \r
1399 void CCommitDlg::UpdateOKButton()\r
1400 {\r
1401 #if 0\r
1402         BOOL bValidLogSize = FALSE;\r
1403 \r
1404     if (m_cLogMessage.GetText().GetLength() >= m_ProjectProperties.nMinLogSize)\r
1405                 bValidLogSize = !m_bBlock;\r
1406 \r
1407         LONG nSelectedItems = m_ListCtrl.GetSelected();\r
1408         DialogEnableWindow(IDOK, bValidLogSize && nSelectedItems>0);\r
1409 #endif\r
1410 }\r
1411 \r
1412 \r
1413 LRESULT CCommitDlg::DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam)\r
1414 {\r
1415         switch (message) {\r
1416         case WM_NOTIFY:\r
1417                 if (wParam == IDC_SPLITTER)\r
1418                 { \r
1419                         SPC_NMHDR* pHdr = (SPC_NMHDR*) lParam;\r
1420                         DoSize(pHdr->delta);\r
1421                 }\r
1422                 break;\r
1423         }\r
1424 \r
1425         return __super::DefWindowProc(message, wParam, lParam);\r
1426 }\r
1427 \r
1428 void CCommitDlg::SetSplitterRange()\r
1429 {\r
1430         if ((m_ListCtrl)&&(m_cLogMessage))\r
1431         {\r
1432                 CRect rcTop;\r
1433                 m_cLogMessage.GetWindowRect(rcTop);\r
1434                 ScreenToClient(rcTop);\r
1435                 CRect rcMiddle;\r
1436                 m_ListCtrl.GetWindowRect(rcMiddle);\r
1437                 ScreenToClient(rcMiddle);\r
1438                 if (rcMiddle.Height() && rcMiddle.Width())\r
1439                         m_wndSplitter.SetRange(rcTop.top+60, rcMiddle.bottom-80);\r
1440         }\r
1441 }\r
1442 \r
1443 void CCommitDlg::DoSize(int delta)\r
1444 {\r
1445         RemoveAnchor(IDC_MESSAGEGROUP);\r
1446         RemoveAnchor(IDC_LOGMESSAGE);\r
1447         RemoveAnchor(IDC_SPLITTER);\r
1448         RemoveAnchor(IDC_SIGNOFF);\r
1449         RemoveAnchor(IDC_COMMIT_AMEND);\r
1450         RemoveAnchor(IDC_LISTGROUP);\r
1451         RemoveAnchor(IDC_FILELIST);\r
1452         CSplitterControl::ChangeHeight(&m_cLogMessage, delta, CW_TOPALIGN);\r
1453         CSplitterControl::ChangeHeight(GetDlgItem(IDC_MESSAGEGROUP), delta, CW_TOPALIGN);\r
1454         CSplitterControl::ChangeHeight(&m_ListCtrl, -delta, CW_BOTTOMALIGN);\r
1455         CSplitterControl::ChangeHeight(GetDlgItem(IDC_LISTGROUP), -delta, CW_BOTTOMALIGN);\r
1456         CSplitterControl::ChangePos(GetDlgItem(IDC_SIGNOFF),0,delta);\r
1457         CSplitterControl::ChangePos(GetDlgItem(IDC_COMMIT_AMEND),0,delta);\r
1458         AddAnchor(IDC_MESSAGEGROUP, TOP_LEFT, TOP_RIGHT);\r
1459         AddAnchor(IDC_LOGMESSAGE, TOP_LEFT, TOP_RIGHT);\r
1460         AddAnchor(IDC_SPLITTER, TOP_LEFT, TOP_RIGHT);\r
1461         AddAnchor(IDC_LISTGROUP, TOP_LEFT, BOTTOM_RIGHT);\r
1462         AddAnchor(IDC_FILELIST, TOP_LEFT, BOTTOM_RIGHT);\r
1463         AddAnchor(IDC_SIGNOFF,TOP_RIGHT);\r
1464         AddAnchor(IDC_COMMIT_AMEND,TOP_LEFT);\r
1465         ArrangeLayout();\r
1466         // adjust the minimum size of the dialog to prevent the resizing from\r
1467         // moving the list control too far down.\r
1468         CRect rcLogMsg;\r
1469         m_cLogMessage.GetClientRect(rcLogMsg);\r
1470         SetMinTrackSize(CSize(m_DlgOrigRect.Width(), m_DlgOrigRect.Height()-m_LogMsgOrigRect.Height()+rcLogMsg.Height()));\r
1471 \r
1472         SetSplitterRange();\r
1473         m_cLogMessage.Invalidate();\r
1474         GetDlgItem(IDC_LOGMESSAGE)->Invalidate();\r
1475 }\r
1476 \r
1477 void CCommitDlg::OnSize(UINT nType, int cx, int cy)\r
1478 {\r
1479     // first, let the resizing take place\r
1480     __super::OnSize(nType, cx, cy);\r
1481 \r
1482     //set range\r
1483     SetSplitterRange();\r
1484 }\r
1485 \r
1486 \r
1487 void CCommitDlg::OnBnClickedSignOff()\r
1488 {\r
1489         // TODO: Add your control notification handler code here\r
1490         CString str;\r
1491         CString username;\r
1492         CString email;\r
1493         username=g_Git.GetUserName();\r
1494         email=g_Git.GetUserEmail();\r
1495         username.Remove(_T('\n'));\r
1496         email.Remove(_T('\n'));\r
1497         str.Format(_T("Signed-off-by: %s <%s>\n"),username,email);\r
1498 \r
1499         m_cLogMessage.SetText(m_cLogMessage.GetText()+_T("\r\n\r\n")+str);\r
1500 }\r
1501 \r
1502 void CCommitDlg::OnStnClickedCommitlabel()\r
1503 {\r
1504         // TODO: Add your control notification handler code here\r
1505 }\r
1506 \r
1507 void CCommitDlg::OnBnClickedCommitAmend()\r
1508 {\r
1509     // TODO: Add your control notification handler code here\r
1510         this->UpdateData();\r
1511         if(this->m_bCommitAmend && this->m_AmendStr.IsEmpty())\r
1512         {\r
1513                 GitRev rev;\r
1514                 BYTE_VECTOR vector;\r
1515                 CString head(_T("HEAD"));\r
1516                 g_Git.GetLog(vector,head,NULL,1);\r
1517                 rev.ParserFromLog(vector);\r
1518                 m_AmendStr=rev.m_Subject+_T("\n\n")+rev.m_Body;\r
1519         }\r
1520 \r
1521         if(this->m_bCommitAmend)\r
1522         {\r
1523                 this->m_NoAmendStr=this->m_cLogMessage.GetText();\r
1524                 m_cLogMessage.SetText(m_AmendStr);\r
1525 \r
1526         }else\r
1527         {\r
1528                 this->m_AmendStr=this->m_cLogMessage.GetText();\r
1529                 m_cLogMessage.SetText(m_NoAmendStr);\r
1530 \r
1531         }\r
1532 \r
1533 }\r
1534 \r
1535 void CCommitDlg::OnBnClickedWholeProject()\r
1536 {\r
1537     // TODO: Add your control notification handler code here\r
1538     m_tooltips.Pop();   // hide the tooltips\r
1539         UpdateData();\r
1540     m_ListCtrl.Clear();\r
1541         if (!m_bBlock)\r
1542         {\r
1543             if(m_bWholeProject)\r
1544             m_ListCtrl.GetStatus(NULL,true,false,true);\r
1545         else\r
1546                     m_ListCtrl.GetStatus(&this->m_pathList,true,false,true);\r
1547                 \r
1548                 m_ListCtrl.Show(m_ListCtrl.GetShowFlags());\r
1549         }\r
1550 \r
1551         CTGitPath commonDir = m_ListCtrl.GetCommonDirectory(false);\r
1552 \r
1553     if(this->m_bWholeProject)   \r
1554         SetWindowText(m_sWindowTitle + _T(" - ") + CString(_T("Whole Project")));\r
1555     else\r
1556             SetWindowText(m_sWindowTitle + _T(" - ") + commonDir.GetWinPathString());\r
1557 \r
1558 }\r