TortoiseProc/LogDlg.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 "cursor.h"\r
  22 #include "InputDlg.h"\r
  23 #include "PropDlg.h"\r
  24 #include "SVNProgressDlg.h"\r
  25 #include "ProgressDlg.h"\r
  26 //#include "RepositoryBrowser.h"\r
  27 //#include "CopyDlg.h"\r
  28 //#include "StatGraphDlg.h"\r
  29 #include "Logdlg.h"\r
  30 #include "MessageBox.h"\r
  31 #include "Registry.h"\r
  32 #include "AppUtils.h"\r
  33 #include "PathUtils.h"\r
  34 #include "StringUtils.h"\r
  35 #include "UnicodeUtils.h"\r
  36 #include "TempFile.h"\r
  37 //#include "GitInfo.h"\r
  38 //#include "GitDiff.h"\r
  39 #include "IconMenu.h"\r
  40 //#include "RevisionRangeDlg.h"\r
  41 //#include "BrowseFolder.h"\r
  42 //#include "BlameDlg.h"\r
  43 //#include "Blame.h"\r
  44 //#include "GitHelpers.h"\r
  45 #include "GitStatus.h"\r
  46 //#include "LogDlgHelper.h"\r
  47 //#include "CachedLogInfo.h"\r
  48 //#include "RepositoryInfo.h"\r
  49 //#include "EditPropertiesDlg.h"\r
  50 \r
  51 \r
  52 #if (NTDDI_VERSION < NTDDI_LONGHORN)\r
  53 \r
  54 enum LISTITEMSTATES_MINE {\r
  55         LISS_NORMAL = 1,\r
  56         LISS_HOT = 2,\r
  57         LISS_SELECTED = 3,\r
  58         LISS_DISABLED = 4,\r
  59         LISS_SELECTEDNOTFOCUS = 5,\r
  60         LISS_HOTSELECTED = 6,\r
  61 };\r
  62 \r
  63 #define MCS_NOTRAILINGDATES  0x0040\r
  64 #define MCS_SHORTDAYSOFWEEK  0x0080\r
  65 #define MCS_NOSELCHANGEONNAV 0x0100\r
  66 \r
  67 #define DTM_SETMCSTYLE    (DTM_FIRST + 11)\r
  68 \r
  69 #endif\r
  70 \r
  71 #define ICONITEMBORDER 5\r
  72 \r
  73 const UINT CLogDlg::m_FindDialogMessage = RegisterWindowMessage(FINDMSGSTRING);\r
  74 \r
  75 \r
  76 enum LogDlgContextMenuCommands\r
  77 {\r
  78         // needs to start with 1, since 0 is the return value if *nothing* is clicked on in the context menu\r
  79         ID_COMPARE = 1,\r
  80         ID_SAVEAS,\r
  81         ID_COMPARETWO,\r
  82         ID_UPDATE,\r
  83         ID_COPY,\r
  84         ID_REVERTREV,\r
  85         ID_MERGEREV,\r
  86         ID_GNUDIFF1,\r
  87         ID_GNUDIFF2,\r
  88         ID_FINDENTRY,\r
  89         ID_OPEN,\r
  90         ID_BLAME,\r
  91         ID_REPOBROWSE,\r
  92         ID_LOG,\r
  93         ID_POPPROPS,\r
  94         ID_EDITAUTHOR,\r
  95         ID_EDITLOG,\r
  96         ID_DIFF,\r
  97         ID_OPENWITH,\r
  98         ID_COPYCLIPBOARD,\r
  99         ID_CHECKOUT,\r
 100         ID_REVERTTOREV,\r
 101         ID_BLAMECOMPARE,\r
 102         ID_BLAMETWO,\r
 103         ID_BLAMEDIFF,\r
 104         ID_VIEWREV,\r
 105         ID_VIEWPATHREV,\r
 106         ID_EXPORT,\r
 107         ID_COMPAREWITHPREVIOUS,\r
 108         ID_BLAMEWITHPREVIOUS,\r
 109         ID_GETMERGELOGS,\r
 110         ID_REVPROPS\r
 111 };\r
 112 \r
 113 \r
 114 IMPLEMENT_DYNAMIC(CLogDlg, CResizableStandAloneDialog)\r
 115 CLogDlg::CLogDlg(CWnd* pParent /*=NULL*/)\r
 116         : CResizableStandAloneDialog(CLogDlg::IDD, pParent)\r
 117         , m_logcounter(0)\r
 118         , m_nSearchIndex(0)\r
 119         , m_wParam(0)\r
 120         , m_nSelectedFilter(LOGFILTER_ALL)\r
 121         , m_bNoDispUpdates(FALSE)\r
 122         , m_currentChangedArray(NULL)\r
 123         , m_nSortColumn(0)\r
 124         , m_bShowedAll(false)\r
 125         , m_bSelect(false)\r
 126         , m_regLastStrict(_T("Software\\TortoiseGit\\LastLogStrict"), FALSE)\r
 127         , m_regMaxBugIDColWidth(_T("Software\\TortoiseGit\\MaxBugIDColWidth"), 200)\r
 128         , m_bSelectionMustBeContinuous(false)\r
 129         , m_bShowBugtraqColumn(false)\r
 130         , m_lowestRev(_T(""))\r
 131         , m_bStrictStopped(false)\r
 132         , m_sLogInfo(_T(""))\r
 133         , m_pFindDialog(NULL)\r
 134         , m_bCancelled(FALSE)\r
 135         , m_pNotifyWindow(NULL)\r
 136         , m_bThreadRunning(FALSE)\r
 137         , m_bAscending(FALSE)\r
 138         , m_pStoreSelection(NULL)\r
 139         , m_limit(0)\r
 140         , m_childCounter(0)\r
 141         , m_maxChild(0)\r
 142         , m_bIncludeMerges(FALSE)\r
 143         , m_hAccel(NULL)\r
 144         , m_bVista(false)\r
 145 {\r
 146         m_bFilterWithRegex = !!CRegDWORD(_T("Software\\TortoiseGit\\UseRegexFilter"), TRUE);\r
 147         // use the default GUI font, create a copy of it and\r
 148         // change the copy to BOLD (leave the rest of the font\r
 149         // the same)\r
 150         HFONT hFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);\r
 151         LOGFONT lf = {0};\r
 152         GetObject(hFont, sizeof(LOGFONT), &lf);\r
 153         lf.lfWeight = FW_BOLD;\r
 154         m_boldFont = CreateFontIndirect(&lf);\r
 155 }\r
 156 \r
 157 CLogDlg::~CLogDlg()\r
 158 {\r
 159         InterlockedExchange(&m_bNoDispUpdates, TRUE);\r
 160     m_CurrentFilteredChangedArray.RemoveAll();\r
 161         m_logEntries.ClearAll();\r
 162         DestroyIcon(m_hModifiedIcon);\r
 163         DestroyIcon(m_hReplacedIcon);\r
 164         DestroyIcon(m_hAddedIcon);\r
 165         DestroyIcon(m_hDeletedIcon);\r
 166         if ( m_pStoreSelection )\r
 167         {\r
 168                 delete m_pStoreSelection;\r
 169                 m_pStoreSelection = NULL;\r
 170         }\r
 171         if (m_boldFont)\r
 172                 DeleteObject(m_boldFont);\r
 173 }\r
 174 \r
 175 void CLogDlg::DoDataExchange(CDataExchange* pDX)\r
 176 {\r
 177         CResizableStandAloneDialog::DoDataExchange(pDX);\r
 178         DDX_Control(pDX, IDC_LOGLIST, m_LogList);\r
 179         DDX_Control(pDX, IDC_LOGMSG, m_ChangedFileListCtrl);\r
 180         DDX_Control(pDX, IDC_PROGRESS, m_LogProgress);\r
 181         DDX_Control(pDX, IDC_SPLITTERTOP, m_wndSplitter1);\r
 182         DDX_Control(pDX, IDC_SPLITTERBOTTOM, m_wndSplitter2);\r
 183         DDX_Check(pDX, IDC_CHECK_STOPONCOPY, m_bStrict);\r
 184         DDX_Text(pDX, IDC_SEARCHEDIT, m_sFilterText);\r
 185         DDX_Control(pDX, IDC_DATEFROM, m_DateFrom);\r
 186         DDX_Control(pDX, IDC_DATETO, m_DateTo);\r
 187         DDX_Control(pDX, IDC_HIDEPATHS, m_cHidePaths);\r
 188         DDX_Control(pDX, IDC_GETALL, m_btnShow);\r
 189         DDX_Text(pDX, IDC_LOGINFO, m_sLogInfo);\r
 190         DDX_Check(pDX, IDC_INCLUDEMERGE, m_bIncludeMerges);\r
 191         DDX_Control(pDX, IDC_SEARCHEDIT, m_cFilter);\r
 192 }\r
 193 \r
 194 BEGIN_MESSAGE_MAP(CLogDlg, CResizableStandAloneDialog)\r
 195         ON_REGISTERED_MESSAGE(m_FindDialogMessage, OnFindDialogMessage) \r
 196         ON_BN_CLICKED(IDC_GETALL, OnBnClickedGetall)\r
 197         ON_NOTIFY(NM_DBLCLK, IDC_LOGMSG, OnNMDblclkChangedFileList)\r
 198         ON_NOTIFY(NM_DBLCLK, IDC_LOGLIST, OnNMDblclkLoglist)\r
 199         ON_WM_CONTEXTMENU()\r
 200         ON_WM_SETCURSOR()\r
 201         ON_BN_CLICKED(IDHELP, OnBnClickedHelp)\r
 202         ON_NOTIFY(LVN_ITEMCHANGED, IDC_LOGLIST, OnLvnItemchangedLoglist)\r
 203         ON_NOTIFY(EN_LINK, IDC_MSGVIEW, OnEnLinkMsgview)\r
 204         ON_BN_CLICKED(IDC_STATBUTTON, OnBnClickedStatbutton)\r
 205         ON_NOTIFY(NM_CUSTOMDRAW, IDC_LOGLIST, OnNMCustomdrawLoglist)\r
 206         ON_MESSAGE(WM_FILTEREDIT_INFOCLICKED, OnClickedInfoIcon)\r
 207         ON_MESSAGE(WM_FILTEREDIT_CANCELCLICKED, OnClickedCancelFilter)\r
 208         ON_NOTIFY(LVN_GETDISPINFO, IDC_LOGLIST, OnLvnGetdispinfoLoglist)\r
 209         ON_EN_CHANGE(IDC_SEARCHEDIT, OnEnChangeSearchedit)\r
 210         ON_WM_TIMER()\r
 211         ON_NOTIFY(DTN_DATETIMECHANGE, IDC_DATETO, OnDtnDatetimechangeDateto)\r
 212         ON_NOTIFY(DTN_DATETIMECHANGE, IDC_DATEFROM, OnDtnDatetimechangeDatefrom)\r
 213         ON_BN_CLICKED(IDC_NEXTHUNDRED, OnBnClickedNexthundred)\r
 214         ON_NOTIFY(NM_CUSTOMDRAW, IDC_LOGMSG, OnNMCustomdrawChangedFileList)\r
 215         ON_NOTIFY(LVN_GETDISPINFO, IDC_LOGMSG, OnLvnGetdispinfoChangedFileList)\r
 216         ON_NOTIFY(LVN_COLUMNCLICK, IDC_LOGLIST, OnLvnColumnclick)\r
 217         ON_NOTIFY(LVN_COLUMNCLICK, IDC_LOGMSG, OnLvnColumnclickChangedFileList)\r
 218         ON_BN_CLICKED(IDC_HIDEPATHS, OnBnClickedHidepaths)\r
 219         ON_NOTIFY(LVN_ODFINDITEM, IDC_LOGLIST, OnLvnOdfinditemLoglist)\r
 220         ON_BN_CLICKED(IDC_CHECK_STOPONCOPY, &CLogDlg::OnBnClickedCheckStoponcopy)\r
 221         ON_NOTIFY(DTN_DROPDOWN, IDC_DATEFROM, &CLogDlg::OnDtnDropdownDatefrom)\r
 222         ON_NOTIFY(DTN_DROPDOWN, IDC_DATETO, &CLogDlg::OnDtnDropdownDateto)\r
 223         ON_WM_SIZE()\r
 224         ON_BN_CLICKED(IDC_INCLUDEMERGE, &CLogDlg::OnBnClickedIncludemerge)\r
 225         ON_BN_CLICKED(IDC_REFRESH, &CLogDlg::OnBnClickedRefresh)\r
 226         ON_COMMAND(ID_LOGDLG_REFRESH,&CLogDlg::OnRefresh)\r
 227         ON_COMMAND(ID_LOGDLG_FIND,&CLogDlg::OnFind)\r
 228         ON_COMMAND(ID_LOGDLG_FOCUSFILTER,&CLogDlg::OnFocusFilter)\r
 229         ON_COMMAND(ID_EDIT_COPY, &CLogDlg::OnEditCopy)\r
 230 END_MESSAGE_MAP()\r
 231 \r
 232 void CLogDlg::SetParams(const CTGitPath& path, GitRev pegrev, GitRev startrev, GitRev endrev, int limit, BOOL bStrict /* = FALSE */, BOOL bSaveStrict /* = TRUE */)\r
 233 {\r
 234         m_path = path;\r
 235         m_pegrev = pegrev;\r
 236         m_startrev = startrev;\r
 237         m_LogRevision = startrev;\r
 238         m_endrev = endrev;\r
 239         m_hasWC = !path.IsUrl();\r
 240         m_bStrict = bStrict;\r
 241         m_bSaveStrict = bSaveStrict;\r
 242         m_limit = limit;\r
 243         if (::IsWindow(m_hWnd))\r
 244                 UpdateData(FALSE);\r
 245 }\r
 246 \r
 247 BOOL CLogDlg::OnInitDialog()\r
 248 {\r
 249         CResizableStandAloneDialog::OnInitDialog();\r
 250 \r
 251         m_hAccel = LoadAccelerators(AfxGetResourceHandle(),MAKEINTRESOURCE(IDR_ACC_LOGDLG));\r
 252 \r
 253         OSVERSIONINFOEX inf;\r
 254         SecureZeroMemory(&inf, sizeof(OSVERSIONINFOEX));\r
 255         inf.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);\r
 256         GetVersionEx((OSVERSIONINFO *)&inf);\r
 257         WORD fullver = MAKEWORD(inf.dwMinorVersion, inf.dwMajorVersion);\r
 258         m_bVista = (fullver >= 0x0600);\r
 259 \r
 260         // use the state of the "stop on copy/rename" option from the last time\r
 261         if (!m_bStrict)\r
 262                 m_bStrict = m_regLastStrict;\r
 263         UpdateData(FALSE);\r
 264         CString temp;\r
 265         if (m_limit)\r
 266                 temp.Format(IDS_LOG_SHOWNEXT, m_limit);\r
 267         else\r
 268                 temp.Format(IDS_LOG_SHOWNEXT, (int)(DWORD)CRegDWORD(_T("Software\\TortoiseGit\\NumberOfLogs"), 100));\r
 269 \r
 270         SetDlgItemText(IDC_NEXTHUNDRED, temp);\r
 271 \r
 272         // set the font to use in the log message view, configured in the settings dialog\r
 273         CAppUtils::CreateFontForLogs(m_logFont);\r
 274         GetDlgItem(IDC_MSGVIEW)->SetFont(&m_logFont);\r
 275         // automatically detect URLs in the log message and turn them into links\r
 276         GetDlgItem(IDC_MSGVIEW)->SendMessage(EM_AUTOURLDETECT, TRUE, NULL);\r
 277         // make the log message rich edit control send a message when the mouse pointer is over a link\r
 278         GetDlgItem(IDC_MSGVIEW)->SendMessage(EM_SETEVENTMASK, NULL, ENM_LINK);\r
 279         m_LogList.SetExtendedStyle(LVS_EX_FULLROWSELECT | LVS_EX_DOUBLEBUFFER | LVS_EX_SUBITEMIMAGES);\r
 280 \r
 281         // the "hide unrelated paths" checkbox should be indeterminate\r
 282         m_cHidePaths.SetCheck(BST_INDETERMINATE);\r
 283 \r
 284         // load the icons for the action columns\r
 285         m_hModifiedIcon = (HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_ACTIONMODIFIED), IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);\r
 286         m_hReplacedIcon = (HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_ACTIONREPLACED), IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);\r
 287         m_hAddedIcon = (HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_ACTIONADDED), IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);\r
 288         m_hDeletedIcon = (HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_ACTIONDELETED), IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);\r
 289         \r
 290         // if there is a working copy, load the project properties\r
 291         // to get information about the bugtraq: integration\r
 292         if (m_hasWC)\r
 293                 m_ProjectProperties.ReadProps(m_path);\r
 294 \r
 295         // the bugtraq issue id column is only shown if the bugtraq:url or bugtraq:regex is set\r
 296         if ((!m_ProjectProperties.sUrl.IsEmpty())||(!m_ProjectProperties.sCheckRe.IsEmpty()))\r
 297                 m_bShowBugtraqColumn = true;\r
 298 \r
 299         theme.SetWindowTheme(m_LogList.GetSafeHwnd(), L"Explorer", NULL);\r
 300         theme.SetWindowTheme(m_ChangedFileListCtrl.GetSafeHwnd(), L"Explorer", NULL);\r
 301 \r
 302         // set up the columns\r
 303         m_LogList.DeleteAllItems();\r
 304         int c = ((CHeaderCtrl*)(m_LogList.GetDlgItem(0)))->GetItemCount()-1;\r
 305         while (c>=0)\r
 306                 m_LogList.DeleteColumn(c--);\r
 307         temp.LoadString(IDS_LOG_REVISION);\r
 308         m_LogList.InsertColumn(0, temp);\r
 309         \r
 310         // make the revision column right aligned\r
 311         LVCOLUMN Column;\r
 312         Column.mask = LVCF_FMT;\r
 313         Column.fmt = LVCFMT_RIGHT;\r
 314         m_LogList.SetColumn(0, &Column); \r
 315         \r
 316 //      CString log;\r
 317 //      g_Git.GetLog(log);\r
 318 \r
 319         temp.LoadString(IDS_LOG_ACTIONS);\r
 320         m_LogList.InsertColumn(1, temp);\r
 321         temp.LoadString(IDS_LOG_AUTHOR);\r
 322         m_LogList.InsertColumn(2, temp);\r
 323         temp.LoadString(IDS_LOG_DATE);\r
 324         m_LogList.InsertColumn(3, temp);\r
 325         if (m_bShowBugtraqColumn)\r
 326         {\r
 327                 temp = m_ProjectProperties.sLabel;\r
 328                 if (temp.IsEmpty())\r
 329                         temp.LoadString(IDS_LOG_BUGIDS);\r
 330                 m_LogList.InsertColumn(4, temp);\r
 331         }\r
 332         temp.LoadString(IDS_LOG_MESSAGE);\r
 333         m_LogList.InsertColumn(m_bShowBugtraqColumn ? 5 : 4, temp);\r
 334         m_LogList.SetRedraw(false);\r
 335         ResizeAllListCtrlCols();\r
 336         m_LogList.SetRedraw(true);\r
 337 \r
 338         m_ChangedFileListCtrl.SetExtendedStyle ( LVS_EX_FULLROWSELECT | LVS_EX_DOUBLEBUFFER );\r
 339         m_ChangedFileListCtrl.DeleteAllItems();\r
 340         c = ((CHeaderCtrl*)(m_ChangedFileListCtrl.GetDlgItem(0)))->GetItemCount()-1;\r
 341         while (c>=0)\r
 342                 m_ChangedFileListCtrl.DeleteColumn(c--);\r
 343         temp.LoadString(IDS_PROGRS_ACTION);\r
 344         m_ChangedFileListCtrl.InsertColumn(0, temp);\r
 345         temp.LoadString(IDS_PROGRS_PATH);\r
 346         m_ChangedFileListCtrl.InsertColumn(1, temp);\r
 347         temp.LoadString(IDS_LOG_COPYFROM);\r
 348         m_ChangedFileListCtrl.InsertColumn(2, temp);\r
 349         temp.LoadString(IDS_LOG_REVISION);\r
 350         m_ChangedFileListCtrl.InsertColumn(3, temp);\r
 351         m_ChangedFileListCtrl.SetRedraw(false);\r
 352         CAppUtils::ResizeAllListCtrlCols(&m_ChangedFileListCtrl);\r
 353         m_ChangedFileListCtrl.SetRedraw(true);\r
 354 \r
 355 \r
 356         GetDlgItem(IDC_LOGLIST)->UpdateData(FALSE);\r
 357 \r
 358         m_logcounter = 0;\r
 359         m_sMessageBuf.Preallocate(100000);\r
 360 \r
 361         // set the dialog title to "Log - path/to/whatever/we/show/the/log/for"\r
 362         SetDlgTitle(false);\r
 363 \r
 364         m_tooltips.Create(this);\r
 365         CheckRegexpTooltip();\r
 366 \r
 367         SetSplitterRange();\r
 368         \r
 369         // the filter control has a 'cancel' button (the red 'X'), we need to load its bitmap\r
 370         m_cFilter.SetCancelBitmaps(IDI_CANCELNORMAL, IDI_CANCELPRESSED);\r
 371         m_cFilter.SetInfoIcon(IDI_LOGFILTER);\r
 372         m_cFilter.SetValidator(this);\r
 373         \r
 374         AdjustControlSize(IDC_HIDEPATHS);\r
 375         AdjustControlSize(IDC_CHECK_STOPONCOPY);\r
 376         AdjustControlSize(IDC_INCLUDEMERGE);\r
 377 \r
 378         GetClientRect(m_DlgOrigRect);\r
 379         m_LogList.GetClientRect(m_LogListOrigRect);\r
 380         GetDlgItem(IDC_MSGVIEW)->GetClientRect(m_MsgViewOrigRect);\r
 381         m_ChangedFileListCtrl.GetClientRect(m_ChgOrigRect);\r
 382 \r
 383         m_DateFrom.SendMessage(DTM_SETMCSTYLE, 0, MCS_WEEKNUMBERS|MCS_NOTODAY|MCS_NOTRAILINGDATES|MCS_NOSELCHANGEONNAV);\r
 384         m_DateTo.SendMessage(DTM_SETMCSTYLE, 0, MCS_WEEKNUMBERS|MCS_NOTODAY|MCS_NOTRAILINGDATES|MCS_NOSELCHANGEONNAV);\r
 385 \r
 386         // resizable stuff\r
 387         AddAnchor(IDC_FROMLABEL, TOP_LEFT);\r
 388         AddAnchor(IDC_DATEFROM, TOP_LEFT);\r
 389         AddAnchor(IDC_TOLABEL, TOP_LEFT);\r
 390         AddAnchor(IDC_DATETO, TOP_LEFT);\r
 391 \r
 392         SetFilterCueText();\r
 393         AddAnchor(IDC_SEARCHEDIT, TOP_LEFT, TOP_RIGHT);\r
 394         \r
 395         AddAnchor(IDC_LOGLIST, TOP_LEFT, TOP_RIGHT);\r
 396         AddAnchor(IDC_SPLITTERTOP, TOP_LEFT, TOP_RIGHT);\r
 397         AddAnchor(IDC_MSGVIEW, TOP_LEFT, BOTTOM_RIGHT);\r
 398         AddAnchor(IDC_SPLITTERBOTTOM, BOTTOM_LEFT, BOTTOM_RIGHT);\r
 399         AddAnchor(IDC_LOGMSG, BOTTOM_LEFT, BOTTOM_RIGHT);\r
 400 \r
 401         AddAnchor(IDC_LOGINFO, BOTTOM_LEFT, BOTTOM_RIGHT);      \r
 402         AddAnchor(IDC_HIDEPATHS, BOTTOM_LEFT);  \r
 403         AddAnchor(IDC_CHECK_STOPONCOPY, BOTTOM_LEFT);\r
 404         AddAnchor(IDC_INCLUDEMERGE, BOTTOM_LEFT);\r
 405         AddAnchor(IDC_GETALL, BOTTOM_LEFT);\r
 406         AddAnchor(IDC_NEXTHUNDRED, BOTTOM_LEFT);\r
 407         AddAnchor(IDC_REFRESH, BOTTOM_LEFT);\r
 408         AddAnchor(IDC_STATBUTTON, BOTTOM_RIGHT);\r
 409         AddAnchor(IDC_PROGRESS, BOTTOM_LEFT, BOTTOM_RIGHT);\r
 410         AddAnchor(IDOK, BOTTOM_RIGHT);\r
 411         AddAnchor(IDCANCEL, BOTTOM_RIGHT);\r
 412         AddAnchor(IDHELP, BOTTOM_RIGHT);\r
 413 \r
 414 //      SetPromptParentWindow(m_hWnd);\r
 415 \r
 416         if (hWndExplorer)\r
 417                 CenterWindow(CWnd::FromHandle(hWndExplorer));\r
 418         EnableSaveRestore(_T("LogDlg"));\r
 419 \r
 420         DWORD yPos1 = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\LogDlgSizer1"));\r
 421         DWORD yPos2 = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\LogDlgSizer2"));\r
 422         RECT rcDlg, rcLogList, rcChgMsg;\r
 423         GetClientRect(&rcDlg);\r
 424         m_LogList.GetWindowRect(&rcLogList);\r
 425         ScreenToClient(&rcLogList);\r
 426         m_ChangedFileListCtrl.GetWindowRect(&rcChgMsg);\r
 427         ScreenToClient(&rcChgMsg);\r
 428         if (yPos1)\r
 429         {\r
 430                 RECT rectSplitter;\r
 431                 m_wndSplitter1.GetWindowRect(&rectSplitter);\r
 432                 ScreenToClient(&rectSplitter);\r
 433                 int delta = yPos1 - rectSplitter.top;\r
 434 \r
 435                 if ((rcLogList.bottom + delta > rcLogList.top)&&(rcLogList.bottom + delta < rcChgMsg.bottom - 30))\r
 436                 {\r
 437                         m_wndSplitter1.SetWindowPos(NULL, 0, yPos1, 0, 0, SWP_NOSIZE);\r
 438                         DoSizeV1(delta);\r
 439                 }\r
 440         }\r
 441         if (yPos2)\r
 442         {\r
 443                 RECT rectSplitter;\r
 444                 m_wndSplitter2.GetWindowRect(&rectSplitter);\r
 445                 ScreenToClient(&rectSplitter);\r
 446                 int delta = yPos2 - rectSplitter.top;\r
 447 \r
 448                 if ((rcChgMsg.top + delta < rcChgMsg.bottom)&&(rcChgMsg.top + delta > rcLogList.top + 30))\r
 449                 {\r
 450                         m_wndSplitter2.SetWindowPos(NULL, 0, yPos2, 0, 0, SWP_NOSIZE);\r
 451                         DoSizeV2(delta);\r
 452                 }\r
 453         }\r
 454 \r
 455         \r
 456         if (m_bSelect)\r
 457         {\r
 458                 // the dialog is used to select revisions\r
 459                 if (m_bSelectionMustBeContinuous)\r
 460                         DialogEnableWindow(IDOK, (m_LogList.GetSelectedCount()!=0)&&(IsSelectionContinuous()));\r
 461                 else\r
 462                         DialogEnableWindow(IDOK, m_LogList.GetSelectedCount()!=0);\r
 463         }\r
 464         else\r
 465         {\r
 466                 // the dialog is used to just view log messages\r
 467                 GetDlgItemText(IDOK, temp);\r
 468                 SetDlgItemText(IDCANCEL, temp);\r
 469                 GetDlgItem(IDOK)->ShowWindow(SW_HIDE);\r
 470         }\r
 471         \r
 472         // set the choices for the "Show All" button\r
 473         temp.LoadString(IDS_LOG_SHOWALL);\r
 474         m_btnShow.AddEntry(temp);\r
 475         temp.LoadString(IDS_LOG_SHOWRANGE);\r
 476         m_btnShow.AddEntry(temp);\r
 477         m_btnShow.SetCurrentEntry((LONG)CRegDWORD(_T("Software\\TortoiseGit\\ShowAllEntry")));\r
 478 \r
 479         m_mergedRevs.clear();\r
 480 \r
 481         // first start a thread to obtain the log messages without\r
 482         // blocking the dialog\r
 483         m_tTo = 0;\r
 484         m_tFrom = (DWORD)-1;\r
 485         InterlockedExchange(&m_bThreadRunning, TRUE);\r
 486         InterlockedExchange(&m_bNoDispUpdates, TRUE);\r
 487         if (AfxBeginThread(LogThreadEntry, this)==NULL)\r
 488         {\r
 489                 InterlockedExchange(&m_bThreadRunning, FALSE);\r
 490                 InterlockedExchange(&m_bNoDispUpdates, FALSE);\r
 491                 CMessageBox::Show(NULL, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);\r
 492         }\r
 493         GetDlgItem(IDC_LOGLIST)->SetFocus();\r
 494         return FALSE;\r
 495 }\r
 496 \r
 497 void CLogDlg::SetDlgTitle(bool bOffline)\r
 498 {\r
 499         if (m_sTitle.IsEmpty())\r
 500                 GetWindowText(m_sTitle);\r
 501 \r
 502         if (bOffline)\r
 503         {\r
 504                 CString sTemp;\r
 505                 if (m_path.IsUrl())\r
 506                         sTemp.Format(IDS_LOG_DLGTITLEOFFLINE, (LPCTSTR)m_sTitle, (LPCTSTR)m_path.GetUIPathString());\r
 507                 else if (m_path.IsDirectory())\r
 508                         sTemp.Format(IDS_LOG_DLGTITLEOFFLINE, (LPCTSTR)m_sTitle, (LPCTSTR)m_path.GetWinPathString());\r
 509                 else\r
 510                         sTemp.Format(IDS_LOG_DLGTITLEOFFLINE, (LPCTSTR)m_sTitle, (LPCTSTR)m_path.GetFilename());\r
 511                 SetWindowText(sTemp);\r
 512         }\r
 513         else\r
 514         {\r
 515                 if (m_path.IsUrl())\r
 516                         SetWindowText(m_sTitle + _T(" - ") + m_path.GetUIPathString());\r
 517                 else if (m_path.IsDirectory())\r
 518                         SetWindowText(m_sTitle + _T(" - ") + m_path.GetWinPathString());\r
 519                 else\r
 520                         SetWindowText(m_sTitle + _T(" - ") + m_path.GetFilename());\r
 521         }\r
 522 }\r
 523 \r
 524 void CLogDlg::CheckRegexpTooltip()\r
 525 {\r
 526         CWnd *pWnd = GetDlgItem(IDC_SEARCHEDIT);\r
 527         // Since tooltip describes regexp features, show it only if regexps are enabled.\r
 528         if (m_bFilterWithRegex)\r
 529         {\r
 530                 m_tooltips.AddTool(pWnd, IDS_LOG_FILTER_REGEX_TT);\r
 531         }\r
 532         else\r
 533                 m_tooltips.DelTool(pWnd);\r
 534 }\r
 535 \r
 536 void CLogDlg::EnableOKButton()\r
 537 {\r
 538         if (m_bSelect)\r
 539         {\r
 540                 // the dialog is used to select revisions\r
 541                 if (m_bSelectionMustBeContinuous)\r
 542                         DialogEnableWindow(IDOK, (m_LogList.GetSelectedCount()!=0)&&(IsSelectionContinuous()));\r
 543                 else\r
 544                         DialogEnableWindow(IDOK, m_LogList.GetSelectedCount()!=0);\r
 545         }\r
 546         else\r
 547                 DialogEnableWindow(IDOK, TRUE);\r
 548 }\r
 549 \r
 550 void CLogDlg::FillLogMessageCtrl(bool bShow /* = true*/)\r
 551 {\r
 552         // we fill here the log message rich edit control,\r
 553         // and also populate the changed files list control\r
 554         // according to the selected revision(s).\r
 555 #if 0\r
 556         CWnd * pMsgView = GetDlgItem(IDC_MSGVIEW);\r
 557         // empty the log message view\r
 558         pMsgView->SetWindowText(_T(" "));\r
 559         // empty the changed files list\r
 560         m_ChangedFileListCtrl.SetRedraw(FALSE);\r
 561         InterlockedExchange(&m_bNoDispUpdates, TRUE);\r
 562         m_currentChangedArray = NULL;\r
 563         m_ChangedFileListCtrl.SetExtendedStyle ( LVS_EX_FULLROWSELECT | LVS_EX_DOUBLEBUFFER );\r
 564         m_ChangedFileListCtrl.DeleteAllItems();\r
 565         m_ChangedFileListCtrl.SetItemCountEx(0);\r
 566 \r
 567         // if we're not here to really show a selected revision, just\r
 568         // get out of here after clearing the views, which is what is intended\r
 569         // if that flag is not set.\r
 570         if (!bShow)\r
 571         {\r
 572                 // force a redraw\r
 573                 m_ChangedFileListCtrl.Invalidate();\r
 574                 InterlockedExchange(&m_bNoDispUpdates, FALSE);\r
 575                 m_ChangedFileListCtrl.SetRedraw(TRUE);\r
 576                 return;\r
 577         }\r
 578 \r
 579         // depending on how many revisions are selected, we have to do different\r
 580         // tasks.\r
 581         int selCount = m_LogList.GetSelectedCount();\r
 582         if (selCount == 0)\r
 583         {\r
 584                 // if nothing is selected, we have nothing more to do\r
 585                 InterlockedExchange(&m_bNoDispUpdates, FALSE);\r
 586                 m_ChangedFileListCtrl.SetRedraw(TRUE);\r
 587                 return;\r
 588         }\r
 589         else if (selCount == 1)\r
 590         {\r
 591                 // if one revision is selected, we have to fill the log message view\r
 592                 // with the corresponding log message, and also fill the changed files\r
 593                 // list fully.\r
 594                 POSITION pos = m_LogList.GetFirstSelectedItemPosition();\r
 595                 int selIndex = m_LogList.GetNextSelectedItem(pos);\r
 596                 if (selIndex >= m_arShownList.GetCount())\r
 597                 {\r
 598                         InterlockedExchange(&m_bNoDispUpdates, FALSE);\r
 599                         m_ChangedFileListCtrl.SetRedraw(TRUE);\r
 600                         return;\r
 601                 }\r
 602                 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(selIndex));\r
 603 \r
 604                 // set the log message text\r
 605                 pMsgView->SetWindowText(pLogEntry->sMessage);\r
 606                 // turn bug ID's into links if the bugtraq: properties have been set\r
 607                 // and we can find a match of those in the log message\r
 608                 m_ProjectProperties.FindBugID(pLogEntry->sMessage, pMsgView);\r
 609                 CAppUtils::FormatTextInRichEditControl(pMsgView);\r
 610                 m_currentChangedArray = pLogEntry->pArChangedPaths;\r
 611                 if (m_currentChangedArray == NULL)\r
 612                 {\r
 613                         InterlockedExchange(&m_bNoDispUpdates, FALSE);\r
 614                         m_ChangedFileListCtrl.SetRedraw(TRUE);\r
 615                         return;\r
 616                 }\r
 617                 // fill in the changed files list control\r
 618                 if ((m_cHidePaths.GetState() & 0x0003)==BST_CHECKED)\r
 619                 {\r
 620                         m_CurrentFilteredChangedArray.RemoveAll();\r
 621                         for (INT_PTR c = 0; c < m_currentChangedArray->GetCount(); ++c)\r
 622                         {\r
 623                                 LogChangedPath * cpath = m_currentChangedArray->GetAt(c);\r
 624                                 if (cpath == NULL)\r
 625                                         continue;\r
 626                                 if (m_currentChangedArray->GetAt(c)->sPath.Left(m_sRelativeRoot.GetLength()).Compare(m_sRelativeRoot)==0)\r
 627                                 {\r
 628                                         m_CurrentFilteredChangedArray.Add(cpath);\r
 629                                 }\r
 630                         }\r
 631                         m_currentChangedArray = &m_CurrentFilteredChangedArray;\r
 632                 }\r
 633         }\r
 634         else\r
 635         {\r
 636                 // more than one revision is selected:\r
 637                 // the log message view must be emptied\r
 638                 // the changed files list contains all the changed paths from all\r
 639                 // selected revisions, with 'doubles' removed\r
 640                 m_currentChangedPathList = GetChangedPathsFromSelectedRevisions(true);\r
 641         }\r
 642         \r
 643         // redraw the views\r
 644         InterlockedExchange(&m_bNoDispUpdates, FALSE);\r
 645         if (m_currentChangedArray)\r
 646         {\r
 647                 m_ChangedFileListCtrl.SetItemCountEx(m_currentChangedArray->GetCount());\r
 648                 m_ChangedFileListCtrl.RedrawItems(0, m_currentChangedArray->GetCount());\r
 649         }\r
 650         else if (m_currentChangedPathList.GetCount())\r
 651         {\r
 652                 m_ChangedFileListCtrl.SetItemCountEx(m_currentChangedPathList.GetCount());\r
 653                 m_ChangedFileListCtrl.RedrawItems(0, m_currentChangedPathList.GetCount());\r
 654         }\r
 655         else\r
 656         {\r
 657                 m_ChangedFileListCtrl.SetItemCountEx(0);\r
 658                 m_ChangedFileListCtrl.Invalidate();\r
 659         }\r
 660         CAppUtils::ResizeAllListCtrlCols(&m_ChangedFileListCtrl);\r
 661         // sort according to the settings\r
 662         if (m_nSortColumnPathList > 0)\r
 663                 SetSortArrow(&m_ChangedFileListCtrl, m_nSortColumnPathList, m_bAscendingPathList);\r
 664         else\r
 665                 SetSortArrow(&m_ChangedFileListCtrl, -1, false);\r
 666         m_ChangedFileListCtrl.SetRedraw(TRUE);\r
 667 #endif\r
 668 }\r
 669 \r
 670 void CLogDlg::OnBnClickedGetall()\r
 671 {\r
 672         GetAll();\r
 673 }\r
 674 \r
 675 void CLogDlg::GetAll(bool bForceAll /* = false */)\r
 676 {\r
 677 #if 0\r
 678         // fetch all requested log messages, either the specified range or\r
 679         // really *all* available log messages.\r
 680         UpdateData();\r
 681         INT_PTR entry = m_btnShow.GetCurrentEntry();\r
 682         if (bForceAll)\r
 683                 entry = 0;\r
 684 \r
 685         switch (entry)\r
 686         {\r
 687         case 0: // show all\r
 688         \r
 689                 m_endrev = 0;\r
 690                 m_startrev = m_LogRevision;\r
 691                 if (m_bStrict)\r
 692                         m_bShowedAll = true;\r
 693 \r
 694                 break;\r
 695         case 1: // show range\r
 696                 {\r
 697 \r
 698                         // ask for a revision range\r
 699                         CRevisionRangeDlg dlg;\r
 700                         dlg.SetStartRevision(m_startrev);\r
 701                         dlg.SetEndRevision( (m_endrev>=0) ? m_endrev : 0);\r
 702                         if (dlg.DoModal()!=IDOK)\r
 703                         {\r
 704                                 return;\r
 705                         }\r
 706                         m_endrev = dlg.GetEndRevision();\r
 707                         m_startrev = dlg.GetStartRevision();\r
 708                         if (((m_endrev.IsNumber())&&(m_startrev.IsNumber()))||\r
 709                                 (m_endrev.IsHead()||m_startrev.IsHead()))\r
 710                         {\r
 711                                 if (((LONG)m_startrev < (LONG)m_endrev)||\r
 712                                         (m_endrev.IsHead()))\r
 713                                 {\r
 714                                         git_revnum_t temp = m_startrev;\r
 715                                         m_startrev = m_endrev;\r
 716                                         m_endrev = temp;\r
 717                                 }\r
 718                         }\r
 719                         m_bShowedAll = false;\r
 720                 }\r
 721 \r
 722                 break;\r
 723         }\r
 724         m_ChangedFileListCtrl.SetItemCountEx(0);\r
 725         m_ChangedFileListCtrl.Invalidate();\r
 726         // We need to create CStoreSelection on the heap or else\r
 727         // the variable will run out of the scope before the\r
 728         // thread ends. Therefore we let the thread delete\r
 729         // the instance.\r
 730         m_pStoreSelection = new CStoreSelection(this);\r
 731         m_LogList.SetItemCountEx(0);\r
 732         m_LogList.Invalidate();\r
 733         InterlockedExchange(&m_bNoDispUpdates, TRUE);\r
 734         CWnd * pMsgView = GetDlgItem(IDC_MSGVIEW);\r
 735         pMsgView->SetWindowText(_T(""));\r
 736 \r
 737         SetSortArrow(&m_LogList, -1, true);\r
 738 \r
 739         m_LogList.DeleteAllItems();\r
 740         m_arShownList.RemoveAll();\r
 741         m_logEntries.ClearAll();\r
 742 \r
 743         m_logcounter = 0;\r
 744         m_bCancelled = FALSE;\r
 745         m_tTo = 0;\r
 746         m_tFrom = (DWORD)-1;\r
 747         m_limit = 0;\r
 748 \r
 749         InterlockedExchange(&m_bThreadRunning, TRUE);\r
 750         if (AfxBeginThread(LogThreadEntry, this)==NULL)\r
 751         {\r
 752                 InterlockedExchange(&m_bThreadRunning, FALSE);\r
 753                 CMessageBox::Show(NULL, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);\r
 754         }\r
 755         GetDlgItem(IDC_LOGLIST)->UpdateData(FALSE);\r
 756         InterlockedExchange(&m_bNoDispUpdates, FALSE);\r
 757 #endif\r
 758 }\r
 759 \r
 760 void CLogDlg::OnBnClickedRefresh()\r
 761 {\r
 762         m_limit = 0;\r
 763         Refresh (true);\r
 764 }\r
 765 \r
 766 void CLogDlg::Refresh (bool autoGoOnline)\r
 767 {\r
 768 #if 0\r
 769         // refreshing means re-downloading the already shown log messages\r
 770         UpdateData();\r
 771         m_maxChild = 0;\r
 772         m_childCounter = 0;\r
 773 \r
 774         if ((m_limit == 0)||(m_bStrict)||(int(m_logEntries.size()-1) > m_limit))\r
 775         {\r
 776                 if (m_logEntries.size() != 0)\r
 777                 {\r
 778                         m_endrev = m_logEntries[m_logEntries.size()-1]->Rev;\r
 779                 }\r
 780         }\r
 781         m_startrev = -1;\r
 782         m_bCancelled = FALSE;\r
 783 \r
 784         // We need to create CStoreSelection on the heap or else\r
 785         // the variable will run out of the scope before the\r
 786         // thread ends. Therefore we let the thread delete\r
 787         // the instance.\r
 788         m_pStoreSelection = new CStoreSelection(this);\r
 789         m_ChangedFileListCtrl.SetItemCountEx(0);\r
 790         m_ChangedFileListCtrl.Invalidate();\r
 791         m_LogList.SetItemCountEx(0);\r
 792         m_LogList.Invalidate();\r
 793         InterlockedExchange(&m_bNoDispUpdates, TRUE);\r
 794         CWnd * pMsgView = GetDlgItem(IDC_MSGVIEW);\r
 795         pMsgView->SetWindowText(_T(""));\r
 796 \r
 797         SetSortArrow(&m_LogList, -1, true);\r
 798 \r
 799         m_LogList.DeleteAllItems();\r
 800         m_arShownList.RemoveAll();\r
 801         m_logEntries.ClearAll();\r
 802 \r
 803     // reset the cached HEAD property & go on-line\r
 804 \r
 805     if (autoGoOnline)\r
 806     {\r
 807             SetDlgTitle (false);\r
 808         logCachePool.GetRepositoryInfo().ResetHeadRevision (m_sUUID, m_sRepositoryRoot);\r
 809     }\r
 810 \r
 811         InterlockedExchange(&m_bThreadRunning, TRUE);\r
 812         if (AfxBeginThread(LogThreadEntry, this)==NULL)\r
 813         {\r
 814                 InterlockedExchange(&m_bThreadRunning, FALSE);\r
 815                 CMessageBox::Show(NULL, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);\r
 816         }\r
 817         GetDlgItem(IDC_LOGLIST)->UpdateData(FALSE);\r
 818         InterlockedExchange(&m_bNoDispUpdates, FALSE);\r
 819 #endif\r
 820 }\r
 821 \r
 822 void CLogDlg::OnBnClickedNexthundred()\r
 823 {\r
 824 #if 0\r
 825         UpdateData();\r
 826         // we have to fetch the next X log messages.\r
 827         if (m_logEntries.size() < 1)\r
 828         {\r
 829                 // since there weren't any log messages fetched before, just\r
 830                 // fetch all since we don't have an 'anchor' to fetch the 'next'\r
 831                 // messages from.\r
 832                 return GetAll(true);\r
 833         }\r
 834         git_revnum_t rev = m_logEntries[m_logEntries.size()-1]->Rev;\r
 835 \r
 836         if (rev < 1)\r
 837                 return;         // do nothing! No more revisions to get\r
 838 \r
 839         m_startrev = rev;\r
 840         m_endrev = 0;\r
 841         m_bCancelled = FALSE;\r
 842 \r
 843     // rev is is revision we already have and we will receive it again\r
 844     // -> fetch one extra revision to get NumberOfLogs *new* revisions\r
 845 \r
 846         m_limit = (int)(DWORD)CRegDWORD(_T("Software\\TortoiseGit\\NumberOfLogs"), 100) +1;\r
 847         InterlockedExchange(&m_bNoDispUpdates, TRUE);\r
 848         SetSortArrow(&m_LogList, -1, true);\r
 849         InterlockedExchange(&m_bThreadRunning, TRUE);\r
 850         // We need to create CStoreSelection on the heap or else\r
 851         // the variable will run out of the scope before the\r
 852         // thread ends. Therefore we let the thread delete\r
 853         // the instance.\r
 854         m_pStoreSelection = new CStoreSelection(this);\r
 855 \r
 856         // since we fetch the log from the last revision we already have,\r
 857         // we have to remove that revision entry to avoid getting it twice\r
 858         m_logEntries.pop_back();\r
 859         if (AfxBeginThread(LogThreadEntry, this)==NULL)\r
 860         {\r
 861                 InterlockedExchange(&m_bThreadRunning, FALSE);\r
 862                 CMessageBox::Show(NULL, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);\r
 863         }\r
 864         InterlockedExchange(&m_bNoDispUpdates, TRUE);\r
 865         GetDlgItem(IDC_LOGLIST)->UpdateData(FALSE);\r
 866 #endif\r
 867 }\r
 868 \r
 869 BOOL CLogDlg::Cancel()\r
 870 {\r
 871         return m_bCancelled;\r
 872 }\r
 873 \r
 874 void CLogDlg::SaveSplitterPos()\r
 875 {\r
 876         if (!IsIconic())\r
 877         {\r
 878                 CRegDWORD regPos1 = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\LogDlgSizer1"));\r
 879                 CRegDWORD regPos2 = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\LogDlgSizer2"));\r
 880                 RECT rectSplitter;\r
 881                 m_wndSplitter1.GetWindowRect(&rectSplitter);\r
 882                 ScreenToClient(&rectSplitter);\r
 883                 regPos1 = rectSplitter.top;\r
 884                 m_wndSplitter2.GetWindowRect(&rectSplitter);\r
 885                 ScreenToClient(&rectSplitter);\r
 886                 regPos2 = rectSplitter.top;\r
 887         }\r
 888 }\r
 889 \r
 890 void CLogDlg::OnCancel()\r
 891 {\r
 892         // canceling means stopping the working thread if it's still running.\r
 893         // we do this by using the Subversion cancel callback.\r
 894         // But canceling can also mean just to close the dialog, depending on the\r
 895         // text shown on the cancel button (it could simply read "OK").\r
 896         CString temp, temp2;\r
 897         GetDlgItemText(IDOK, temp);\r
 898         temp2.LoadString(IDS_MSGBOX_CANCEL);\r
 899         if ((temp.Compare(temp2)==0)||(m_bThreadRunning))\r
 900         {\r
 901                 m_bCancelled = true;\r
 902                 return;\r
 903         }\r
 904         UpdateData();\r
 905         if (m_bSaveStrict)\r
 906                 m_regLastStrict = m_bStrict;\r
 907         CRegDWORD reg = CRegDWORD(_T("Software\\TortoiseGit\\ShowAllEntry"));\r
 908         reg = m_btnShow.GetCurrentEntry();\r
 909         SaveSplitterPos();\r
 910         __super::OnCancel();\r
 911 }\r
 912 \r
 913 CString CLogDlg::MakeShortMessage(const CString& message)\r
 914 {\r
 915         bool bFoundShort = true;\r
 916         CString sShortMessage = m_ProjectProperties.GetLogSummary(message);\r
 917         if (sShortMessage.IsEmpty())\r
 918         {\r
 919                 bFoundShort = false;\r
 920                 sShortMessage = message;\r
 921         }\r
 922         // Remove newlines and tabs 'cause those are not shown nicely in the list control\r
 923         sShortMessage.Replace(_T("\r"), _T(""));\r
 924         sShortMessage.Replace(_T("\t"), _T(" "));\r
 925         \r
 926         // Suppose the first empty line separates 'summary' from the rest of the message.\r
 927         int found = sShortMessage.Find(_T("\n\n"));\r
 928         // To avoid too short 'short' messages \r
 929         // (e.g. if the message looks something like "Bugfix:\n\n*done this\n*done that")\r
 930         // only use the empty newline as a separator if it comes after at least 15 chars.\r
 931         if ((!bFoundShort)&&(found >= 15))\r
 932         {\r
 933                 sShortMessage = sShortMessage.Left(found);\r
 934         }\r
 935         sShortMessage.Replace('\n', ' ');\r
 936         return sShortMessage;\r
 937 }\r
 938 \r
 939 BOOL CLogDlg::Log(git_revnum_t rev, const CString& author, const CString& date, const CString& message, LogChangedPathArray * cpaths,  int filechanges, BOOL copies, DWORD actions, BOOL haschildren)\r
 940 {\r
 941 #if 0\r
 942         if (rev == SVN_INVALID_REVNUM)\r
 943         {\r
 944                 m_childCounter--;\r
 945                 return TRUE;\r
 946         }\r
 947 \r
 948         // this is the callback function which receives the data for every revision we ask the log for\r
 949         // we store this information here one by one.\r
 950         m_logcounter += 1;\r
 951         if (m_startrev == -1)\r
 952                 m_startrev = rev;\r
 953         if (m_limit != 0)\r
 954         {\r
 955                 m_limitcounter--;\r
 956                 m_LogProgress.SetPos(m_limit - m_limitcounter);\r
 957         }\r
 958         else if (m_startrev.IsNumber() && m_startrev.IsNumber())\r
 959                 m_LogProgress.SetPos((git_revnum_t)m_startrev-rev+(git_revnum_t)m_endrev);\r
 960         __time64_t ttime = time/1000000L;\r
 961         if (m_tTo < (DWORD)ttime)\r
 962                 m_tTo = (DWORD)ttime;\r
 963         if (m_tFrom > (DWORD)ttime)\r
 964                 m_tFrom = (DWORD)ttime;\r
 965         if ((m_lowestRev > rev)||(m_lowestRev < 0))\r
 966                 m_lowestRev = rev;\r
 967         // Add as many characters from the log message to the list control\r
 968         PLOGENTRYDATA pLogItem = new LOGENTRYDATA;\r
 969         pLogItem->bCopies = !!copies;\r
 970         \r
 971         // find out if this item was copied in the revision\r
 972         BOOL copiedself = FALSE;\r
 973         if (copies)\r
 974         {\r
 975                 for (INT_PTR cpPathIndex = 0; cpPathIndex < cpaths->GetCount(); ++cpPathIndex)\r
 976                 {\r
 977                         LogChangedPath * cpath = cpaths->GetAt(cpPathIndex);\r
 978                         if (!cpath->sCopyFromPath.IsEmpty() && (cpath->sPath.Compare(m_sSelfRelativeURL) == 0))\r
 979                         {\r
 980                                 // note: this only works if the log is fetched top-to-bottom\r
 981                                 // but since we do that, it shouldn't be a problem\r
 982                                 m_sSelfRelativeURL = cpath->sCopyFromPath;\r
 983                                 copiedself = TRUE;\r
 984                                 break;\r
 985                         }\r
 986                 }\r
 987         }\r
 988         pLogItem->bCopiedSelf = copiedself;\r
 989         pLogItem->tmDate = ttime;\r
 990         pLogItem->sAuthor = author;\r
 991         pLogItem->sDate = date;\r
 992         pLogItem->sShortMessage = MakeShortMessage(message);\r
 993         pLogItem->dwFileChanges = filechanges;\r
 994         pLogItem->actions = actions;\r
 995         pLogItem->haschildren = haschildren;\r
 996         pLogItem->childStackDepth = m_childCounter;\r
 997         m_maxChild = max(m_childCounter, m_maxChild);\r
 998         if (haschildren)\r
 999                 m_childCounter++;\r
1000         pLogItem->sBugIDs = m_ProjectProperties.FindBugID(message).Trim();\r
1001         \r
1002         // split multi line log entries and concatenate them\r
1003         // again but this time with \r\n as line separators\r
1004         // so that the edit control recognizes them\r
1005         try\r
1006         {\r
1007                 if (message.GetLength()>0)\r
1008                 {\r
1009                         m_sMessageBuf = message;\r
1010                         m_sMessageBuf.Replace(_T("\n\r"), _T("\n"));\r
1011                         m_sMessageBuf.Replace(_T("\r\n"), _T("\n"));\r
1012                         if (m_sMessageBuf.Right(1).Compare(_T("\n"))==0)\r
1013                                 m_sMessageBuf = m_sMessageBuf.Left(m_sMessageBuf.GetLength()-1);\r
1014                 }\r
1015                 else\r
1016                         m_sMessageBuf.Empty();\r
1017         pLogItem->sMessage = m_sMessageBuf;\r
1018         pLogItem->Rev = rev;\r
1019 \r
1020         // move-construct path array\r
1021 \r
1022         pLogItem->pArChangedPaths = new LogChangedPathArray (*cpaths);\r
1023         cpaths->RemoveAll();\r
1024         }\r
1025         catch (CException * e)\r
1026         {\r
1027                 ::MessageBox(NULL, _T("not enough memory!"), _T("TortoiseGit"), MB_ICONERROR);\r
1028                 e->Delete();\r
1029                 m_bCancelled = TRUE;\r
1030         }\r
1031         m_logEntries.push_back(pLogItem);\r
1032         m_arShownList.Add(pLogItem);\r
1033 #endif\r
1034         return TRUE;\r
1035 }\r
1036 \r
1037 //this is the thread function which calls the subversion function\r
1038 UINT CLogDlg::LogThreadEntry(LPVOID pVoid)\r
1039 {\r
1040         return ((CLogDlg*)pVoid)->LogThread();\r
1041 }\r
1042 \r
1043 GitRev g_rev;\r
1044 //this is the thread function which calls the subversion function\r
1045 UINT CLogDlg::LogThread()\r
1046 {\r
1047 \r
1048         InterlockedExchange(&m_bThreadRunning, TRUE);\r
1049 \r
1050     //does the user force the cache to refresh (shift or control key down)?\r
1051     bool refresh =    (GetKeyState (VK_CONTROL) < 0) \r
1052                    || (GetKeyState (VK_SHIFT) < 0);\r
1053 \r
1054         //disable the "Get All" button while we're receiving\r
1055         //log messages.\r
1056         DialogEnableWindow(IDC_GETALL, FALSE);\r
1057         DialogEnableWindow(IDC_NEXTHUNDRED, FALSE);\r
1058         DialogEnableWindow(IDC_CHECK_STOPONCOPY, FALSE);\r
1059         DialogEnableWindow(IDC_INCLUDEMERGE, FALSE);\r
1060         DialogEnableWindow(IDC_STATBUTTON, FALSE);\r
1061         DialogEnableWindow(IDC_REFRESH, FALSE);\r
1062         \r
1063         CString temp;\r
1064         temp.LoadString(IDS_PROGRESSWAIT);\r
1065         m_LogList.ShowText(temp, true);\r
1066         // change the text of the close button to "Cancel" since now the thread\r
1067         // is running, and simply closing the dialog doesn't work.\r
1068         if (!GetDlgItem(IDOK)->IsWindowVisible())\r
1069         {\r
1070                 temp.LoadString(IDS_MSGBOX_CANCEL);\r
1071                 SetDlgItemText(IDCANCEL, temp);\r
1072         }\r
1073         // We use a progress bar while getting the logs\r
1074         m_LogProgress.SetRange32(0, 100);\r
1075         m_LogProgress.SetPos(0);\r
1076         GetDlgItem(IDC_PROGRESS)->ShowWindow(TRUE);\r
1077 //      git_revnum_t r = -1;\r
1078         \r
1079         // get the repository root url, because the changed-files-list has the\r
1080         // paths shown there relative to the repository root.\r
1081 //      CTGitPath rootpath;\r
1082 //  BOOL succeeded = GetRootAndHead(m_path, rootpath, r);\r
1083 \r
1084 //    m_sRepositoryRoot = rootpath.GetGitPathString();\r
1085 //    m_sURL = m_path.GetGitPathString();\r
1086 \r
1087     // we need the UUID to unambigously identify the log cache\r
1088 //    if (logCachePool.IsEnabled())\r
1089 //        m_sUUID = logCachePool.GetRepositoryInfo().GetRepositoryUUID (rootpath);\r
1090 \r
1091     // if the log dialog is started from a working copy, we need to turn that\r
1092     // local path into an url here\r
1093 //    if (succeeded)\r
1094 //    {\r
1095 //        if (!m_path.IsUrl())\r
1096 //        {\r
1097 //              m_sURL = GetURLFromPath(m_path);\r
1098 \r
1099                 // The URL is escaped because Git::logReceiver\r
1100                 // returns the path in a native format\r
1101 //              m_sURL = CPathUtils::PathUnescape(m_sURL);\r
1102   //      }\r
1103 //        m_sRelativeRoot = m_sURL.Mid(CPathUtils::PathUnescape(m_sRepositoryRoot).GetLength());\r
1104 //              m_sSelfRelativeURL = m_sRelativeRoot;\r
1105   //  }\r
1106 #if 0\r
1107     if (succeeded && !m_mergePath.IsEmpty() && m_mergedRevs.empty())\r
1108     {\r
1109             // in case we got a merge path set, retrieve the merge info\r
1110             // of that path and check whether one of the merge URLs\r
1111             // match the URL we show the log for.\r
1112             GitPool localpool(pool);\r
1113             git_error_clear(Err);\r
1114             apr_hash_t * mergeinfo = NULL;\r
1115             if (git_client_mergeinfo_get_merged (&mergeinfo, m_mergePath.GetGitApiPath(localpool), GitRev(GitRev::REV_WC), m_pctx, localpool) == NULL)\r
1116             {\r
1117                     // now check the relative paths\r
1118                     apr_hash_index_t *hi;\r
1119                     const void *key;\r
1120                     void *val;\r
1121 \r
1122                     if (mergeinfo)\r
1123                     {\r
1124                             for (hi = apr_hash_first(localpool, mergeinfo); hi; hi = apr_hash_next(hi))\r
1125                             {\r
1126                                     apr_hash_this(hi, &key, NULL, &val);\r
1127                                     if (m_sURL.Compare(CUnicodeUtils::GetUnicode((char*)key)) == 0)\r
1128                                     {\r
1129                                             apr_array_header_t * arr = (apr_array_header_t*)val;\r
1130                                             if (val)\r
1131                                             {\r
1132                                                     for (long i=0; i<arr->nelts; ++i)\r
1133                                                     {\r
1134                                                             git_merge_range_t * pRange = APR_ARRAY_IDX(arr, i, git_merge_range_t*);\r
1135                                                             if (pRange)\r
1136                                                             {\r
1137                                                                     for (git_revnum_t r=pRange->start+1; r<=pRange->end; ++r)\r
1138                                                                     {\r
1139                                                                             m_mergedRevs.insert(r);\r
1140                                                                     }\r
1141                                                             }\r
1142                                                     }\r
1143                                             }\r
1144                                             break;\r
1145                                     }\r
1146                             }\r
1147                     }\r
1148             }\r
1149     }\r
1150 \r
1151     m_LogProgress.SetPos(1);\r
1152     if (m_startrev == GitRev::REV_HEAD)\r
1153     {\r
1154             m_startrev = r;\r
1155     }\r
1156     if (m_endrev == GitRev::REV_HEAD)\r
1157     {\r
1158             m_endrev = r;\r
1159     }\r
1160 \r
1161     if (m_limit != 0)\r
1162     {\r
1163             m_limitcounter = m_limit;\r
1164             m_LogProgress.SetRange32(0, m_limit);\r
1165     }\r
1166     else\r
1167             m_LogProgress.SetRange32(m_endrev, m_startrev);\r
1168         \r
1169     if (!m_pegrev.IsValid())\r
1170             m_pegrev = m_startrev;\r
1171     size_t startcount = m_logEntries.size();\r
1172     m_lowestRev = -1;\r
1173     m_bStrictStopped = false;\r
1174 \r
1175     if (succeeded)\r
1176     {\r
1177         succeeded = ReceiveLog (CTGitPathList(m_path), m_pegrev, m_startrev, m_endrev, m_limit, m_bStrict, m_bIncludeMerges, refresh);\r
1178         if ((!succeeded)&&(!m_path.IsUrl()))\r
1179         {\r
1180                 // try again with REV_WC as the start revision, just in case the path doesn't\r
1181                 // exist anymore in HEAD\r
1182                 succeeded = ReceiveLog(CTGitPathList(m_path), GitRev(), GitRev::REV_WC, m_endrev, m_limit, m_bStrict, m_bIncludeMerges, refresh);\r
1183         }\r
1184     }\r
1185         m_LogList.ClearText();\r
1186     if (!succeeded)\r
1187         {\r
1188                 m_LogList.ShowText(GetLastErrorMessage(), true);\r
1189         }\r
1190         else\r
1191         {\r
1192                 if (!m_wcRev.IsValid())\r
1193                 {\r
1194                         // fetch the revision the wc path is on so we can mark it\r
1195                         CTGitPath revWCPath = m_ProjectProperties.GetPropsPath();\r
1196                         if (!m_path.IsUrl())\r
1197                                 revWCPath = m_path;\r
1198                         if (DWORD(CRegDWORD(_T("Software\\TortoiseGit\\RecursiveLogRev"), FALSE)))\r
1199                         {\r
1200                                 git_revnum_t minrev, maxrev;\r
1201                                 bool switched, modified, sparse;\r
1202                                 GetWCRevisionStatus(revWCPath, true, minrev, maxrev, switched, modified, sparse);\r
1203                                 if (maxrev)\r
1204                                         m_wcRev = maxrev;\r
1205                         }\r
1206                         else\r
1207                         {\r
1208                                 CTGitPath dummypath;\r
1209                                 GitStatus status;\r
1210                                 git_wc_status2_t * stat = status.GetFirstFileStatus(revWCPath, dummypath, false, git_depth_empty);\r
1211                                 if (stat && stat->entry && stat->entry->cmt_rev)\r
1212                                         m_wcRev = stat->entry->cmt_rev;\r
1213                                 if (stat && stat->entry && (stat->entry->kind == git_node_dir))\r
1214                                         m_wcRev = stat->entry->revision;\r
1215                         }\r
1216                 }\r
1217         }\r
1218     if (m_bStrict && (m_lowestRev>1) && ((m_limit>0) ? ((startcount + m_limit)>m_logEntries.size()) : (m_endrev<m_lowestRev)))\r
1219                 m_bStrictStopped = true;\r
1220         m_LogList.SetItemCountEx(ShownCountWithStopped());\r
1221 \r
1222         m_timFrom = (__time64_t(m_tFrom));\r
1223         m_timTo = (__time64_t(m_tTo));\r
1224         m_DateFrom.SetRange(&m_timFrom, &m_timTo);\r
1225         m_DateTo.SetRange(&m_timFrom, &m_timTo);\r
1226         m_DateFrom.SetTime(&m_timFrom);\r
1227         m_DateTo.SetTime(&m_timTo);\r
1228 #endif\r
1229         DialogEnableWindow(IDC_GETALL, TRUE);\r
1230         m_LogList.ClearText();\r
1231 \r
1232         this->m_logEntries.ClearAll();\r
1233         this->m_logEntries.ParserFromLog();\r
1234         m_LogList.SetItemCountEx(this->m_logEntries.size());\r
1235         \r
1236         this->m_arShownList.Add(&g_rev);\r
1237         g_rev.m_AuthorName.Append(_T("Frank Li"));\r
1238         \r
1239 #if 0   \r
1240         if (!m_bShowedAll)\r
1241                 DialogEnableWindow(IDC_NEXTHUNDRED, TRUE);\r
1242 #endif\r
1243         DialogEnableWindow(IDC_CHECK_STOPONCOPY, TRUE);\r
1244         DialogEnableWindow(IDC_INCLUDEMERGE, TRUE);\r
1245         DialogEnableWindow(IDC_STATBUTTON, TRUE);\r
1246         DialogEnableWindow(IDC_REFRESH, TRUE);\r
1247 \r
1248 #if 0\r
1249         LogCache::CRepositoryInfo& cachedProperties = logCachePool.GetRepositoryInfo();\r
1250         SetDlgTitle(cachedProperties.IsOffline (m_sUUID, m_sRepositoryRoot, false));\r
1251 \r
1252         GetDlgItem(IDC_PROGRESS)->ShowWindow(FALSE);\r
1253         m_bCancelled = true;\r
1254 #endif\r
1255         InterlockedExchange(&m_bThreadRunning, FALSE);\r
1256         m_LogList.RedrawItems(0, m_arShownList.GetCount());\r
1257         m_LogList.SetRedraw(false);\r
1258         ResizeAllListCtrlCols();\r
1259         m_LogList.SetRedraw(true);\r
1260         if ( m_pStoreSelection )\r
1261         {\r
1262                 // Deleting the instance will restore the\r
1263                 // selection of the CLogDlg.\r
1264                 delete m_pStoreSelection;\r
1265                 m_pStoreSelection = NULL;\r
1266         }\r
1267         else\r
1268         {\r
1269                 // If no selection has been set then this must be the first time\r
1270                 // the revisions are shown. Let's preselect the topmost revision.\r
1271                 if ( m_LogList.GetItemCount()>0 )\r
1272                 {\r
1273                         m_LogList.SetSelectionMark(0);\r
1274                         m_LogList.SetItemState(0, LVIS_SELECTED, LVIS_SELECTED);\r
1275                 }\r
1276         }\r
1277 \r
1278         if (!GetDlgItem(IDOK)->IsWindowVisible())\r
1279         {\r
1280                 temp.LoadString(IDS_MSGBOX_OK);\r
1281                 SetDlgItemText(IDCANCEL, temp);\r
1282         }\r
1283 \r
1284         RefreshCursor();\r
1285         // make sure the filter is applied (if any) now, after we refreshed/fetched\r
1286         // the log messages\r
1287         PostMessage(WM_TIMER, LOGFILTER_TIMER);\r
1288 \r
1289         return 0;\r
1290 }\r
1291 \r
1292 void CLogDlg::CopySelectionToClipBoard()\r
1293 {\r
1294 #if 0\r
1295         CString sClipdata;\r
1296         POSITION pos = m_LogList.GetFirstSelectedItemPosition();\r
1297         if (pos != NULL)\r
1298         {\r
1299                 CString sRev;\r
1300                 sRev.LoadString(IDS_LOG_REVISION);\r
1301                 CString sAuthor;\r
1302                 sAuthor.LoadString(IDS_LOG_AUTHOR);\r
1303                 CString sDate;\r
1304                 sDate.LoadString(IDS_LOG_DATE);\r
1305                 CString sMessage;\r
1306                 sMessage.LoadString(IDS_LOG_MESSAGE);\r
1307                 while (pos)\r
1308                 {\r
1309                         CString sLogCopyText;\r
1310                         CString sPaths;\r
1311                         PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(m_LogList.GetNextSelectedItem(pos)));\r
1312                         LogChangedPathArray * cpatharray = pLogEntry->pArChangedPaths;\r
1313                         for (INT_PTR cpPathIndex = 0; cpPathIndex<cpatharray->GetCount(); ++cpPathIndex)\r
1314                         {\r
1315                                 LogChangedPath * cpath = cpatharray->GetAt(cpPathIndex);\r
1316                                 sPaths += cpath->GetAction() + _T(" : ") + cpath->sPath;\r
1317                                 if (cpath->sCopyFromPath.IsEmpty())\r
1318                                         sPaths += _T("\r\n");\r
1319                                 else\r
1320                                 {\r
1321                                         CString sCopyFrom;\r
1322                                         sCopyFrom.Format(_T(" (%s: %s, %s, %ld)\r\n"), CString(MAKEINTRESOURCE(IDS_LOG_COPYFROM)), \r
1323                                                 (LPCTSTR)cpath->sCopyFromPath, \r
1324                                                 (LPCTSTR)CString(MAKEINTRESOURCE(IDS_LOG_REVISION)), \r
1325                                                 (LPCTSTR)cpath->lCopyFromRev);\r
1326                                         sPaths += sCopyFrom;\r
1327                                 }\r
1328                         }\r
1329                         sPaths.Trim();\r
1330                         sLogCopyText.Format(_T("%s: %d\r\n%s: %s\r\n%s: %s\r\n%s:\r\n%s\r\n----\r\n%s\r\n\r\n"),\r
1331                                 (LPCTSTR)sRev, pLogEntry->Rev,\r
1332                                 (LPCTSTR)sAuthor, (LPCTSTR)pLogEntry->sAuthor,\r
1333                                 (LPCTSTR)sDate, (LPCTSTR)pLogEntry->sDate,\r
1334                                 (LPCTSTR)sMessage, (LPCTSTR)pLogEntry->sMessage,\r
1335                                 (LPCTSTR)sPaths);\r
1336                         sClipdata +=  sLogCopyText;\r
1337                 }\r
1338                 CStringUtils::WriteAsciiStringToClipboard(sClipdata, GetSafeHwnd());\r
1339         }\r
1340 #endif\r
1341 }\r
1342 \r
1343 void CLogDlg::CopyChangedSelectionToClipBoard()\r
1344 {\r
1345 #if 0\r
1346         POSITION pos = m_LogList.GetFirstSelectedItemPosition();\r
1347         if (pos == NULL)\r
1348                 return; // nothing is selected, get out of here\r
1349 \r
1350         CString sPaths;\r
1351 \r
1352         PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(m_LogList.GetNextSelectedItem(pos)));\r
1353         if (pos)\r
1354         {\r
1355                 POSITION pos = m_ChangedFileListCtrl.GetFirstSelectedItemPosition();\r
1356                 while (pos)\r
1357                 {\r
1358                         int nItem = m_ChangedFileListCtrl.GetNextSelectedItem(pos);\r
1359                         sPaths += m_currentChangedPathList[nItem].GetGitPathString();\r
1360                         sPaths += _T("\r\n");\r
1361                 }\r
1362         }\r
1363         else\r
1364         {\r
1365                 // only one revision is selected in the log dialog top pane\r
1366                 // but multiple items could be selected  in the changed items list\r
1367                 POSITION pos = m_ChangedFileListCtrl.GetFirstSelectedItemPosition();\r
1368                 while (pos)\r
1369                 {\r
1370                         int nItem = m_ChangedFileListCtrl.GetNextSelectedItem(pos);\r
1371                         LogChangedPath * changedlogpath = pLogEntry->pArChangedPaths->GetAt(nItem);\r
1372 \r
1373                         if ((m_cHidePaths.GetState() & 0x0003)==BST_CHECKED)\r
1374                         {\r
1375                                 // some items are hidden! So find out which item the user really selected\r
1376                                 INT_PTR selRealIndex = -1;\r
1377                                 for (INT_PTR hiddenindex=0; hiddenindex<pLogEntry->pArChangedPaths->GetCount(); ++hiddenindex)\r
1378                                 {\r
1379                                         if (pLogEntry->pArChangedPaths->GetAt(hiddenindex)->sPath.Left(m_sRelativeRoot.GetLength()).Compare(m_sRelativeRoot)==0)\r
1380                                                 selRealIndex++;\r
1381                                         if (selRealIndex == nItem)\r
1382                                         {\r
1383                                                 changedlogpath = pLogEntry->pArChangedPaths->GetAt(hiddenindex);\r
1384                                                 break;\r
1385                                         }\r
1386                                 }\r
1387                         }\r
1388                         if (changedlogpath)\r
1389                         {\r
1390                                 sPaths += changedlogpath->sPath;\r
1391                                 sPaths += _T("\r\n");\r
1392                         }\r
1393                 }\r
1394         }\r
1395         sPaths.Trim();\r
1396         CStringUtils::WriteAsciiStringToClipboard(sPaths, GetSafeHwnd());\r
1397 #endif\r
1398 }\r
1399 \r
1400 BOOL CLogDlg::IsDiffPossible(LogChangedPath * changedpath, git_revnum_t rev)\r
1401 {\r
1402 #if 0\r
1403         CString added, deleted;\r
1404         if (changedpath == NULL)\r
1405                 return false;\r
1406 \r
1407         if ((rev > 1)&&(changedpath->action != LOGACTIONS_DELETED))\r
1408         {\r
1409                 if (changedpath->action == LOGACTIONS_ADDED) // file is added\r
1410                 {\r
1411                         if (changedpath->lCopyFromRev == 0)\r
1412                                 return FALSE; // but file was not added with history\r
1413                 }\r
1414                 return TRUE;\r
1415         }\r
1416 #endif\r
1417         return FALSE;\r
1418 }\r
1419 \r
1420 void CLogDlg::OnContextMenu(CWnd* pWnd, CPoint point)\r
1421 {\r
1422         // we have two separate context menus:\r
1423         // one shown on the log message list control,\r
1424         // the other shown in the changed-files list control\r
1425         int selCount = m_LogList.GetSelectedCount();\r
1426         if (pWnd == &m_LogList)\r
1427         {\r
1428                 ShowContextMenuForRevisions(pWnd, point);\r
1429         }\r
1430         else if (pWnd == &m_ChangedFileListCtrl)\r
1431         {\r
1432                 ShowContextMenuForChangedpaths(pWnd, point);\r
1433         }\r
1434         else if ((selCount == 1)&&(pWnd == GetDlgItem(IDC_MSGVIEW)))\r
1435         {\r
1436                 POSITION pos = m_LogList.GetFirstSelectedItemPosition();\r
1437                 int selIndex = -1;\r
1438                 if (pos)\r
1439                         selIndex = m_LogList.GetNextSelectedItem(pos);\r
1440                 if ((point.x == -1) && (point.y == -1))\r
1441                 {\r
1442                         CRect rect;\r
1443                         GetDlgItem(IDC_MSGVIEW)->GetClientRect(&rect);\r
1444                         ClientToScreen(&rect);\r
1445                         point = rect.CenterPoint();\r
1446                 }\r
1447                 CString sMenuItemText;\r
1448                 CMenu popup;\r
1449                 if (popup.CreatePopupMenu())\r
1450                 {\r
1451                         // add the 'default' entries\r
1452                         sMenuItemText.LoadString(IDS_SCIEDIT_COPY);\r
1453                         popup.AppendMenu(MF_STRING | MF_ENABLED, WM_COPY, sMenuItemText);\r
1454                         sMenuItemText.LoadString(IDS_SCIEDIT_SELECTALL);\r
1455                         popup.AppendMenu(MF_STRING | MF_ENABLED, EM_SETSEL, sMenuItemText);\r
1456 \r
1457                         if (selIndex >= 0)\r
1458                         {\r
1459                                 popup.AppendMenu(MF_SEPARATOR);\r
1460                                 sMenuItemText.LoadString(IDS_LOG_POPUP_EDITLOG);\r
1461                                 popup.AppendMenu(MF_STRING | MF_ENABLED, ID_EDITAUTHOR, sMenuItemText);\r
1462                         }\r
1463 \r
1464                         int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this, 0);\r
1465                         switch (cmd)\r
1466                         {\r
1467                         case 0:\r
1468                                 break;  // no command selected\r
1469                         case EM_SETSEL:\r
1470                         case WM_COPY:\r
1471                                 ::SendMessage(GetDlgItem(IDC_MSGVIEW)->GetSafeHwnd(), cmd, 0, -1);\r
1472                                 break;\r
1473                         case ID_EDITAUTHOR:\r
1474                                 EditLogMessage(selIndex);\r
1475                                 break;\r
1476                         }\r
1477                 }\r
1478         }\r
1479 }\r
1480 \r
1481 bool CLogDlg::IsSelectionContinuous()\r
1482 {\r
1483         if ( m_LogList.GetSelectedCount()==1 )\r
1484         {\r
1485                 // if only one revision is selected, the selection is of course\r
1486                 // continuous\r
1487                 return true;\r
1488         }\r
1489 \r
1490         POSITION pos = m_LogList.GetFirstSelectedItemPosition();\r
1491         bool bContinuous = (m_arShownList.GetCount() == (INT_PTR)m_logEntries.size());\r
1492         if (bContinuous)\r
1493         {\r
1494                 int itemindex = m_LogList.GetNextSelectedItem(pos);\r
1495                 while (pos)\r
1496                 {\r
1497                         int nextindex = m_LogList.GetNextSelectedItem(pos);\r
1498                         if (nextindex - itemindex > 1)\r
1499                         {\r
1500                                 bContinuous = false;\r
1501                                 break;\r
1502                         }\r
1503                         itemindex = nextindex;\r
1504                 }\r
1505         }\r
1506         return bContinuous;\r
1507 }\r
1508 \r
1509 LRESULT CLogDlg::OnFindDialogMessage(WPARAM /*wParam*/, LPARAM /*lParam*/)\r
1510 {\r
1511 #if 0\r
1512     ASSERT(m_pFindDialog != NULL);\r
1513 \r
1514     if (m_pFindDialog->IsTerminating())\r
1515     {\r
1516             // invalidate the handle identifying the dialog box.\r
1517         m_pFindDialog = NULL;\r
1518         return 0;\r
1519     }\r
1520 \r
1521     if(m_pFindDialog->FindNext())\r
1522     {\r
1523         //read data from dialog\r
1524         CString FindText = m_pFindDialog->GetFindString();\r
1525         bool bMatchCase = (m_pFindDialog->MatchCase() == TRUE);\r
1526                 bool bFound = false;\r
1527                 tr1::wregex pat;\r
1528                 bool bRegex = ValidateRegexp(FindText, pat, bMatchCase);\r
1529 \r
1530                 tr1::regex_constants::match_flag_type flags = tr1::regex_constants::match_not_null;\r
1531 \r
1532                 int i;\r
1533                 for (i = this->m_nSearchIndex; i<m_arShownList.GetCount()&&!bFound; i++)\r
1534                 {\r
1535                         if (bRegex)\r
1536                         {\r
1537                                 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(i));\r
1538 \r
1539                                 if (regex_search(wstring((LPCTSTR)pLogEntry->sMessage), pat, flags))\r
1540                                 {\r
1541                                         bFound = true;\r
1542                                         break;\r
1543                                 }\r
1544                                 LogChangedPathArray * cpatharray = pLogEntry->pArChangedPaths;\r
1545                                 for (INT_PTR cpPathIndex = 0; cpPathIndex<cpatharray->GetCount(); ++cpPathIndex)\r
1546                                 {\r
1547                                         LogChangedPath * cpath = cpatharray->GetAt(cpPathIndex);\r
1548                                         if (regex_search(wstring((LPCTSTR)cpath->sCopyFromPath), pat, flags))\r
1549                                         {\r
1550                                                 bFound = true;\r
1551                                                 --i;\r
1552                                                 break;\r
1553                                         }\r
1554                                         if (regex_search(wstring((LPCTSTR)cpath->sPath), pat, flags))\r
1555                                         {\r
1556                                                 bFound = true;\r
1557                                                 --i;\r
1558                                                 break;\r
1559                                         }\r
1560                                 }\r
1561                         }\r
1562                         else\r
1563                         {\r
1564                                 if (bMatchCase)\r
1565                                 {\r
1566                                         if (m_logEntries[i]->sMessage.Find(FindText) >= 0)\r
1567                                         {\r
1568                                                 bFound = true;\r
1569                                                 break;\r
1570                                         }\r
1571                                         PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(i));\r
1572                                         LogChangedPathArray * cpatharray = pLogEntry->pArChangedPaths;\r
1573                                         for (INT_PTR cpPathIndex = 0; cpPathIndex<cpatharray->GetCount(); ++cpPathIndex)\r
1574                                         {\r
1575                                                 LogChangedPath * cpath = cpatharray->GetAt(cpPathIndex);\r
1576                                                 if (cpath->sCopyFromPath.Find(FindText)>=0)\r
1577                                                 {\r
1578                                                         bFound = true;\r
1579                                                         --i;\r
1580                                                         break;\r
1581                                                 }\r
1582                                                 if (cpath->sPath.Find(FindText)>=0)\r
1583                                                 {\r
1584                                                         bFound = true;\r
1585                                                         --i;\r
1586                                                         break;\r
1587                                                 }\r
1588                                         }\r
1589                                 }\r
1590                                 else\r
1591                                 {\r
1592                                     PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(i));\r
1593                                         CString msg = pLogEntry->sMessage;\r
1594                                         msg = msg.MakeLower();\r
1595                                         CString find = FindText.MakeLower();\r
1596                                         if (msg.Find(find) >= 0)\r
1597                                         {\r
1598                                                 bFound = TRUE;\r
1599                                                 break;\r
1600                                         }\r
1601                                         LogChangedPathArray * cpatharray = pLogEntry->pArChangedPaths;\r
1602                                         for (INT_PTR cpPathIndex = 0; cpPathIndex<cpatharray->GetCount(); ++cpPathIndex)\r
1603                                         {\r
1604                                                 LogChangedPath * cpath = cpatharray->GetAt(cpPathIndex);\r
1605                                                 CString lowerpath = cpath->sCopyFromPath;\r
1606                                                 lowerpath.MakeLower();\r
1607                                                 if (lowerpath.Find(find)>=0)\r
1608                                                 {\r
1609                                                         bFound = TRUE;\r
1610                                                         --i;\r
1611                                                         break;\r
1612                                                 }\r
1613                                                 lowerpath = cpath->sPath;\r
1614                                                 lowerpath.MakeLower();\r
1615                                                 if (lowerpath.Find(find)>=0)\r
1616                                                 {\r
1617                                                         bFound = TRUE;\r
1618                                                         --i;\r
1619                                                         break;\r
1620                                                 }\r
1621                                         }\r
1622                                 } \r
1623                         }\r
1624                 } // for (i = this->m_nSearchIndex; i<m_arShownList.GetItemCount()&&!bFound; i++)\r
1625                 if (bFound)\r
1626                 {\r
1627                         this->m_nSearchIndex = (i+1);\r
1628                         m_LogList.EnsureVisible(i, FALSE);\r
1629                         m_LogList.SetItemState(m_LogList.GetSelectionMark(), 0, LVIS_SELECTED);\r
1630                         m_LogList.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);\r
1631                         m_LogList.SetSelectionMark(i);\r
1632                         FillLogMessageCtrl();\r
1633                         UpdateData(FALSE);\r
1634                         m_nSearchIndex++;\r
1635                         if (m_nSearchIndex >= m_arShownList.GetCount())\r
1636                                 m_nSearchIndex = (int)m_arShownList.GetCount()-1;\r
1637                 }\r
1638     } // if(m_pFindDialog->FindNext()) \r
1639         UpdateLogInfoLabel();\r
1640 #endif\r
1641     return 0;\r
1642 }\r
1643 \r
1644 void CLogDlg::OnOK()\r
1645 {\r
1646 #if 0 \r
1647         // since the log dialog is also used to select revisions for other\r
1648         // dialogs, we have to do some work before closing this dialog\r
1649         if (GetFocus() != GetDlgItem(IDOK))\r
1650                 return; // if the "OK" button doesn't have the focus, do nothing: this prevents closing the dialog when pressing enter\r
1651         if (!GetDlgItem(IDOK)->IsWindowVisible() && GetFocus() != GetDlgItem(IDCANCEL))\r
1652                 return; // the Cancel button works as the OK button. But if the cancel button has not the focus, do nothing.\r
1653 \r
1654         CString temp;\r
1655         CString buttontext;\r
1656         GetDlgItemText(IDOK, buttontext);\r
1657         temp.LoadString(IDS_MSGBOX_CANCEL);\r
1658         if (temp.Compare(buttontext) != 0)\r
1659                 __super::OnOK();        // only exit if the button text matches, and that will match only if the thread isn't running anymore\r
1660         m_bCancelled = TRUE;\r
1661         m_selectedRevs.Clear();\r
1662         m_selectedRevsOneRange.Clear();\r
1663         if (m_pNotifyWindow)\r
1664         {\r
1665                 int selIndex = m_LogList.GetSelectionMark();\r
1666                 if (selIndex >= 0)\r
1667                 {       \r
1668                     PLOGENTRYDATA pLogEntry = NULL;\r
1669                         POSITION pos = m_LogList.GetFirstSelectedItemPosition();\r
1670                         pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(m_LogList.GetNextSelectedItem(pos)));\r
1671                         m_selectedRevs.AddRevision(pLogEntry->Rev);\r
1672                         git_revnum_t lowerRev = pLogEntry->Rev;\r
1673                         git_revnum_t higherRev = lowerRev;\r
1674                         while (pos)\r
1675                         {\r
1676                             pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(m_LogList.GetNextSelectedItem(pos)));\r
1677                                 git_revnum_t rev = pLogEntry->Rev;\r
1678                                 m_selectedRevs.AddRevision(pLogEntry->Rev);\r
1679                                 if (lowerRev > rev)\r
1680                                         lowerRev = rev;\r
1681                                 if (higherRev < rev)\r
1682                                         higherRev = rev;\r
1683                         }\r
1684                         if (m_sFilterText.IsEmpty() && m_nSortColumn == 0 && IsSelectionContinuous())\r
1685                         {\r
1686                                 m_selectedRevsOneRange.AddRevRange(lowerRev, higherRev);\r
1687                         }\r
1688                         BOOL bSentMessage = FALSE;\r
1689                         if (m_LogList.GetSelectedCount() == 1)\r
1690                         {\r
1691                                 // if only one revision is selected, check if the path/url with which the dialog was started\r
1692                                 // was directly affected in that revision. If it was, then check if our path was copied from somewhere.\r
1693                                 // if it was copied, use the copy from revision as lowerRev\r
1694                                 if ((pLogEntry)&&(pLogEntry->pArChangedPaths)&&(lowerRev == higherRev))\r
1695                                 {\r
1696                                         CString sUrl = m_path.GetGitPathString();\r
1697                                         if (!m_path.IsUrl())\r
1698                                         {\r
1699                                                 sUrl = GetURLFromPath(m_path);\r
1700                                         }\r
1701                                         sUrl = sUrl.Mid(m_sRepositoryRoot.GetLength());\r
1702                                         for (int cp = 0; cp < pLogEntry->pArChangedPaths->GetCount(); ++cp)\r
1703                                         {\r
1704                                                 LogChangedPath * pData = pLogEntry->pArChangedPaths->GetAt(cp);\r
1705                                                 if (pData)\r
1706                                                 {\r
1707                                                         if (sUrl.Compare(pData->sPath) == 0)\r
1708                                                         {\r
1709                                                                 if (!pData->sCopyFromPath.IsEmpty())\r
1710                                                                 {\r
1711                                                                         lowerRev = pData->lCopyFromRev;\r
1712                                                                         m_pNotifyWindow->SendMessage(WM_REVSELECTED, m_wParam & (MERGE_REVSELECTSTART), lowerRev);\r
1713                                                                         m_pNotifyWindow->SendMessage(WM_REVSELECTED, m_wParam & (MERGE_REVSELECTEND), higherRev);\r
1714                                                                         m_pNotifyWindow->SendMessage(WM_REVLIST, m_selectedRevs.GetCount(), (LPARAM)&m_selectedRevs);\r
1715                                                                         bSentMessage = TRUE;\r
1716                                                                 }\r
1717                                                         }\r
1718                                                 }\r
1719                                         }\r
1720                                 }\r
1721                         }\r
1722                         if ( !bSentMessage )\r
1723                         {\r
1724                                 m_pNotifyWindow->SendMessage(WM_REVSELECTED, m_wParam & (MERGE_REVSELECTSTART | MERGE_REVSELECTMINUSONE), lowerRev);\r
1725                                 m_pNotifyWindow->SendMessage(WM_REVSELECTED, m_wParam & (MERGE_REVSELECTEND | MERGE_REVSELECTMINUSONE), higherRev);\r
1726                                 m_pNotifyWindow->SendMessage(WM_REVLIST, m_selectedRevs.GetCount(), (LPARAM)&m_selectedRevs);\r
1727                                 if (m_selectedRevsOneRange.GetCount())\r
1728                                         m_pNotifyWindow->SendMessage(WM_REVLISTONERANGE, 0, (LPARAM)&m_selectedRevsOneRange);\r
1729                         }\r
1730                 }\r
1731         }\r
1732         UpdateData();\r
1733         if (m_bSaveStrict)\r
1734                 m_regLastStrict = m_bStrict;\r
1735         CRegDWORD reg = CRegDWORD(_T("Software\\TortoiseGit\\ShowAllEntry"));\r
1736         reg = m_btnShow.GetCurrentEntry();\r
1737         SaveSplitterPos();\r
1738 #endif \r
1739 }\r
1740 \r
1741 void CLogDlg::OnNMDblclkChangedFileList(NMHDR * /*pNMHDR*/, LRESULT *pResult)\r
1742 {\r
1743         // a double click on an entry in the changed-files list has happened\r
1744         *pResult = 0;\r
1745 \r
1746         DiffSelectedFile();\r
1747 }\r
1748 \r
1749 void CLogDlg::DiffSelectedFile()\r
1750 {\r
1751 #if 0\r
1752         if (m_bThreadRunning)\r
1753                 return;\r
1754         UpdateLogInfoLabel();\r
1755         INT_PTR selIndex = m_ChangedFileListCtrl.GetSelectionMark();\r
1756         if (selIndex < 0)\r
1757                 return;\r
1758         if (m_ChangedFileListCtrl.GetSelectedCount() == 0)\r
1759                 return;\r
1760         // find out if there's an entry selected in the log list\r
1761         POSITION pos = m_LogList.GetFirstSelectedItemPosition();\r
1762         PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(m_LogList.GetNextSelectedItem(pos)));\r
1763         git_revnum_t rev1 = pLogEntry->Rev;\r
1764         git_revnum_t rev2 = rev1;\r
1765         if (pos)\r
1766         {\r
1767                 while (pos)\r
1768                 {\r
1769                         // there's at least a second entry selected in the log list: several revisions selected!\r
1770                         pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(m_LogList.GetNextSelectedItem(pos)));\r
1771                         if (pLogEntry)\r
1772                         {\r
1773                                 rev1 = max(rev1,(long)pLogEntry->Rev);\r
1774                                 rev2 = min(rev2,(long)pLogEntry->Rev);\r
1775                         }\r
1776                 }\r
1777                 rev2--;\r
1778                 // now we have both revisions selected in the log list, so we can do a diff of the selected\r
1779                 // entry in the changed files list with these two revisions.\r
1780                 DoDiffFromLog(selIndex, rev1, rev2, false, false);\r
1781         }\r
1782         else\r
1783         {\r
1784                 rev2 = rev1-1;\r
1785                 // nothing or only one revision selected in the log list\r
1786                 LogChangedPath * changedpath = pLogEntry->pArChangedPaths->GetAt(selIndex);\r
1787 \r
1788                 if ((m_cHidePaths.GetState() & 0x0003)==BST_CHECKED)\r
1789                 {\r
1790                         // some items are hidden! So find out which item the user really clicked on\r
1791                         INT_PTR selRealIndex = -1;\r
1792                         for (INT_PTR hiddenindex=0; hiddenindex<pLogEntry->pArChangedPaths->GetCount(); ++hiddenindex)\r
1793                         {\r
1794                                 if (pLogEntry->pArChangedPaths->GetAt(hiddenindex)->sPath.Left(m_sRelativeRoot.GetLength()).Compare(m_sRelativeRoot)==0)\r
1795                                         selRealIndex++;\r
1796                                 if (selRealIndex == selIndex)\r
1797                                 {\r
1798                                         selIndex = hiddenindex;\r
1799                                         changedpath = pLogEntry->pArChangedPaths->GetAt(selIndex);\r
1800                                         break;\r
1801                                 }\r
1802                         }\r
1803                 }\r
1804 \r
1805                 if (IsDiffPossible(changedpath, rev1))\r
1806                 {\r
1807                         // diffs with renamed files are possible\r
1808                         if ((changedpath)&&(!changedpath->sCopyFromPath.IsEmpty()))\r
1809                                 rev2 = changedpath->lCopyFromRev;\r
1810                         else\r
1811                         {\r
1812                                 // if the path was modified but the parent path was 'added with history'\r
1813                                 // then we have to use the copy from revision of the parent path\r
1814                                 CTGitPath cpath = CTGitPath(changedpath->sPath);\r
1815                                 for (int flist = 0; flist < pLogEntry->pArChangedPaths->GetCount(); ++flist)\r
1816                                 {\r
1817                                         CTGitPath p = CTGitPath(pLogEntry->pArChangedPaths->GetAt(flist)->sPath);\r
1818                                         if (p.IsAncestorOf(cpath))\r
1819                                         {\r
1820                                                 if (!pLogEntry->pArChangedPaths->GetAt(flist)->sCopyFromPath.IsEmpty())\r
1821                                                         rev2 = pLogEntry->pArChangedPaths->GetAt(flist)->lCopyFromRev;\r
1822                                         }\r
1823                                 }\r
1824                         }\r
1825                         DoDiffFromLog(selIndex, rev1, rev2, false, false);\r
1826                 }\r
1827                 else \r
1828                 {\r
1829                         CTGitPath tempfile = CTempFiles::Instance().GetTempFilePath(false, CTGitPath(changedpath->sPath));\r
1830                         CTGitPath tempfile2 = CTempFiles::Instance().GetTempFilePath(false, CTGitPath(changedpath->sPath));\r
1831                         GitRev r = rev1;\r
1832                         // deleted files must be opened from the revision before the deletion\r
1833                         if (changedpath->action == LOGACTIONS_DELETED)\r
1834                                 r = rev1-1;\r
1835                         m_bCancelled = false;\r
1836 \r
1837                         CProgressDlg progDlg;\r
1838                         progDlg.SetTitle(IDS_APPNAME);\r
1839                         progDlg.SetAnimation(IDR_DOWNLOAD);\r
1840                         CString sInfoLine;\r
1841                         sInfoLine.Format(IDS_PROGRESSGETFILEREVISION, (LPCTSTR)(m_sRepositoryRoot + changedpath->sPath), (LPCTSTR)r.ToString());\r
1842                         progDlg.SetLine(1, sInfoLine, true);\r
1843                         SetAndClearProgressInfo(&progDlg);\r
1844                         progDlg.ShowModeless(m_hWnd);\r
1845 \r
1846                         if (!Cat(CTGitPath(m_sRepositoryRoot + changedpath->sPath), r, r, tempfile))\r
1847                         {\r
1848                                 m_bCancelled = false;\r
1849                                 if (!Cat(CTGitPath(m_sRepositoryRoot + changedpath->sPath), GitRev::REV_HEAD, r, tempfile))\r
1850                                 {\r
1851                                         progDlg.Stop();\r
1852                                         SetAndClearProgressInfo((HWND)NULL);\r
1853                                         CMessageBox::Show(m_hWnd, GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);\r
1854                                         return;\r
1855                                 }\r
1856                         }\r
1857                         progDlg.Stop();\r
1858                         SetAndClearProgressInfo((HWND)NULL);\r
1859 \r
1860                         CString sName1, sName2;\r
1861                         sName1.Format(_T("%s - Revision %ld"), (LPCTSTR)CPathUtils::GetFileNameFromPath(changedpath->sPath), (git_revnum_t)rev1);\r
1862                         sName2.Format(_T("%s - Revision %ld"), (LPCTSTR)CPathUtils::GetFileNameFromPath(changedpath->sPath), (git_revnum_t)rev1-1);\r
1863                         CAppUtils::DiffFlags flags;\r
1864                         flags.AlternativeTool(!!(GetAsyncKeyState(VK_SHIFT) & 0x8000));\r
1865                         if (changedpath->action == LOGACTIONS_DELETED)\r
1866                                 CAppUtils::StartExtDiff(tempfile, tempfile2, sName2, sName1, flags);\r
1867                         else\r
1868                                 CAppUtils::StartExtDiff(tempfile2, tempfile, sName2, sName1, flags);\r
1869                 }\r
1870         }\r
1871 #endif \r
1872 }\r
1873 \r
1874 \r
1875 void CLogDlg::OnNMDblclkLoglist(NMHDR * /*pNMHDR*/, LRESULT *pResult)\r
1876 {\r
1877         // a double click on an entry in the revision list has happened\r
1878         *pResult = 0;\r
1879 \r
1880   if (CRegDWORD(_T("Software\\TortoiseGit\\DiffByDoubleClickInLog"), FALSE))\r
1881           DiffSelectedRevWithPrevious();\r
1882 }\r
1883 \r
1884 void CLogDlg::DiffSelectedRevWithPrevious()\r
1885 {\r
1886 #if 0\r
1887         if (m_bThreadRunning)\r
1888                 return;\r
1889         UpdateLogInfoLabel();\r
1890         int selIndex = m_LogList.GetSelectionMark();\r
1891         if (selIndex < 0)\r
1892                 return;\r
1893         int selCount = m_LogList.GetSelectedCount();\r
1894         if (selCount != 1)\r
1895                 return;\r
1896 \r
1897         // Find selected entry in the log list\r
1898         POSITION pos = m_LogList.GetFirstSelectedItemPosition();\r
1899         PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(m_LogList.GetNextSelectedItem(pos)));\r
1900         long rev1 = pLogEntry->Rev;\r
1901         long rev2 = rev1-1;\r
1902         CTGitPath path = m_path;\r
1903 \r
1904         // See how many files under the relative root were changed in selected revision\r
1905         int nChanged = 0;\r
1906         LogChangedPath * changed = NULL;\r
1907         for (INT_PTR c = 0; c < pLogEntry->pArChangedPaths->GetCount(); ++c)\r
1908         {\r
1909                 LogChangedPath * cpath = pLogEntry->pArChangedPaths->GetAt(c);\r
1910                 if (cpath  &&  cpath -> sPath.Left(m_sRelativeRoot.GetLength()).Compare(m_sRelativeRoot)==0)\r
1911                 {\r
1912                         ++nChanged;\r
1913                         changed = cpath;\r
1914                 }\r
1915         }\r
1916 \r
1917         if (m_path.IsDirectory() && nChanged == 1) \r
1918         {\r
1919                 // We're looking at the log for a directory and only one file under dir was changed in the revision\r
1920                 // Do diff on that file instead of whole directory\r
1921                 path.AppendPathString(changed->sPath.Mid(m_sRelativeRoot.GetLength()));\r
1922         } \r
1923 \r
1924         m_bCancelled = FALSE;\r
1925         DialogEnableWindow(IDOK, FALSE);\r
1926         SetPromptApp(&theApp);\r
1927         theApp.DoWaitCursor(1);\r
1928 \r
1929         if (PromptShown())\r
1930         {\r
1931                 GitDiff diff(this, m_hWnd, true);\r
1932                 diff.SetAlternativeTool(!!(GetAsyncKeyState(VK_SHIFT) & 0x8000));\r
1933                 diff.SetHEADPeg(m_LogRevision);\r
1934                 diff.ShowCompare(path, rev2, path, rev1);\r
1935         }\r
1936         else\r
1937         {\r
1938                 CAppUtils::StartShowCompare(m_hWnd, path, rev2, path, rev1, GitRev(), m_LogRevision, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000));\r
1939         }\r
1940 \r
1941         theApp.DoWaitCursor(-1);\r
1942         EnableOKButton();\r
1943 #endif\r
1944 }\r
1945 \r
1946 void CLogDlg::DoDiffFromLog(INT_PTR selIndex, git_revnum_t rev1, git_revnum_t rev2, bool blame, bool unified)\r
1947 {\r
1948 #if 0\r
1949         DialogEnableWindow(IDOK, FALSE);\r
1950         SetPromptApp(&theApp);\r
1951         theApp.DoWaitCursor(1);\r
1952         //get the filename\r
1953         CString filepath;\r
1954         if (Git::PathIsURL(m_path))\r
1955         {\r
1956                 filepath = m_path.GetGitPathString();\r
1957         }\r
1958         else\r
1959         {\r
1960                 filepath = GetURLFromPath(m_path);\r
1961                 if (filepath.IsEmpty())\r
1962                 {\r
1963                         theApp.DoWaitCursor(-1);\r
1964                         CString temp;\r
1965                         temp.Format(IDS_ERR_NOURLOFFILE, (LPCTSTR)filepath);\r
1966                         CMessageBox::Show(this->m_hWnd, temp, _T("TortoiseGit"), MB_ICONERROR);\r
1967                         TRACE(_T("could not retrieve the URL of the file!\n"));\r
1968                         EnableOKButton();\r
1969                         theApp.DoWaitCursor(-11);\r
1970                         return;         //exit\r
1971                 }\r
1972         }\r
1973         m_bCancelled = FALSE;\r
1974         filepath = GetRepositoryRoot(CTGitPath(filepath));\r
1975 \r
1976         CString firstfile, secondfile;\r
1977         if (m_LogList.GetSelectedCount()==1)\r
1978         {\r
1979                 int s = m_LogList.GetSelectionMark();\r
1980                 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(s));\r
1981                 LogChangedPath * changedpath = pLogEntry->pArChangedPaths->GetAt(selIndex);\r
1982                 firstfile = changedpath->sPath;\r
1983                 secondfile = firstfile;\r
1984                 if ((rev2 == rev1-1)&&(changedpath->lCopyFromRev > 0)) // is it an added file with history?\r
1985                 {\r
1986                         secondfile = changedpath->sCopyFromPath;\r
1987                         rev2 = changedpath->lCopyFromRev;\r
1988                 }\r
1989         }\r
1990         else\r
1991         {\r
1992                 firstfile = m_currentChangedPathList[selIndex].GetGitPathString();\r
1993                 secondfile = firstfile;\r
1994         }\r
1995 \r
1996         firstfile = filepath + firstfile.Trim();\r
1997         secondfile = filepath + secondfile.Trim();\r
1998 \r
1999         GitDiff diff(this, this->m_hWnd, true);\r
2000         diff.SetAlternativeTool(!!(GetAsyncKeyState(VK_SHIFT) & 0x8000));\r
2001         diff.SetHEADPeg(m_LogRevision);\r
2002         if (unified)\r
2003         {\r
2004                 if (PromptShown())\r
2005                         diff.ShowUnifiedDiff(CTGitPath(secondfile), rev2, CTGitPath(firstfile), rev1);\r
2006                 else\r
2007                         CAppUtils::StartShowUnifiedDiff(m_hWnd, CTGitPath(secondfile), rev2, CTGitPath(firstfile), rev1, GitRev(), m_LogRevision);\r
2008         }\r
2009         else\r
2010         {\r
2011                 if (diff.ShowCompare(CTGitPath(secondfile), rev2, CTGitPath(firstfile), rev1, GitRev(), false, blame))\r
2012                 {\r
2013                         if (firstfile.Compare(secondfile)==0)\r
2014                         {\r
2015                                 git_revnum_t baseRev = 0;\r
2016                                 diff.DiffProps(CTGitPath(firstfile), rev2, rev1, baseRev);\r
2017                         }\r
2018                 }\r
2019         }\r
2020         theApp.DoWaitCursor(-1);\r
2021         EnableOKButton();\r
2022 #endif\r
2023 }\r
2024 \r
2025 BOOL CLogDlg::Open(bool bOpenWith,CString changedpath, git_revnum_t rev)\r
2026 {\r
2027 #if 0\r
2028         DialogEnableWindow(IDOK, FALSE);\r
2029         SetPromptApp(&theApp);\r
2030         theApp.DoWaitCursor(1);\r
2031         CString filepath;\r
2032         if (Git::PathIsURL(m_path))\r
2033         {\r
2034                 filepath = m_path.GetGitPathString();\r
2035         }\r
2036         else\r
2037         {\r
2038                 filepath = GetURLFromPath(m_path);\r
2039                 if (filepath.IsEmpty())\r
2040                 {\r
2041                         theApp.DoWaitCursor(-1);\r
2042                         CString temp;\r
2043                         temp.Format(IDS_ERR_NOURLOFFILE, (LPCTSTR)filepath);\r
2044                         CMessageBox::Show(this->m_hWnd, temp, _T("TortoiseGit"), MB_ICONERROR);\r
2045                         TRACE(_T("could not retrieve the URL of the file!\n"));\r
2046                         EnableOKButton();\r
2047                         return FALSE;\r
2048                 }\r
2049         }\r
2050         m_bCancelled = false;\r
2051         filepath = GetRepositoryRoot(CTGitPath(filepath));\r
2052         filepath += changedpath;\r
2053 \r
2054         CProgressDlg progDlg;\r
2055         progDlg.SetTitle(IDS_APPNAME);\r
2056         progDlg.SetAnimation(IDR_DOWNLOAD);\r
2057         CString sInfoLine;\r
2058         sInfoLine.Format(IDS_PROGRESSGETFILEREVISION, (LPCTSTR)filepath, (LPCTSTR)GitRev(rev).ToString());\r
2059         progDlg.SetLine(1, sInfoLine, true);\r
2060         SetAndClearProgressInfo(&progDlg);\r
2061         progDlg.ShowModeless(m_hWnd);\r
2062 \r
2063         CTGitPath tempfile = CTempFiles::Instance().GetTempFilePath(false, CTGitPath(filepath), rev);\r
2064         m_bCancelled = false;\r
2065         if (!Cat(CTGitPath(filepath), GitRev(rev), rev, tempfile))\r
2066         {\r
2067                 progDlg.Stop();\r
2068                 SetAndClearProgressInfo((HWND)NULL);\r
2069                 CMessageBox::Show(this->m_hWnd, GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);\r
2070                 EnableOKButton();\r
2071                 theApp.DoWaitCursor(-1);\r
2072                 return FALSE;\r
2073         }\r
2074         progDlg.Stop();\r
2075         SetAndClearProgressInfo((HWND)NULL);\r
2076         SetFileAttributes(tempfile.GetWinPath(), FILE_ATTRIBUTE_READONLY);\r
2077         if (!bOpenWith)\r
2078         {\r
2079                 int ret = (int)ShellExecute(this->m_hWnd, NULL, tempfile.GetWinPath(), NULL, NULL, SW_SHOWNORMAL);\r
2080                 if (ret <= HINSTANCE_ERROR)\r
2081                         bOpenWith = true;\r
2082         }\r
2083         if (bOpenWith)\r
2084         {\r
2085                 CString cmd = _T("RUNDLL32 Shell32,OpenAs_RunDLL ");\r
2086                 cmd += tempfile.GetWinPathString() + _T(" ");\r
2087                 CAppUtils::LaunchApplication(cmd, NULL, false);\r
2088         }\r
2089         EnableOKButton();\r
2090         theApp.DoWaitCursor(-1);\r
2091 #endif\r
2092         return TRUE;\r
2093 }\r
2094 \r
2095 void CLogDlg::EditAuthor(const CLogDataVector& logs)\r
2096 {\r
2097 #if 0\r
2098         CString url;\r
2099         CString name;\r
2100         if (logs.size() == 0)\r
2101                 return;\r
2102         DialogEnableWindow(IDOK, FALSE);\r
2103         SetPromptApp(&theApp);\r
2104         theApp.DoWaitCursor(1);\r
2105         if (Git::PathIsURL(m_path))\r
2106                 url = m_path.GetGitPathString();\r
2107         else\r
2108         {\r
2109                 url = GetURLFromPath(m_path);\r
2110         }\r
2111         name = Git_PROP_REVISION_AUTHOR;\r
2112 \r
2113         CString value = RevPropertyGet(name, CTGitPath(url), logs[0]->Rev);\r
2114         CString sOldValue = value;\r
2115         value.Replace(_T("\n"), _T("\r\n"));\r
2116         CInputDlg dlg(this);\r
2117         dlg.m_sHintText.LoadString(IDS_LOG_AUTHOR);\r
2118         dlg.m_sInputText = value;\r
2119         dlg.m_sTitle.LoadString(IDS_LOG_AUTHOREDITTITLE);\r
2120         dlg.m_pProjectProperties = &m_ProjectProperties;\r
2121         dlg.m_bUseLogWidth = false;\r
2122         if (dlg.DoModal() == IDOK)\r
2123         {\r
2124                 dlg.m_sInputText.Replace(_T("\r"), _T(""));\r
2125 \r
2126                 LogCache::CCachedLogInfo* toUpdate \r
2127                         = GetLogCache (CTGitPath (m_sRepositoryRoot));\r
2128 \r
2129                 CProgressDlg progDlg;\r
2130                 progDlg.SetTitle(IDS_APPNAME);\r
2131                 progDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_PROGRESSWAIT)));\r
2132                 progDlg.SetTime(true);\r
2133                 progDlg.SetShowProgressBar(true);\r
2134                 progDlg.ShowModeless(m_hWnd);\r
2135                 for (DWORD i=0; i<logs.size(); ++i)\r
2136                 {\r
2137                         if (!RevPropertySet(name, dlg.m_sInputText, sOldValue, CTGitPath(url), logs[i]->Rev))\r
2138                         {\r
2139                                 progDlg.Stop();\r
2140                                 CMessageBox::Show(this->m_hWnd, GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);\r
2141                                 break;\r
2142                         }\r
2143                         else\r
2144                         {\r
2145 \r
2146                                 logs[i]->sAuthor = dlg.m_sInputText;\r
2147                                 m_LogList.Invalidate();\r
2148 \r
2149                                 // update the log cache \r
2150 \r
2151                                 if (toUpdate != NULL)\r
2152                                 {\r
2153                                         // log caching is active\r
2154 \r
2155                                         LogCache::CCachedLogInfo newInfo;\r
2156                                         newInfo.Insert ( logs[i]->Rev\r
2157                                                 , (const char*) CUnicodeUtils::GetUTF8 (logs[i]->sAuthor)\r
2158                                                 , ""\r
2159                                                 , 0\r
2160                                                 , LogCache::CRevisionInfoContainer::HAS_AUTHOR);\r
2161 \r
2162                                         toUpdate->Update (newInfo);\r
2163                                 }\r
2164                         }\r
2165                         progDlg.SetProgress64(i, logs.size());\r
2166                 }\r
2167                 progDlg.Stop();\r
2168         }\r
2169         theApp.DoWaitCursor(-1);\r
2170         EnableOKButton();\r
2171 #endif\r
2172 }\r
2173 \r
2174 void CLogDlg::EditLogMessage(int index)\r
2175 {\r
2176 #if 0\r
2177         CString url;\r
2178         CString name;\r
2179         DialogEnableWindow(IDOK, FALSE);\r
2180         SetPromptApp(&theApp);\r
2181         theApp.DoWaitCursor(1);\r
2182         if (Git::PathIsURL(m_path))\r
2183                 url = m_path.GetGitPathString();\r
2184         else\r
2185         {\r
2186                 url = GetURLFromPath(m_path);\r
2187         }\r
2188         name = Git_PROP_REVISION_LOG;\r
2189 \r
2190         PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(index));\r
2191         m_bCancelled = FALSE;\r
2192         CString value = RevPropertyGet(name, CTGitPath(url), pLogEntry->Rev);\r
2193         CString sOldValue = value;\r
2194         value.Replace(_T("\n"), _T("\r\n"));\r
2195         CInputDlg dlg(this);\r
2196         dlg.m_sHintText.LoadString(IDS_LOG_MESSAGE);\r
2197         dlg.m_sInputText = value;\r
2198         dlg.m_sTitle.LoadString(IDS_LOG_MESSAGEEDITTITLE);\r
2199         dlg.m_pProjectProperties = &m_ProjectProperties;\r
2200         dlg.m_bUseLogWidth = true;\r
2201         if (dlg.DoModal() == IDOK)\r
2202         {\r
2203                 dlg.m_sInputText.Replace(_T("\r"), _T(""));\r
2204                 if (!RevPropertySet(name, dlg.m_sInputText, sOldValue, CTGitPath(url), pLogEntry->Rev))\r
2205                 {\r
2206                         CMessageBox::Show(this->m_hWnd, GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);\r
2207                 }\r
2208                 else\r
2209                 {\r
2210                         pLogEntry->sShortMessage = MakeShortMessage(dlg.m_sInputText);\r
2211                         // split multi line log entries and concatenate them\r
2212                         // again but this time with \r\n as line separators\r
2213                         // so that the edit control recognizes them\r
2214                         if (dlg.m_sInputText.GetLength()>0)\r
2215                         {\r
2216                                 m_sMessageBuf = dlg.m_sInputText;\r
2217                                 dlg.m_sInputText.Replace(_T("\n\r"), _T("\n"));\r
2218                                 dlg.m_sInputText.Replace(_T("\r\n"), _T("\n"));\r
2219                                 if (dlg.m_sInputText.Right(1).Compare(_T("\n"))==0)\r
2220                                         dlg.m_sInputText = dlg.m_sInputText.Left(dlg.m_sInputText.GetLength()-1);\r
2221                         } \r
2222                         else\r
2223                                 dlg.m_sInputText.Empty();\r
2224                         pLogEntry->sMessage = dlg.m_sInputText;\r
2225                         pLogEntry->sBugIDs = m_ProjectProperties.FindBugID(dlg.m_sInputText);\r
2226                         CWnd * pMsgView = GetDlgItem(IDC_MSGVIEW);\r
2227                         pMsgView->SetWindowText(_T(" "));\r
2228                         pMsgView->SetWindowText(dlg.m_sInputText);\r
2229                         m_ProjectProperties.FindBugID(dlg.m_sInputText, pMsgView);\r
2230                         m_LogList.Invalidate();\r
2231         \r
2232             // update the log cache \r
2233 \r
2234             LogCache::CCachedLogInfo* toUpdate \r
2235                 = GetLogCache (CTGitPath (m_sRepositoryRoot));\r
2236             if (toUpdate != NULL)\r
2237             {\r
2238                 // log caching is active\r
2239 \r
2240                 LogCache::CCachedLogInfo newInfo;\r
2241                 newInfo.Insert ( pLogEntry->Rev\r
2242                                , ""\r
2243                                , (const char*) CUnicodeUtils::GetUTF8 (pLogEntry->sMessage)\r
2244                                , 0\r
2245                                , LogCache::CRevisionInfoContainer::HAS_COMMENT);\r
2246 \r
2247                 toUpdate->Update (newInfo);\r
2248             }\r
2249         }\r
2250         }\r
2251         theApp.DoWaitCursor(-1);\r
2252         EnableOKButton();\r
2253 #endif\r
2254 }\r
2255 \r
2256 BOOL CLogDlg::PreTranslateMessage(MSG* pMsg)\r
2257 {\r
2258         // Skip Ctrl-C when copying text out of the log message or search filter\r
2259         BOOL bSkipAccelerator = ( pMsg->message == WM_KEYDOWN && pMsg->wParam=='C' && (GetFocus()==GetDlgItem(IDC_MSGVIEW) || GetFocus()==GetDlgItem(IDC_SEARCHEDIT) ) && GetKeyState(VK_CONTROL)&0x8000 );\r
2260         if (pMsg->message == WM_KEYDOWN && pMsg->wParam=='\r')\r
2261         {\r
2262                 if (GetFocus()==GetDlgItem(IDC_LOGLIST))\r
2263                 {\r
2264                         if (CRegDWORD(_T("Software\\TortoiseGit\\DiffByDoubleClickInLog"), FALSE))\r
2265                         {\r
2266                                 DiffSelectedRevWithPrevious();\r
2267                                 return TRUE;\r
2268                         }\r
2269                 }\r
2270                 if (GetFocus()==GetDlgItem(IDC_LOGMSG))\r
2271                 {\r
2272                         DiffSelectedFile();\r
2273                         return TRUE;\r
2274                 }\r
2275         }\r
2276         if (m_hAccel && !bSkipAccelerator)\r
2277         {\r
2278                 int ret = TranslateAccelerator(m_hWnd, m_hAccel, pMsg);\r
2279                 if (ret)\r
2280                         return TRUE;\r
2281         }\r
2282         \r
2283         m_tooltips.RelayEvent(pMsg);\r
2284         return __super::PreTranslateMessage(pMsg);\r
2285 }\r
2286 \r
2287 BOOL CLogDlg::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)\r
2288 {\r
2289         if (m_bThreadRunning)\r
2290         {\r
2291                 // only show the wait cursor over the list control\r
2292                 if ((pWnd)&&\r
2293                         ((pWnd == GetDlgItem(IDC_LOGLIST))||\r
2294                         (pWnd == GetDlgItem(IDC_MSGVIEW))||\r
2295                         (pWnd == GetDlgItem(IDC_LOGMSG))))\r
2296                 {\r
2297                         HCURSOR hCur = LoadCursor(NULL, MAKEINTRESOURCE(IDC_WAIT));\r
2298                         SetCursor(hCur);\r
2299                         return TRUE;\r
2300                 }\r
2301         }\r
2302         if ((pWnd) && (pWnd == GetDlgItem(IDC_MSGVIEW)))\r
2303                 return CResizableStandAloneDialog::OnSetCursor(pWnd, nHitTest, message);\r
2304 \r
2305         HCURSOR hCur = LoadCursor(NULL, MAKEINTRESOURCE(IDC_ARROW));\r
2306         SetCursor(hCur);\r
2307         return CResizableStandAloneDialog::OnSetCursor(pWnd, nHitTest, message);\r
2308 }\r
2309 \r
2310 void CLogDlg::OnBnClickedHelp()\r
2311 {\r
2312         OnHelp();\r
2313 }\r
2314 \r
2315 void CLogDlg::OnLvnItemchangedLoglist(NMHDR *pNMHDR, LRESULT *pResult)\r
2316 {\r
2317         LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);\r
2318         *pResult = 0;\r
2319         if (m_bThreadRunning)\r
2320                 return;\r
2321         if (pNMLV->iItem >= 0)\r
2322         {\r
2323                 m_nSearchIndex = pNMLV->iItem;\r
2324                 if (pNMLV->iSubItem != 0)\r
2325                         return;\r
2326                 if ((pNMLV->iItem == m_arShownList.GetCount())&&(m_bStrict)&&(m_bStrictStopped))\r
2327                 {\r
2328                         // remove the selected state\r
2329                         if (pNMLV->uChanged & LVIF_STATE)\r
2330                         {\r
2331                                 m_LogList.SetItemState(pNMLV->iItem, 0, LVIS_SELECTED);\r
2332                                 FillLogMessageCtrl();\r
2333                                 UpdateData(FALSE);\r
2334                                 UpdateLogInfoLabel();\r
2335                         }\r
2336                         return;\r
2337                 }\r
2338                 if (pNMLV->uChanged & LVIF_STATE)\r
2339                 {\r
2340                         FillLogMessageCtrl();\r
2341                         UpdateData(FALSE);\r
2342                 }\r
2343         }\r
2344         else\r
2345         {\r
2346                 FillLogMessageCtrl();\r
2347                 UpdateData(FALSE);\r
2348         }\r
2349         EnableOKButton();\r
2350         UpdateLogInfoLabel();\r
2351 }\r
2352 \r
2353 void CLogDlg::OnEnLinkMsgview(NMHDR *pNMHDR, LRESULT *pResult)\r
2354 {\r
2355         ENLINK *pEnLink = reinterpret_cast<ENLINK *>(pNMHDR);\r
2356         if (pEnLink->msg == WM_LBUTTONUP)\r
2357         {\r
2358                 CString url, msg;\r
2359                 GetDlgItemText(IDC_MSGVIEW, msg);\r
2360                 msg.Replace(_T("\r\n"), _T("\n"));\r
2361                 url = msg.Mid(pEnLink->chrg.cpMin, pEnLink->chrg.cpMax-pEnLink->chrg.cpMin);\r
2362                 if (!::PathIsURL(url))\r
2363                 {\r
2364                         url = m_ProjectProperties.GetBugIDUrl(url);\r
2365                         url = GetAbsoluteUrlFromRelativeUrl(url);\r
2366                 }\r
2367                 if (!url.IsEmpty())\r
2368                         ShellExecute(this->m_hWnd, _T("open"), url, NULL, NULL, SW_SHOWDEFAULT);\r
2369         }\r
2370         *pResult = 0;\r
2371 }\r
2372 \r
2373 void CLogDlg::OnBnClickedStatbutton()\r
2374 {\r
2375 #if 0\r
2376         if (m_bThreadRunning)\r
2377                 return;\r
2378         if (m_arShownList.IsEmpty())\r
2379                 return;         // nothing is shown, so no statistics.\r
2380         // the statistics dialog expects the log entries to be sorted by date\r
2381         SortByColumn(3, false);\r
2382         CPtrArray shownlist;\r
2383         RecalculateShownList(&shownlist);\r
2384         // create arrays which are aware of the current filter\r
2385         CStringArray m_arAuthorsFiltered;\r
2386         CDWordArray m_arDatesFiltered;\r
2387         CDWordArray m_arFileChangesFiltered;\r
2388         for (INT_PTR i=0; i<shownlist.GetCount(); ++i)\r
2389         {\r
2390                 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(shownlist.GetAt(i));\r
2391                 CString strAuthor = pLogEntry->sAuthor;\r
2392                 if ( strAuthor.IsEmpty() )\r
2393                 {\r
2394                         strAuthor.LoadString(IDS_STATGRAPH_EMPTYAUTHOR);\r
2395                 }\r
2396                 m_arAuthorsFiltered.Add(strAuthor);\r
2397                 m_arDatesFiltered.Add(static_cast<DWORD>(pLogEntry->tmDate));\r
2398                 m_arFileChangesFiltered.Add(pLogEntry->dwFileChanges);\r
2399         }\r
2400         CStatGraphDlg dlg;\r
2401         dlg.m_parAuthors = &m_arAuthorsFiltered;\r
2402         dlg.m_parDates = &m_arDatesFiltered;\r
2403         dlg.m_parFileChanges = &m_arFileChangesFiltered;\r
2404         dlg.m_path = m_path;\r
2405         dlg.DoModal();\r
2406         // restore the previous sorting\r
2407         SortByColumn(m_nSortColumn, m_bAscending);\r
2408         OnTimer(LOGFILTER_TIMER);\r
2409 #endif\r
2410 }\r
2411 \r
2412 void CLogDlg::OnNMCustomdrawLoglist(NMHDR *pNMHDR, LRESULT *pResult)\r
2413 {\r
2414 \r
2415         NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>( pNMHDR );\r
2416         // Take the default processing unless we set this to something else below.\r
2417         *pResult = CDRF_DODEFAULT;\r
2418 \r
2419         if (m_bNoDispUpdates)\r
2420                 return;\r
2421 \r
2422         switch (pLVCD->nmcd.dwDrawStage)\r
2423         {\r
2424         case CDDS_PREPAINT:\r
2425                 {\r
2426                         *pResult = CDRF_NOTIFYITEMDRAW;\r
2427                         return;\r
2428                 }\r
2429                 break;\r
2430         case CDDS_ITEMPREPAINT:\r
2431                 {\r
2432                         // This is the prepaint stage for an item. Here's where we set the\r
2433                         // item's text color. \r
2434                         \r
2435                         // Tell Windows to send draw notifications for each subitem.\r
2436                         *pResult = CDRF_NOTIFYSUBITEMDRAW;\r
2437 \r
2438                         COLORREF crText = GetSysColor(COLOR_WINDOWTEXT);\r
2439 \r
2440                         if (m_arShownList.GetCount() > (INT_PTR)pLVCD->nmcd.dwItemSpec)\r
2441                         {\r
2442                                 GitRev* data = (GitRev*)m_arShownList.GetAt(pLVCD->nmcd.dwItemSpec);\r
2443                                 if (data)\r
2444                                 {\r
2445 #if 0\r
2446                                         if (data->bCopiedSelf)\r
2447                                         {\r
2448                                                 // only change the background color if the item is not 'hot' (on vista with themes enabled)\r
2449                                                 if (!theme.IsAppThemed() || !m_bVista || ((pLVCD->nmcd.uItemState & CDIS_HOT)==0))\r
2450                                                         pLVCD->clrTextBk = GetSysColor(COLOR_MENU);\r
2451                                         }\r
2452 \r
2453                                         if (data->bCopies)\r
2454                                                 crText = m_Colors.GetColor(CColors::Modified);\r
2455 #endif\r
2456 //                                      if ((data->childStackDepth)||(m_mergedRevs.find(data->Rev) != m_mergedRevs.end()))\r
2457 //                                              crText = GetSysColor(COLOR_GRAYTEXT);\r
2458 //                                      if (data->Rev == m_wcRev)\r
2459 //                                      {\r
2460 //                                              SelectObject(pLVCD->nmcd.hdc, m_boldFont);\r
2461                                                 // We changed the font, so we're returning CDRF_NEWFONT. This\r
2462                                                 // tells the control to recalculate the extent of the text.\r
2463 //                                              *pResult = CDRF_NOTIFYSUBITEMDRAW | CDRF_NEWFONT;\r
2464 //                                      }\r
2465                                 }\r
2466                         }\r
2467                         if (m_arShownList.GetCount() == (INT_PTR)pLVCD->nmcd.dwItemSpec)\r
2468                         {\r
2469                                 if (m_bStrictStopped)\r
2470                                         crText = GetSysColor(COLOR_GRAYTEXT);\r
2471                         }\r
2472                         // Store the color back in the NMLVCUSTOMDRAW struct.\r
2473                         pLVCD->clrText = crText;\r
2474                         return;\r
2475                 }\r
2476                 break;\r
2477         case CDDS_ITEMPREPAINT|CDDS_ITEM|CDDS_SUBITEM:\r
2478                 {\r
2479                         if ((m_bStrictStopped)&&(m_arShownList.GetCount() == (INT_PTR)pLVCD->nmcd.dwItemSpec))\r
2480                         {\r
2481                                 pLVCD->nmcd.uItemState &= ~(CDIS_SELECTED|CDIS_FOCUS);\r
2482                         }\r
2483                         if (pLVCD->iSubItem == 1)\r
2484                         {\r
2485                                 *pResult = CDRF_DODEFAULT;\r
2486 \r
2487                                 if (m_arShownList.GetCount() <= (INT_PTR)pLVCD->nmcd.dwItemSpec)\r
2488                                         return;\r
2489 \r
2490                                 int             nIcons = 0;\r
2491                                 int             iconwidth = ::GetSystemMetrics(SM_CXSMICON);\r
2492                                 int             iconheight = ::GetSystemMetrics(SM_CYSMICON);\r
2493 \r
2494                                 GitRev* pLogEntry = reinterpret_cast<GitRev *>(m_arShownList.GetAt(pLVCD->nmcd.dwItemSpec));\r
2495 \r
2496                                 // Get the selected state of the\r
2497                                 // item being drawn.\r
2498                                 LVITEM   rItem;\r
2499                                 SecureZeroMemory(&rItem, sizeof(LVITEM));\r
2500                                 rItem.mask  = LVIF_STATE;\r
2501                                 rItem.iItem = pLVCD->nmcd.dwItemSpec;\r
2502                                 rItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED;\r
2503                                 m_LogList.GetItem(&rItem);\r
2504 \r
2505                                 CRect rect;\r
2506                                 m_LogList.GetSubItemRect(pLVCD->nmcd.dwItemSpec, pLVCD->iSubItem, LVIR_BOUNDS, rect);\r
2507 \r
2508                                 // Fill the background\r
2509                                 if (theme.IsAppThemed() && m_bVista)\r
2510                                 {\r
2511                                         theme.Open(m_hWnd, L"Explorer");\r
2512                                         int state = LISS_NORMAL;\r
2513                                         if (rItem.state & LVIS_SELECTED)\r
2514                                         {\r
2515                                                 if (::GetFocus() == m_LogList.m_hWnd)\r
2516                                                         state |= LISS_SELECTED;\r
2517                                                 else\r
2518                                                         state |= LISS_SELECTEDNOTFOCUS;\r
2519                                         }\r
2520                                         else\r
2521                                         {\r
2522 #if 0\r
2523                                                 if (pLogEntry->bCopiedSelf)\r
2524                                                 {\r
2525                                                         // unfortunately, the pLVCD->nmcd.uItemState does not contain valid\r
2526                                                         // information at this drawing stage. But we can check the whether the\r
2527                                                         // previous stage changed the background color of the item\r
2528                                                         if (pLVCD->clrTextBk == GetSysColor(COLOR_MENU))\r
2529                                                         {\r
2530                                                                 HBRUSH brush;\r
2531                                                                 brush = ::CreateSolidBrush(::GetSysColor(COLOR_MENU));\r
2532                                                                 if (brush)\r
2533                                                                 {\r
2534                                                                         ::FillRect(pLVCD->nmcd.hdc, &rect, brush);\r
2535                                                                         ::DeleteObject(brush);\r
2536                                                                 }\r
2537                                                         }\r
2538                                                 }\r
2539 #endif\r
2540                                         }\r
2541 \r
2542                                         if (theme.IsBackgroundPartiallyTransparent(LVP_LISTDETAIL, state))\r
2543                                                 theme.DrawParentBackground(m_hWnd, pLVCD->nmcd.hdc, &rect);\r
2544 \r
2545                                         theme.DrawBackground(pLVCD->nmcd.hdc, LVP_LISTDETAIL, state, &rect, NULL);\r
2546                                 }\r
2547                                 else\r
2548                                 {\r
2549                                         HBRUSH brush;\r
2550                                         if (rItem.state & LVIS_SELECTED)\r
2551                                         {\r
2552                                                 if (::GetFocus() == m_LogList.m_hWnd)\r
2553                                                         brush = ::CreateSolidBrush(::GetSysColor(COLOR_HIGHLIGHT));\r
2554                                                 else\r
2555                                                         brush = ::CreateSolidBrush(::GetSysColor(COLOR_BTNFACE));\r
2556                                         }\r
2557                                         else\r
2558                                         {\r
2559                                                 //if (pLogEntry->bCopiedSelf)\r
2560                                                 //      brush = ::CreateSolidBrush(::GetSysColor(COLOR_MENU));\r
2561                                                 //else\r
2562                                                         brush = ::CreateSolidBrush(::GetSysColor(COLOR_WINDOW));\r
2563                                         }\r
2564                                         if (brush == NULL)\r
2565                                                 return;\r
2566 \r
2567                                         ::FillRect(pLVCD->nmcd.hdc, &rect, brush);\r
2568                                         ::DeleteObject(brush);\r
2569                                 }\r
2570 #if 0\r
2571                                 // Draw the icon(s) into the compatible DC\r
2572                                 if (pLogEntry->actions & LOGACTIONS_MODIFIED)\r
2573                                         ::DrawIconEx(pLVCD->nmcd.hdc, rect.left + ICONITEMBORDER, rect.top, m_hModifiedIcon, iconwidth, iconheight, 0, NULL, DI_NORMAL);\r
2574                                 nIcons++;\r
2575 \r
2576                                 if (pLogEntry->actions & LOGACTIONS_ADDED)\r
2577                                         ::DrawIconEx(pLVCD->nmcd.hdc, rect.left+nIcons*iconwidth + ICONITEMBORDER, rect.top, m_hAddedIcon, iconwidth, iconheight, 0, NULL, DI_NORMAL);\r
2578                                 nIcons++;\r
2579 \r
2580                                 if (pLogEntry->actions & LOGACTIONS_DELETED)\r
2581                                         ::DrawIconEx(pLVCD->nmcd.hdc, rect.left+nIcons*iconwidth + ICONITEMBORDER, rect.top, m_hDeletedIcon, iconwidth, iconheight, 0, NULL, DI_NORMAL);\r
2582                                 nIcons++;\r
2583 \r
2584                                 if (pLogEntry->actions & LOGACTIONS_REPLACED)\r
2585                                         ::DrawIconEx(pLVCD->nmcd.hdc, rect.left+nIcons*iconwidth + ICONITEMBORDER, rect.top, m_hReplacedIcon, iconwidth, iconheight, 0, NULL, DI_NORMAL);\r
2586                                 nIcons++;\r
2587 #endif\r
2588                                 *pResult = CDRF_SKIPDEFAULT;\r
2589                                 return;\r
2590                         }\r
2591                 }\r
2592                 break;\r
2593         }\r
2594         *pResult = CDRF_DODEFAULT;\r
2595 \r
2596 }\r
2597 void CLogDlg::OnNMCustomdrawChangedFileList(NMHDR *pNMHDR, LRESULT *pResult)\r
2598 {\r
2599 #if 0\r
2600         NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>( pNMHDR );\r
2601         // Take the default processing unless we set this to something else below.\r
2602         *pResult = CDRF_DODEFAULT;\r
2603 \r
2604         if (m_bNoDispUpdates)\r
2605                 return;\r
2606 \r
2607         // First thing - check the draw stage. If it's the control's prepaint\r
2608         // stage, then tell Windows we want messages for every item.\r
2609 \r
2610         if ( CDDS_PREPAINT == pLVCD->nmcd.dwDrawStage )\r
2611         {\r
2612                 *pResult = CDRF_NOTIFYITEMDRAW;\r
2613         }\r
2614         else if ( CDDS_ITEMPREPAINT == pLVCD->nmcd.dwDrawStage )\r
2615         {\r
2616                 // This is the prepaint stage for an item. Here's where we set the\r
2617                 // item's text color. Our return value will tell Windows to draw the\r
2618                 // item itself, but it will use the new color we set here.\r
2619 \r
2620                 // Tell Windows to paint the control itself.\r
2621                 *pResult = CDRF_DODEFAULT;\r
2622 \r
2623                 COLORREF crText = GetSysColor(COLOR_WINDOWTEXT);\r
2624                 bool bGrayed = false;\r
2625                 if ((m_cHidePaths.GetState() & 0x0003)==BST_INDETERMINATE)\r
2626                 {\r
2627                         if ((m_currentChangedArray)&&((m_currentChangedArray->GetCount() > (INT_PTR)pLVCD->nmcd.dwItemSpec)))\r
2628                         {\r
2629                                 if (m_currentChangedArray->GetAt(pLVCD->nmcd.dwItemSpec)->sPath.Left(m_sRelativeRoot.GetLength()).Compare(m_sRelativeRoot)!=0)\r
2630                                 {\r
2631                                         crText = GetSysColor(COLOR_GRAYTEXT);\r
2632                                         bGrayed = true;\r
2633                                 }\r
2634                         }\r
2635                         else if (m_currentChangedPathList.GetCount() > (INT_PTR)pLVCD->nmcd.dwItemSpec)\r
2636                         {\r
2637                                 if (m_currentChangedPathList[pLVCD->nmcd.dwItemSpec].GetGitPathString().Left(m_sRelativeRoot.GetLength()).Compare(m_sRelativeRoot)!=0)\r
2638                                 {\r
2639                                         crText = GetSysColor(COLOR_GRAYTEXT);\r
2640                                         bGrayed = true;\r
2641                                 }\r
2642                         }\r
2643                 }\r
2644 \r
2645                 if ((!bGrayed)&&(m_currentChangedArray)&&(m_currentChangedArray->GetCount() > (INT_PTR)pLVCD->nmcd.dwItemSpec))\r
2646                 {\r
2647                         DWORD action = m_currentChangedArray->GetAt(pLVCD->nmcd.dwItemSpec)->action;\r
2648                         if (action == LOGACTIONS_MODIFIED)\r
2649                                 crText = m_Colors.GetColor(CColors::Modified);\r
2650                         if (action == LOGACTIONS_REPLACED)\r
2651                                 crText = m_Colors.GetColor(CColors::Deleted);\r
2652                         if (action == LOGACTIONS_ADDED)\r
2653                                 crText = m_Colors.GetColor(CColors::Added);\r
2654                         if (action == LOGACTIONS_DELETED)\r
2655                                 crText = m_Colors.GetColor(CColors::Deleted);\r
2656                 }\r
2657 \r
2658                 // Store the color back in the NMLVCUSTOMDRAW struct.\r
2659                 pLVCD->clrText = crText;\r
2660         }\r
2661 #endif\r
2662 }\r
2663 \r
2664 void CLogDlg::DoSizeV1(int delta)\r
2665 {\r
2666 \r
2667         RemoveAnchor(IDC_LOGLIST);\r
2668         RemoveAnchor(IDC_SPLITTERTOP);\r
2669         RemoveAnchor(IDC_MSGVIEW);\r
2670         RemoveAnchor(IDC_SPLITTERBOTTOM);\r
2671         RemoveAnchor(IDC_LOGMSG);\r
2672         CSplitterControl::ChangeHeight(&m_LogList, delta, CW_TOPALIGN);\r
2673         CSplitterControl::ChangeHeight(GetDlgItem(IDC_MSGVIEW), -delta, CW_BOTTOMALIGN);\r
2674         AddAnchor(IDC_LOGLIST, TOP_LEFT, TOP_RIGHT);\r
2675         AddAnchor(IDC_SPLITTERTOP, TOP_LEFT, TOP_RIGHT);\r
2676         AddAnchor(IDC_MSGVIEW, TOP_LEFT, BOTTOM_RIGHT);\r
2677         AddAnchor(IDC_SPLITTERBOTTOM, BOTTOM_LEFT, BOTTOM_RIGHT);\r
2678         AddAnchor(IDC_LOGMSG, BOTTOM_LEFT, BOTTOM_RIGHT);\r
2679         ArrangeLayout();\r
2680         AdjustMinSize();\r
2681         SetSplitterRange();\r
2682         m_LogList.Invalidate();\r
2683         GetDlgItem(IDC_MSGVIEW)->Invalidate();\r
2684 \r
2685 }\r
2686 \r
2687 void CLogDlg::DoSizeV2(int delta)\r
2688 {\r
2689 \r
2690         RemoveAnchor(IDC_LOGLIST);\r
2691         RemoveAnchor(IDC_SPLITTERTOP);\r
2692         RemoveAnchor(IDC_MSGVIEW);\r
2693         RemoveAnchor(IDC_SPLITTERBOTTOM);\r
2694         RemoveAnchor(IDC_LOGMSG);\r
2695         CSplitterControl::ChangeHeight(GetDlgItem(IDC_MSGVIEW), delta, CW_TOPALIGN);\r
2696         CSplitterControl::ChangeHeight(&m_ChangedFileListCtrl, -delta, CW_BOTTOMALIGN);\r