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