src/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 #include "FileDiffDlg.h"\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         \r
 306         while (c>=0)\r
 307                 m_LogList.DeleteColumn(c--);\r
 308         temp.LoadString(IDS_LOG_GRAPH);\r
 309 \r
 310         m_LogList.InsertColumn(this->LOGLIST_GRAPH, temp);\r
 311         \r
 312 #if 0   \r
 313         // make the revision column right aligned\r
 314         LVCOLUMN Column;\r
 315         Column.mask = LVCF_FMT;\r
 316         Column.fmt = LVCFMT_RIGHT;\r
 317         m_LogList.SetColumn(0, &Column); \r
 318 #endif  \r
 319 //      CString log;\r
 320 //      g_Git.GetLog(log);\r
 321 \r
 322         temp.LoadString(IDS_LOG_ACTIONS);\r
 323         m_LogList.InsertColumn(this->LOGLIST_ACTION, temp);\r
 324         \r
 325         temp.LoadString(IDS_LOG_MESSAGE);\r
 326         m_LogList.InsertColumn(this->LOGLIST_MESSAGE, temp);\r
 327         \r
 328         temp.LoadString(IDS_LOG_AUTHOR);\r
 329         m_LogList.InsertColumn(this->LOGLIST_AUTHOR, temp);\r
 330         \r
 331         temp.LoadString(IDS_LOG_DATE);\r
 332         m_LogList.InsertColumn(this->LOGLIST_DATE, temp);\r
 333         \r
 334 \r
 335         if (m_bShowBugtraqColumn)\r
 336         {\r
 337                 temp = m_ProjectProperties.sLabel;\r
 338                 if (temp.IsEmpty())\r
 339                         temp.LoadString(IDS_LOG_BUGIDS);\r
 340                 m_LogList.InsertColumn(this->LOGLIST_BUG, temp);\r
 341 \r
 342         }\r
 343         \r
 344         m_LogList.SetRedraw(false);\r
 345         ResizeAllListCtrlCols();\r
 346         m_LogList.SetRedraw(true);\r
 347 \r
 348         m_ChangedFileListCtrl.SetExtendedStyle ( LVS_EX_FULLROWSELECT | LVS_EX_DOUBLEBUFFER );\r
 349         m_ChangedFileListCtrl.DeleteAllItems();\r
 350         c = ((CHeaderCtrl*)(m_ChangedFileListCtrl.GetDlgItem(0)))->GetItemCount()-1;\r
 351         while (c>=0)\r
 352                 m_ChangedFileListCtrl.DeleteColumn(c--);\r
 353         temp.LoadString(IDS_PROGRS_ACTION);\r
 354         m_ChangedFileListCtrl.InsertColumn(this->FILELIST_ACTION, temp);\r
 355         temp.LoadString(IDS_LOG_FILE_LINE_ADD);\r
 356         m_ChangedFileListCtrl.InsertColumn(this->FILELIST_ADD, temp);\r
 357         temp.LoadString(IDS_LOG_FILE_LINE_DEL);\r
 358         m_ChangedFileListCtrl.InsertColumn(this->FILELIST_DEL, temp);\r
 359         temp.LoadString(IDS_PROGRS_PATH);\r
 360         m_ChangedFileListCtrl.InsertColumn(this->FILELIST_PATH, temp);\r
 361         \r
 362         m_ChangedFileListCtrl.SetRedraw(false);\r
 363         CAppUtils::ResizeAllListCtrlCols(&m_ChangedFileListCtrl);\r
 364         m_ChangedFileListCtrl.SetRedraw(true);\r
 365 \r
 366 \r
 367         GetDlgItem(IDC_LOGLIST)->UpdateData(FALSE);\r
 368 \r
 369         m_logcounter = 0;\r
 370         m_sMessageBuf.Preallocate(100000);\r
 371 \r
 372         // set the dialog title to "Log - path/to/whatever/we/show/the/log/for"\r
 373         SetDlgTitle(false);\r
 374 \r
 375         m_tooltips.Create(this);\r
 376         CheckRegexpTooltip();\r
 377 \r
 378         SetSplitterRange();\r
 379         \r
 380         // the filter control has a 'cancel' button (the red 'X'), we need to load its bitmap\r
 381         m_cFilter.SetCancelBitmaps(IDI_CANCELNORMAL, IDI_CANCELPRESSED);\r
 382         m_cFilter.SetInfoIcon(IDI_LOGFILTER);\r
 383         m_cFilter.SetValidator(this);\r
 384         \r
 385         AdjustControlSize(IDC_HIDEPATHS);\r
 386         AdjustControlSize(IDC_CHECK_STOPONCOPY);\r
 387         AdjustControlSize(IDC_INCLUDEMERGE);\r
 388 \r
 389         GetClientRect(m_DlgOrigRect);\r
 390         m_LogList.GetClientRect(m_LogListOrigRect);\r
 391         GetDlgItem(IDC_MSGVIEW)->GetClientRect(m_MsgViewOrigRect);\r
 392         m_ChangedFileListCtrl.GetClientRect(m_ChgOrigRect);\r
 393 \r
 394         m_DateFrom.SendMessage(DTM_SETMCSTYLE, 0, MCS_WEEKNUMBERS|MCS_NOTODAY|MCS_NOTRAILINGDATES|MCS_NOSELCHANGEONNAV);\r
 395         m_DateTo.SendMessage(DTM_SETMCSTYLE, 0, MCS_WEEKNUMBERS|MCS_NOTODAY|MCS_NOTRAILINGDATES|MCS_NOSELCHANGEONNAV);\r
 396 \r
 397         // resizable stuff\r
 398         AddAnchor(IDC_FROMLABEL, TOP_LEFT);\r
 399         AddAnchor(IDC_DATEFROM, TOP_LEFT);\r
 400         AddAnchor(IDC_TOLABEL, TOP_LEFT);\r
 401         AddAnchor(IDC_DATETO, TOP_LEFT);\r
 402 \r
 403         SetFilterCueText();\r
 404         AddAnchor(IDC_SEARCHEDIT, TOP_LEFT, TOP_RIGHT);\r
 405         \r
 406         AddAnchor(IDC_LOGLIST, TOP_LEFT, TOP_RIGHT);\r
 407         AddAnchor(IDC_SPLITTERTOP, TOP_LEFT, TOP_RIGHT);\r
 408         AddAnchor(IDC_MSGVIEW, TOP_LEFT, BOTTOM_RIGHT);\r
 409         AddAnchor(IDC_SPLITTERBOTTOM, BOTTOM_LEFT, BOTTOM_RIGHT);\r
 410         AddAnchor(IDC_LOGMSG, BOTTOM_LEFT, BOTTOM_RIGHT);\r
 411 \r
 412         AddAnchor(IDC_LOGINFO, BOTTOM_LEFT, BOTTOM_RIGHT);      \r
 413         AddAnchor(IDC_HIDEPATHS, BOTTOM_LEFT);  \r
 414         AddAnchor(IDC_CHECK_STOPONCOPY, BOTTOM_LEFT);\r
 415         AddAnchor(IDC_INCLUDEMERGE, BOTTOM_LEFT);\r
 416         AddAnchor(IDC_GETALL, BOTTOM_LEFT);\r
 417         AddAnchor(IDC_NEXTHUNDRED, BOTTOM_LEFT);\r
 418         AddAnchor(IDC_REFRESH, BOTTOM_LEFT);\r
 419         AddAnchor(IDC_STATBUTTON, BOTTOM_RIGHT);\r
 420         AddAnchor(IDC_PROGRESS, BOTTOM_LEFT, BOTTOM_RIGHT);\r
 421         AddAnchor(IDOK, BOTTOM_RIGHT);\r
 422         AddAnchor(IDCANCEL, BOTTOM_RIGHT);\r
 423         AddAnchor(IDHELP, BOTTOM_RIGHT);\r
 424 \r
 425 //      SetPromptParentWindow(m_hWnd);\r
 426 \r
 427         if (hWndExplorer)\r
 428                 CenterWindow(CWnd::FromHandle(hWndExplorer));\r
 429         EnableSaveRestore(_T("LogDlg"));\r
 430 \r
 431         DWORD yPos1 = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\LogDlgSizer1"));\r
 432         DWORD yPos2 = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\LogDlgSizer2"));\r
 433         RECT rcDlg, rcLogList, rcChgMsg;\r
 434         GetClientRect(&rcDlg);\r
 435         m_LogList.GetWindowRect(&rcLogList);\r
 436         ScreenToClient(&rcLogList);\r
 437         m_ChangedFileListCtrl.GetWindowRect(&rcChgMsg);\r
 438         ScreenToClient(&rcChgMsg);\r
 439         if (yPos1)\r
 440         {\r
 441                 RECT rectSplitter;\r
 442                 m_wndSplitter1.GetWindowRect(&rectSplitter);\r
 443                 ScreenToClient(&rectSplitter);\r
 444                 int delta = yPos1 - rectSplitter.top;\r
 445 \r
 446                 if ((rcLogList.bottom + delta > rcLogList.top)&&(rcLogList.bottom + delta < rcChgMsg.bottom - 30))\r
 447                 {\r
 448                         m_wndSplitter1.SetWindowPos(NULL, 0, yPos1, 0, 0, SWP_NOSIZE);\r
 449                         DoSizeV1(delta);\r
 450                 }\r
 451         }\r
 452         if (yPos2)\r
 453         {\r
 454                 RECT rectSplitter;\r
 455                 m_wndSplitter2.GetWindowRect(&rectSplitter);\r
 456                 ScreenToClient(&rectSplitter);\r
 457                 int delta = yPos2 - rectSplitter.top;\r
 458 \r
 459                 if ((rcChgMsg.top + delta < rcChgMsg.bottom)&&(rcChgMsg.top + delta > rcLogList.top + 30))\r
 460                 {\r
 461                         m_wndSplitter2.SetWindowPos(NULL, 0, yPos2, 0, 0, SWP_NOSIZE);\r
 462                         DoSizeV2(delta);\r
 463                 }\r
 464         }\r
 465 \r
 466         \r
 467         if (m_bSelect)\r
 468         {\r
 469                 // the dialog is used to select revisions\r
 470                 if (m_bSelectionMustBeContinuous)\r
 471                         DialogEnableWindow(IDOK, (m_LogList.GetSelectedCount()!=0)&&(IsSelectionContinuous()));\r
 472                 else\r
 473                         DialogEnableWindow(IDOK, m_LogList.GetSelectedCount()!=0);\r
 474         }\r
 475         else\r
 476         {\r
 477                 // the dialog is used to just view log messages\r
 478                 GetDlgItemText(IDOK, temp);\r
 479                 SetDlgItemText(IDCANCEL, temp);\r
 480                 GetDlgItem(IDOK)->ShowWindow(SW_HIDE);\r
 481         }\r
 482         \r
 483         // set the choices for the "Show All" button\r
 484         temp.LoadString(IDS_LOG_SHOWALL);\r
 485         m_btnShow.AddEntry(temp);\r
 486         temp.LoadString(IDS_LOG_SHOWRANGE);\r
 487         m_btnShow.AddEntry(temp);\r
 488         m_btnShow.SetCurrentEntry((LONG)CRegDWORD(_T("Software\\TortoiseGit\\ShowAllEntry")));\r
 489 \r
 490         m_mergedRevs.clear();\r
 491 \r
 492         // first start a thread to obtain the log messages without\r
 493         // blocking the dialog\r
 494         m_tTo = 0;\r
 495         m_tFrom = (DWORD)-1;\r
 496         InterlockedExchange(&m_bThreadRunning, TRUE);\r
 497         InterlockedExchange(&m_bNoDispUpdates, TRUE);\r
 498         if (AfxBeginThread(LogThreadEntry, this)==NULL)\r
 499         {\r
 500                 InterlockedExchange(&m_bThreadRunning, FALSE);\r
 501                 InterlockedExchange(&m_bNoDispUpdates, FALSE);\r
 502                 CMessageBox::Show(NULL, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);\r
 503         }\r
 504         GetDlgItem(IDC_LOGLIST)->SetFocus();\r
 505         return FALSE;\r
 506 }\r
 507 \r
 508 void CLogDlg::SetDlgTitle(bool bOffline)\r
 509 {\r
 510         if (m_sTitle.IsEmpty())\r
 511                 GetWindowText(m_sTitle);\r
 512 \r
 513         if (bOffline)\r
 514         {\r
 515                 CString sTemp;\r
 516                 if (m_path.IsUrl())\r
 517                         sTemp.Format(IDS_LOG_DLGTITLEOFFLINE, (LPCTSTR)m_sTitle, (LPCTSTR)m_path.GetUIPathString());\r
 518                 else if (m_path.IsDirectory())\r
 519                         sTemp.Format(IDS_LOG_DLGTITLEOFFLINE, (LPCTSTR)m_sTitle, (LPCTSTR)m_path.GetWinPathString());\r
 520                 else\r
 521                         sTemp.Format(IDS_LOG_DLGTITLEOFFLINE, (LPCTSTR)m_sTitle, (LPCTSTR)m_path.GetFilename());\r
 522                 SetWindowText(sTemp);\r
 523         }\r
 524         else\r
 525         {\r
 526                 if (m_path.IsUrl())\r
 527                         SetWindowText(m_sTitle + _T(" - ") + m_path.GetUIPathString());\r
 528                 else if (m_path.IsDirectory())\r
 529                         SetWindowText(m_sTitle + _T(" - ") + m_path.GetWinPathString());\r
 530                 else\r
 531                         SetWindowText(m_sTitle + _T(" - ") + m_path.GetFilename());\r
 532         }\r
 533 }\r
 534 \r
 535 void CLogDlg::CheckRegexpTooltip()\r
 536 {\r
 537         CWnd *pWnd = GetDlgItem(IDC_SEARCHEDIT);\r
 538         // Since tooltip describes regexp features, show it only if regexps are enabled.\r
 539         if (m_bFilterWithRegex)\r
 540         {\r
 541                 m_tooltips.AddTool(pWnd, IDS_LOG_FILTER_REGEX_TT);\r
 542         }\r
 543         else\r
 544                 m_tooltips.DelTool(pWnd);\r
 545 }\r
 546 \r
 547 void CLogDlg::EnableOKButton()\r
 548 {\r
 549         if (m_bSelect)\r
 550         {\r
 551                 // the dialog is used to select revisions\r
 552                 if (m_bSelectionMustBeContinuous)\r
 553                         DialogEnableWindow(IDOK, (m_LogList.GetSelectedCount()!=0)&&(IsSelectionContinuous()));\r
 554                 else\r
 555                         DialogEnableWindow(IDOK, m_LogList.GetSelectedCount()!=0);\r
 556         }\r
 557         else\r
 558                 DialogEnableWindow(IDOK, TRUE);\r
 559 }\r
 560 \r
 561 void CLogDlg::FillLogMessageCtrl(bool bShow /* = true*/)\r
 562 {\r
 563         // we fill here the log message rich edit control,\r
 564         // and also populate the changed files list control\r
 565         // according to the selected revision(s).\r
 566 \r
 567         CWnd * pMsgView = GetDlgItem(IDC_MSGVIEW);\r
 568         // empty the log message view\r
 569         pMsgView->SetWindowText(_T(" "));\r
 570         // empty the changed files list\r
 571         m_ChangedFileListCtrl.SetRedraw(FALSE);\r
 572         InterlockedExchange(&m_bNoDispUpdates, TRUE);\r
 573         m_currentChangedArray = NULL;\r
 574         m_ChangedFileListCtrl.SetExtendedStyle ( LVS_EX_FULLROWSELECT | LVS_EX_DOUBLEBUFFER );\r
 575         m_ChangedFileListCtrl.DeleteAllItems();\r
 576         m_ChangedFileListCtrl.SetItemCountEx(0);\r
 577 \r
 578         // if we're not here to really show a selected revision, just\r
 579         // get out of here after clearing the views, which is what is intended\r
 580         // if that flag is not set.\r
 581         if (!bShow)\r
 582         {\r
 583                 // force a redraw\r
 584                 m_ChangedFileListCtrl.Invalidate();\r
 585                 InterlockedExchange(&m_bNoDispUpdates, FALSE);\r
 586                 m_ChangedFileListCtrl.SetRedraw(TRUE);\r
 587                 return;\r
 588         }\r
 589 \r
 590         // depending on how many revisions are selected, we have to do different\r
 591         // tasks.\r
 592         int selCount = m_LogList.GetSelectedCount();\r
 593         if (selCount == 0)\r
 594         {\r
 595                 // if nothing is selected, we have nothing more to do\r
 596                 InterlockedExchange(&m_bNoDispUpdates, FALSE);\r
 597                 m_ChangedFileListCtrl.SetRedraw(TRUE);\r
 598                 return;\r
 599         }\r
 600         else if (selCount == 1)\r
 601         {\r
 602                 // if one revision is selected, we have to fill the log message view\r
 603                 // with the corresponding log message, and also fill the changed files\r
 604                 // list fully.\r
 605                 POSITION pos = m_LogList.GetFirstSelectedItemPosition();\r
 606                 int selIndex = m_LogList.GetNextSelectedItem(pos);\r
 607                 if (selIndex >= m_arShownList.GetCount())\r
 608                 {\r
 609                         InterlockedExchange(&m_bNoDispUpdates, FALSE);\r
 610                         m_ChangedFileListCtrl.SetRedraw(TRUE);\r
 611                         return;\r
 612                 }\r
 613                 GitRev* pLogEntry = reinterpret_cast<GitRev *>(m_arShownList.GetAt(selIndex));\r
 614 \r
 615                 // set the log message text\r
 616                 pMsgView->SetWindowText(_T("*")+pLogEntry->m_Subject+_T("\n\n")+pLogEntry->m_Body);\r
 617                 // turn bug ID's into links if the bugtraq: properties have been set\r
 618                 // and we can find a match of those in the log message\r
 619                 m_ProjectProperties.FindBugID(pLogEntry->m_Body, pMsgView);\r
 620                 CAppUtils::FormatTextInRichEditControl(pMsgView);\r
 621                 m_currentChangedArray = &(pLogEntry->m_Files);\r
 622                 if (m_currentChangedArray == NULL)\r
 623                 {\r
 624                         InterlockedExchange(&m_bNoDispUpdates, FALSE);\r
 625                         m_ChangedFileListCtrl.SetRedraw(TRUE);\r
 626                         return;\r
 627                 }\r
 628 #if 0\r
 629                 // fill in the changed files list control\r
 630                 if ((m_cHidePaths.GetState() & 0x0003)==BST_CHECKED)\r
 631                 {\r
 632                         m_CurrentFilteredChangedArray.RemoveAll();\r
 633                         for (INT_PTR c = 0; c < m_currentChangedArray->GetCount(); ++c)\r
 634                         {\r
 635                                 LogChangedPath * cpath = m_currentChangedArray->GetAt(c);\r
 636                                 if (cpath == NULL)\r
 637                                         continue;\r
 638                                 if (m_currentChangedArray->GetAt(c)->sPath.Left(m_sRelativeRoot.GetLength()).Compare(m_sRelativeRoot)==0)\r
 639                                 {\r
 640                                         m_CurrentFilteredChangedArray.Add(cpath);\r
 641                                 }\r
 642                         }\r
 643                         m_currentChangedArray = &m_CurrentFilteredChangedArray;\r
 644                 }\r
 645 #endif\r
 646         }\r
 647         else\r
 648         {\r
 649                 // more than one revision is selected:\r
 650                 // the log message view must be emptied\r
 651                 // the changed files list contains all the changed paths from all\r
 652                 // selected revisions, with 'doubles' removed\r
 653                 m_currentChangedPathList = GetChangedPathsFromSelectedRevisions(true);\r
 654         }\r
 655         \r
 656         // redraw the views\r
 657         InterlockedExchange(&m_bNoDispUpdates, FALSE);\r
 658         if (m_currentChangedArray)\r
 659         {\r
 660                 m_ChangedFileListCtrl.SetItemCountEx(m_currentChangedArray->GetCount());\r
 661                 m_ChangedFileListCtrl.RedrawItems(0, m_currentChangedArray->GetCount());\r
 662         }\r
 663         else if (m_currentChangedPathList.GetCount())\r
 664         {\r
 665                 m_ChangedFileListCtrl.SetItemCountEx(m_currentChangedPathList.GetCount());\r
 666                 m_ChangedFileListCtrl.RedrawItems(0, m_currentChangedPathList.GetCount());\r
 667         }\r
 668         else\r
 669         {\r
 670                 m_ChangedFileListCtrl.SetItemCountEx(0);\r
 671                 m_ChangedFileListCtrl.Invalidate();\r
 672         }\r
 673         CAppUtils::ResizeAllListCtrlCols(&m_ChangedFileListCtrl);\r
 674         // sort according to the settings\r
 675         if (m_nSortColumnPathList > 0)\r
 676                 SetSortArrow(&m_ChangedFileListCtrl, m_nSortColumnPathList, m_bAscendingPathList);\r
 677         else\r
 678                 SetSortArrow(&m_ChangedFileListCtrl, -1, false);\r
 679         m_ChangedFileListCtrl.SetRedraw(TRUE);\r
 680 \r
 681 }\r
 682 \r
 683 void CLogDlg::OnBnClickedGetall()\r
 684 {\r
 685         GetAll();\r
 686 }\r
 687 \r
 688 void CLogDlg::GetAll(bool bForceAll /* = false */)\r
 689 {\r
 690 #if 0\r
 691         // fetch all requested log messages, either the specified range or\r
 692         // really *all* available log messages.\r
 693         UpdateData();\r
 694         INT_PTR entry = m_btnShow.GetCurrentEntry();\r
 695         if (bForceAll)\r
 696                 entry = 0;\r
 697 \r
 698         switch (entry)\r
 699         {\r
 700         case 0: // show all\r
 701         \r
 702                 m_endrev = 0;\r
 703                 m_startrev = m_LogRevision;\r
 704                 if (m_bStrict)\r
 705                         m_bShowedAll = true;\r
 706 \r
 707                 break;\r
 708         case 1: // show range\r
 709                 {\r
 710 \r
 711                         // ask for a revision range\r
 712                         CRevisionRangeDlg dlg;\r
 713                         dlg.SetStartRevision(m_startrev);\r
 714                         dlg.SetEndRevision( (m_endrev>=0) ? m_endrev : 0);\r
 715                         if (dlg.DoModal()!=IDOK)\r
 716                         {\r
 717                                 return;\r
 718                         }\r
 719                         m_endrev = dlg.GetEndRevision();\r
 720                         m_startrev = dlg.GetStartRevision();\r
 721                         if (((m_endrev.IsNumber())&&(m_startrev.IsNumber()))||\r
 722                                 (m_endrev.IsHead()||m_startrev.IsHead()))\r
 723                         {\r
 724                                 if (((LONG)m_startrev < (LONG)m_endrev)||\r
 725                                         (m_endrev.IsHead()))\r
 726                                 {\r
 727                                         git_revnum_t temp = m_startrev;\r
 728                                         m_startrev = m_endrev;\r
 729                                         m_endrev = temp;\r
 730                                 }\r
 731                         }\r
 732                         m_bShowedAll = false;\r
 733                 }\r
 734 \r
 735                 break;\r
 736         }\r
 737         m_ChangedFileListCtrl.SetItemCountEx(0);\r
 738         m_ChangedFileListCtrl.Invalidate();\r
 739         // We need to create CStoreSelection on the heap or else\r
 740         // the variable will run out of the scope before the\r
 741         // thread ends. Therefore we let the thread delete\r
 742         // the instance.\r
 743         m_pStoreSelection = new CStoreSelection(this);\r
 744         m_LogList.SetItemCountEx(0);\r
 745         m_LogList.Invalidate();\r
 746         InterlockedExchange(&m_bNoDispUpdates, TRUE);\r
 747         CWnd * pMsgView = GetDlgItem(IDC_MSGVIEW);\r
 748         pMsgView->SetWindowText(_T(""));\r
 749 \r
 750         SetSortArrow(&m_LogList, -1, true);\r
 751 \r
 752         m_LogList.DeleteAllItems();\r
 753         m_arShownList.RemoveAll();\r
 754         m_logEntries.ClearAll();\r
 755 \r
 756         m_logcounter = 0;\r
 757         m_bCancelled = FALSE;\r
 758         m_tTo = 0;\r
 759         m_tFrom = (DWORD)-1;\r
 760         m_limit = 0;\r
 761 \r
 762         InterlockedExchange(&m_bThreadRunning, TRUE);\r
 763         if (AfxBeginThread(LogThreadEntry, this)==NULL)\r
 764         {\r
 765                 InterlockedExchange(&m_bThreadRunning, FALSE);\r
 766                 CMessageBox::Show(NULL, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);\r
 767         }\r
 768         GetDlgItem(IDC_LOGLIST)->UpdateData(FALSE);\r
 769         InterlockedExchange(&m_bNoDispUpdates, FALSE);\r
 770 #endif\r
 771 }\r
 772 \r
 773 void CLogDlg::OnBnClickedRefresh()\r
 774 {\r
 775         m_limit = 0;\r
 776         Refresh (true);\r
 777 }\r
 778 \r
 779 void CLogDlg::Refresh (bool autoGoOnline)\r
 780 {\r
 781 #if 0\r
 782         // refreshing means re-downloading the already shown log messages\r
 783         UpdateData();\r
 784         m_maxChild = 0;\r
 785         m_childCounter = 0;\r
 786 \r
 787         if ((m_limit == 0)||(m_bStrict)||(int(m_logEntries.size()-1) > m_limit))\r
 788         {\r
 789                 if (m_logEntries.size() != 0)\r
 790                 {\r
 791                         m_endrev = m_logEntries[m_logEntries.size()-1]->Rev;\r
 792                 }\r
 793         }\r
 794         m_startrev = -1;\r
 795         m_bCancelled = FALSE;\r
 796 \r
 797         // We need to create CStoreSelection on the heap or else\r
 798         // the variable will run out of the scope before the\r
 799         // thread ends. Therefore we let the thread delete\r
 800         // the instance.\r
 801         m_pStoreSelection = new CStoreSelection(this);\r
 802         m_ChangedFileListCtrl.SetItemCountEx(0);\r
 803         m_ChangedFileListCtrl.Invalidate();\r
 804         m_LogList.SetItemCountEx(0);\r
 805         m_LogList.Invalidate();\r
 806         InterlockedExchange(&m_bNoDispUpdates, TRUE);\r
 807         CWnd * pMsgView = GetDlgItem(IDC_MSGVIEW);\r
 808         pMsgView->SetWindowText(_T(""));\r
 809 \r
 810         SetSortArrow(&m_LogList, -1, true);\r
 811 \r
 812         m_LogList.DeleteAllItems();\r
 813         m_arShownList.RemoveAll();\r
 814         m_logEntries.ClearAll();\r
 815 \r
 816     // reset the cached HEAD property & go on-line\r
 817 \r
 818     if (autoGoOnline)\r
 819     {\r
 820             SetDlgTitle (false);\r
 821         logCachePool.GetRepositoryInfo().ResetHeadRevision (m_sUUID, m_sRepositoryRoot);\r
 822     }\r
 823 \r
 824         InterlockedExchange(&m_bThreadRunning, TRUE);\r
 825         if (AfxBeginThread(LogThreadEntry, this)==NULL)\r
 826         {\r
 827                 InterlockedExchange(&m_bThreadRunning, FALSE);\r
 828                 CMessageBox::Show(NULL, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);\r
 829         }\r
 830         GetDlgItem(IDC_LOGLIST)->UpdateData(FALSE);\r
 831         InterlockedExchange(&m_bNoDispUpdates, FALSE);\r
 832 #endif\r
 833 }\r
 834 \r
 835 void CLogDlg::OnBnClickedNexthundred()\r
 836 {\r
 837 #if 0\r
 838         UpdateData();\r
 839         // we have to fetch the next X log messages.\r
 840         if (m_logEntries.size() < 1)\r
 841         {\r
 842                 // since there weren't any log messages fetched before, just\r
 843                 // fetch all since we don't have an 'anchor' to fetch the 'next'\r
 844                 // messages from.\r
 845                 return GetAll(true);\r
 846         }\r
 847         git_revnum_t rev = m_logEntries[m_logEntries.size()-1]->Rev;\r
 848 \r
 849         if (rev < 1)\r
 850                 return;         // do nothing! No more revisions to get\r
 851 \r
 852         m_startrev = rev;\r
 853         m_endrev = 0;\r
 854         m_bCancelled = FALSE;\r
 855 \r
 856     // rev is is revision we already have and we will receive it again\r
 857     // -> fetch one extra revision to get NumberOfLogs *new* revisions\r
 858 \r
 859         m_limit = (int)(DWORD)CRegDWORD(_T("Software\\TortoiseGit\\NumberOfLogs"), 100) +1;\r
 860         InterlockedExchange(&m_bNoDispUpdates, TRUE);\r
 861         SetSortArrow(&m_LogList, -1, true);\r
 862         InterlockedExchange(&m_bThreadRunning, TRUE);\r
 863         // We need to create CStoreSelection on the heap or else\r
 864         // the variable will run out of the scope before the\r
 865         // thread ends. Therefore we let the thread delete\r
 866         // the instance.\r
 867         m_pStoreSelection = new CStoreSelection(this);\r
 868 \r
 869         // since we fetch the log from the last revision we already have,\r
 870         // we have to remove that revision entry to avoid getting it twice\r
 871         m_logEntries.pop_back();\r
 872         if (AfxBeginThread(LogThreadEntry, this)==NULL)\r
 873         {\r
 874                 InterlockedExchange(&m_bThreadRunning, FALSE);\r
 875                 CMessageBox::Show(NULL, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);\r
 876         }\r
 877         InterlockedExchange(&m_bNoDispUpdates, TRUE);\r
 878         GetDlgItem(IDC_LOGLIST)->UpdateData(FALSE);\r
 879 #endif\r
 880 }\r
 881 \r
 882 BOOL CLogDlg::Cancel()\r
 883 {\r
 884         return m_bCancelled;\r
 885 }\r
 886 \r
 887 void CLogDlg::SaveSplitterPos()\r
 888 {\r
 889         if (!IsIconic())\r
 890         {\r
 891                 CRegDWORD regPos1 = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\LogDlgSizer1"));\r
 892                 CRegDWORD regPos2 = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\LogDlgSizer2"));\r
 893                 RECT rectSplitter;\r
 894                 m_wndSplitter1.GetWindowRect(&rectSplitter);\r
 895                 ScreenToClient(&rectSplitter);\r
 896                 regPos1 = rectSplitter.top;\r
 897                 m_wndSplitter2.GetWindowRect(&rectSplitter);\r
 898                 ScreenToClient(&rectSplitter);\r
 899                 regPos2 = rectSplitter.top;\r
 900         }\r
 901 }\r
 902 \r
 903 void CLogDlg::OnCancel()\r
 904 {\r
 905         // canceling means stopping the working thread if it's still running.\r
 906         // we do this by using the Subversion cancel callback.\r
 907         // But canceling can also mean just to close the dialog, depending on the\r
 908         // text shown on the cancel button (it could simply read "OK").\r
 909         CString temp, temp2;\r
 910         GetDlgItemText(IDOK, temp);\r
 911         temp2.LoadString(IDS_MSGBOX_CANCEL);\r
 912         if ((temp.Compare(temp2)==0)||(m_bThreadRunning))\r
 913         {\r
 914                 m_bCancelled = true;\r
 915                 return;\r
 916         }\r
 917         UpdateData();\r
 918         if (m_bSaveStrict)\r
 919                 m_regLastStrict = m_bStrict;\r
 920         CRegDWORD reg = CRegDWORD(_T("Software\\TortoiseGit\\ShowAllEntry"));\r
 921         reg = m_btnShow.GetCurrentEntry();\r
 922         SaveSplitterPos();\r
 923         __super::OnCancel();\r
 924 }\r
 925 \r
 926 CString CLogDlg::MakeShortMessage(const CString& message)\r
 927 {\r
 928         bool bFoundShort = true;\r
 929         CString sShortMessage = m_ProjectProperties.GetLogSummary(message);\r
 930         if (sShortMessage.IsEmpty())\r
 931         {\r
 932                 bFoundShort = false;\r
 933                 sShortMessage = message;\r
 934         }\r
 935         // Remove newlines and tabs 'cause those are not shown nicely in the list control\r
 936         sShortMessage.Replace(_T("\r"), _T(""));\r
 937         sShortMessage.Replace(_T("\t"), _T(" "));\r
 938         \r
 939         // Suppose the first empty line separates 'summary' from the rest of the message.\r
 940         int found = sShortMessage.Find(_T("\n\n"));\r
 941         // To avoid too short 'short' messages \r
 942         // (e.g. if the message looks something like "Bugfix:\n\n*done this\n*done that")\r
 943         // only use the empty newline as a separator if it comes after at least 15 chars.\r
 944         if ((!bFoundShort)&&(found >= 15))\r
 945         {\r
 946                 sShortMessage = sShortMessage.Left(found);\r
 947         }\r
 948         sShortMessage.Replace('\n', ' ');\r
 949         return sShortMessage;\r
 950 }\r
 951 \r
 952 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
 953 {\r
 954 #if 0\r
 955         if (rev == SVN_INVALID_REVNUM)\r
 956         {\r
 957                 m_childCounter--;\r
 958                 return TRUE;\r
 959         }\r
 960 \r
 961         // this is the callback function which receives the data for every revision we ask the log for\r
 962         // we store this information here one by one.\r
 963         m_logcounter += 1;\r
 964         if (m_startrev == -1)\r
 965                 m_startrev = rev;\r
 966         if (m_limit != 0)\r
 967         {\r
 968                 m_limitcounter--;\r
 969                 m_LogProgress.SetPos(m_limit - m_limitcounter);\r
 970         }\r
 971         else if (m_startrev.IsNumber() && m_startrev.IsNumber())\r
 972                 m_LogProgress.SetPos((git_revnum_t)m_startrev-rev+(git_revnum_t)m_endrev);\r
 973         __time64_t ttime = time/1000000L;\r
 974         if (m_tTo < (DWORD)ttime)\r
 975                 m_tTo = (DWORD)ttime;\r
 976         if (m_tFrom > (DWORD)ttime)\r
 977                 m_tFrom = (DWORD)ttime;\r
 978         if ((m_lowestRev > rev)||(m_lowestRev < 0))\r
 979                 m_lowestRev = rev;\r
 980         // Add as many characters from the log message to the list control\r
 981         PLOGENTRYDATA pLogItem = new LOGENTRYDATA;\r
 982         pLogItem->bCopies = !!copies;\r
 983         \r
 984         // find out if this item was copied in the revision\r
 985         BOOL copiedself = FALSE;\r
 986         if (copies)\r
 987         {\r
 988                 for (INT_PTR cpPathIndex = 0; cpPathIndex < cpaths->GetCount(); ++cpPathIndex)\r
 989                 {\r
 990                         LogChangedPath * cpath = cpaths->GetAt(cpPathIndex);\r
 991                         if (!cpath->sCopyFromPath.IsEmpty() && (cpath->sPath.Compare(m_sSelfRelativeURL) == 0))\r
 992                         {\r
 993                                 // note: this only works if the log is fetched top-to-bottom\r
 994                                 // but since we do that, it shouldn't be a problem\r
 995                                 m_sSelfRelativeURL = cpath->sCopyFromPath;\r
 996                                 copiedself = TRUE;\r
 997                                 break;\r
 998                         }\r
 999                 }\r
1000         }\r
1001         pLogItem->bCopiedSelf = copiedself;\r
1002         pLogItem->tmDate = ttime;\r
1003         pLogItem->sAuthor = author;\r
1004         pLogItem->sDate = date;\r
1005         pLogItem->sShortMessage = MakeShortMessage(message);\r
1006         pLogItem->dwFileChanges = filechanges;\r
1007         pLogItem->actions = actions;\r
1008         pLogItem->haschildren = haschildren;\r
1009         pLogItem->childStackDepth = m_childCounter;\r
1010         m_maxChild = max(m_childCounter, m_maxChild);\r
1011         if (haschildren)\r
1012                 m_childCounter++;\r
1013         pLogItem->sBugIDs = m_ProjectProperties.FindBugID(message).Trim();\r
1014         \r
1015         // split multi line log entries and concatenate them\r
1016         // again but this time with \r\n as line separators\r
1017         // so that the edit control recognizes them\r
1018         try\r
1019         {\r
1020                 if (message.GetLength()>0)\r
1021                 {\r
1022                         m_sMessageBuf = message;\r
1023                         m_sMessageBuf.Replace(_T("\n\r"), _T("\n"));\r
1024                         m_sMessageBuf.Replace(_T("\r\n"), _T("\n"));\r
1025                         if (m_sMessageBuf.Right(1).Compare(_T("\n"))==0)\r
1026                                 m_sMessageBuf = m_sMessageBuf.Left(m_sMessageBuf.GetLength()-1);\r
1027                 }\r
1028                 else\r
1029                         m_sMessageBuf.Empty();\r
1030         pLogItem->sMessage = m_sMessageBuf;\r
1031         pLogItem->Rev = rev;\r
1032 \r
1033         // move-construct path array\r
1034 \r
1035         pLogItem->pArChangedPaths = new LogChangedPathArray (*cpaths);\r
1036         cpaths->RemoveAll();\r
1037         }\r
1038         catch (CException * e)\r
1039         {\r
1040                 ::MessageBox(NULL, _T("not enough memory!"), _T("TortoiseGit"), MB_ICONERROR);\r
1041                 e->Delete();\r
1042                 m_bCancelled = TRUE;\r
1043         }\r
1044         m_logEntries.push_back(pLogItem);\r
1045         m_arShownList.Add(pLogItem);\r
1046 #endif\r
1047         return TRUE;\r
1048 }\r
1049 \r
1050 //this is the thread function which calls the subversion function\r
1051 UINT CLogDlg::LogThreadEntry(LPVOID pVoid)\r
1052 {\r
1053         return ((CLogDlg*)pVoid)->LogThread();\r
1054 }\r
1055 \r
1056 GitRev g_rev;\r
1057 //this is the thread function which calls the subversion function\r
1058 UINT CLogDlg::LogThread()\r
1059 {\r
1060 \r
1061         InterlockedExchange(&m_bThreadRunning, TRUE);\r
1062 \r
1063     //does the user force the cache to refresh (shift or control key down)?\r
1064     bool refresh =    (GetKeyState (VK_CONTROL) < 0) \r
1065                    || (GetKeyState (VK_SHIFT) < 0);\r
1066 \r
1067         //disable the "Get All" button while we're receiving\r
1068         //log messages.\r
1069         DialogEnableWindow(IDC_GETALL, FALSE);\r
1070         DialogEnableWindow(IDC_NEXTHUNDRED, FALSE);\r
1071         DialogEnableWindow(IDC_CHECK_STOPONCOPY, FALSE);\r
1072         DialogEnableWindow(IDC_INCLUDEMERGE, FALSE);\r
1073         DialogEnableWindow(IDC_STATBUTTON, FALSE);\r
1074         DialogEnableWindow(IDC_REFRESH, FALSE);\r
1075         \r
1076         CString temp;\r
1077         temp.LoadString(IDS_PROGRESSWAIT);\r
1078         m_LogList.ShowText(temp, true);\r
1079         // change the text of the close button to "Cancel" since now the thread\r
1080         // is running, and simply closing the dialog doesn't work.\r
1081         if (!GetDlgItem(IDOK)->IsWindowVisible())\r
1082         {\r
1083                 temp.LoadString(IDS_MSGBOX_CANCEL);\r
1084                 SetDlgItemText(IDCANCEL, temp);\r
1085         }\r
1086         // We use a progress bar while getting the logs\r
1087         m_LogProgress.SetRange32(0, 100);\r
1088         m_LogProgress.SetPos(0);\r
1089         GetDlgItem(IDC_PROGRESS)->ShowWindow(TRUE);\r
1090 //      git_revnum_t r = -1;\r
1091         \r
1092         // get the repository root url, because the changed-files-list has the\r
1093         // paths shown there relative to the repository root.\r
1094 //      CTGitPath rootpath;\r
1095 //  BOOL succeeded = GetRootAndHead(m_path, rootpath, r);\r
1096 \r
1097 //    m_sRepositoryRoot = rootpath.GetGitPathString();\r
1098 //    m_sURL = m_path.GetGitPathString();\r
1099 \r
1100     // we need the UUID to unambigously identify the log cache\r
1101 //    if (logCachePool.IsEnabled())\r
1102 //        m_sUUID = logCachePool.GetRepositoryInfo().GetRepositoryUUID (rootpath);\r
1103 \r
1104     // if the log dialog is started from a working copy, we need to turn that\r
1105     // local path into an url here\r
1106 //    if (succeeded)\r
1107 //    {\r
1108 //        if (!m_path.IsUrl())\r
1109 //        {\r
1110 //              m_sURL = GetURLFromPath(m_path);\r
1111 \r
1112                 // The URL is escaped because Git::logReceiver\r
1113                 // returns the path in a native format\r
1114 //              m_sURL = CPathUtils::PathUnescape(m_sURL);\r
1115   //      }\r
1116 //        m_sRelativeRoot = m_sURL.Mid(CPathUtils::PathUnescape(m_sRepositoryRoot).GetLength());\r
1117 //              m_sSelfRelativeURL = m_sRelativeRoot;\r
1118   //  }\r
1119 #if 0\r
1120     if (succeeded && !m_mergePath.IsEmpty() && m_mergedRevs.empty())\r
1121     {\r
1122             // in case we got a merge path set, retrieve the merge info\r
1123             // of that path and check whether one of the merge URLs\r
1124             // match the URL we show the log for.\r
1125             GitPool localpool(pool);\r
1126             git_error_clear(Err);\r
1127             apr_hash_t * mergeinfo = NULL;\r
1128             if (git_client_mergeinfo_get_merged (&mergeinfo, m_mergePath.GetGitApiPath(localpool), GitRev(GitRev::REV_WC), m_pctx, localpool) == NULL)\r
1129             {\r
1130                     // now check the relative paths\r
1131                     apr_hash_index_t *hi;\r
1132                     const void *key;\r
1133                     void *val;\r
1134 \r
1135                     if (mergeinfo)\r
1136                     {\r
1137                             for (hi = apr_hash_first(localpool, mergeinfo); hi; hi = apr_hash_next(hi))\r
1138                             {\r
1139                                     apr_hash_this(hi, &key, NULL, &val);\r
1140                                     if (m_sURL.Compare(CUnicodeUtils::GetUnicode((char*)key)) == 0)\r
1141                                     {\r
1142                                             apr_array_header_t * arr = (apr_array_header_t*)val;\r
1143                                             if (val)\r
1144                                             {\r
1145                                                     for (long i=0; i<arr->nelts; ++i)\r
1146                                                     {\r
1147                                                             git_merge_range_t * pRange = APR_ARRAY_IDX(arr, i, git_merge_range_t*);\r
1148                                                             if (pRange)\r
1149                                                             {\r
1150                                                                     for (git_revnum_t r=pRange->start+1; r<=pRange->end; ++r)\r
1151                                                                     {\r
1152                                                                             m_mergedRevs.insert(r);\r
1153                                                                     }\r
1154                                                             }\r
1155                                                     }\r
1156                                             }\r
1157                                             break;\r
1158                                     }\r
1159                             }\r
1160                     }\r
1161             }\r
1162     }\r
1163 \r
1164     m_LogProgress.SetPos(1);\r
1165     if (m_startrev == GitRev::REV_HEAD)\r
1166     {\r
1167             m_startrev = r;\r
1168     }\r
1169     if (m_endrev == GitRev::REV_HEAD)\r
1170     {\r
1171             m_endrev = r;\r
1172     }\r
1173 \r
1174     if (m_limit != 0)\r
1175     {\r
1176             m_limitcounter = m_limit;\r
1177             m_LogProgress.SetRange32(0, m_limit);\r
1178     }\r
1179     else\r
1180             m_LogProgress.SetRange32(m_endrev, m_startrev);\r
1181         \r
1182     if (!m_pegrev.IsValid())\r
1183             m_pegrev = m_startrev;\r
1184     size_t startcount = m_logEntries.size();\r
1185     m_lowestRev = -1;\r
1186     m_bStrictStopped = false;\r
1187 \r
1188     if (succeeded)\r
1189     {\r
1190         succeeded = ReceiveLog (CTGitPathList(m_path), m_pegrev, m_startrev, m_endrev, m_limit, m_bStrict, m_bIncludeMerges, refresh);\r
1191         if ((!succeeded)&&(!m_path.IsUrl()))\r
1192         {\r
1193                 // try again with REV_WC as the start revision, just in case the path doesn't\r
1194                 // exist anymore in HEAD\r
1195                 succeeded = ReceiveLog(CTGitPathList(m_path), GitRev(), GitRev::REV_WC, m_endrev, m_limit, m_bStrict, m_bIncludeMerges, refresh);\r
1196         }\r
1197     }\r
1198         m_LogList.ClearText();\r
1199     if (!succeeded)\r
1200         {\r
1201                 m_LogList.ShowText(GetLastErrorMessage(), true);\r
1202         }\r
1203         else\r
1204         {\r
1205                 if (!m_wcRev.IsValid())\r
1206                 {\r
1207                         // fetch the revision the wc path is on so we can mark it\r
1208                         CTGitPath revWCPath = m_ProjectProperties.GetPropsPath();\r
1209                         if (!m_path.IsUrl())\r
1210                                 revWCPath = m_path;\r
1211                         if (DWORD(CRegDWORD(_T("Software\\TortoiseGit\\RecursiveLogRev"), FALSE)))\r
1212                         {\r
1213                                 git_revnum_t minrev, maxrev;\r
1214                                 bool switched, modified, sparse;\r
1215                                 GetWCRevisionStatus(revWCPath, true, minrev, maxrev, switched, modified, sparse);\r
1216                                 if (maxrev)\r
1217                                         m_wcRev = maxrev;\r
1218                         }\r
1219                         else\r
1220                         {\r
1221                                 CTGitPath dummypath;\r
1222                                 GitStatus status;\r
1223                                 git_wc_status2_t * stat = status.GetFirstFileStatus(revWCPath, dummypath, false, git_depth_empty);\r
1224                                 if (stat && stat->entry && stat->entry->cmt_rev)\r
1225                                         m_wcRev = stat->entry->cmt_rev;\r
1226                                 if (stat && stat->entry && (stat->entry->kind == git_node_dir))\r
1227                                         m_wcRev = stat->entry->revision;\r
1228                         }\r
1229                 }\r
1230         }\r
1231     if (m_bStrict && (m_lowestRev>1) && ((m_limit>0) ? ((startcount + m_limit)>m_logEntries.size()) : (m_endrev<m_lowestRev)))\r
1232                 m_bStrictStopped = true;\r
1233         m_LogList.SetItemCountEx(ShownCountWithStopped());\r
1234 \r
1235         m_timFrom = (__time64_t(m_tFrom));\r
1236         m_timTo = (__time64_t(m_tTo));\r
1237         m_DateFrom.SetRange(&m_timFrom, &m_timTo);\r
1238         m_DateTo.SetRange(&m_timFrom, &m_timTo);\r
1239         m_DateFrom.SetTime(&m_timFrom);\r
1240         m_DateTo.SetTime(&m_timTo);\r
1241 #endif\r
1242         DialogEnableWindow(IDC_GETALL, TRUE);\r
1243         m_LogList.ClearText();\r
1244 \r
1245         this->m_logEntries.ClearAll();\r
1246         this->m_logEntries.ParserFromLog();\r
1247         m_LogList.SetItemCountEx(this->m_logEntries.size());\r
1248 \r
1249         this->m_arShownList.RemoveAll();\r
1250 \r
1251         for(int i=0;i<m_logEntries.size();i++)\r
1252                 this->m_arShownList.Add(&m_logEntries[i]);\r
1253         \r
1254 #if 0   \r
1255         if (!m_bShowedAll)\r
1256                 DialogEnableWindow(IDC_NEXTHUNDRED, TRUE);\r
1257 #endif\r
1258         DialogEnableWindow(IDC_CHECK_STOPONCOPY, TRUE);\r
1259         DialogEnableWindow(IDC_INCLUDEMERGE, TRUE);\r
1260         DialogEnableWindow(IDC_STATBUTTON, TRUE);\r
1261         DialogEnableWindow(IDC_REFRESH, TRUE);\r
1262 \r
1263 #if 0\r
1264         LogCache::CRepositoryInfo& cachedProperties = logCachePool.GetRepositoryInfo();\r
1265         SetDlgTitle(cachedProperties.IsOffline (m_sUUID, m_sRepositoryRoot, false));\r
1266 \r
1267         GetDlgItem(IDC_PROGRESS)->ShowWindow(FALSE);\r
1268         m_bCancelled = true;\r
1269 #endif\r
1270         InterlockedExchange(&m_bThreadRunning, FALSE);\r
1271         m_LogList.RedrawItems(0, m_arShownList.GetCount());\r
1272         m_LogList.SetRedraw(false);\r
1273         ResizeAllListCtrlCols();\r
1274         m_LogList.SetRedraw(true);\r
1275         if ( m_pStoreSelection )\r
1276         {\r
1277                 // Deleting the instance will restore the\r
1278                 // selection of the CLogDlg.\r
1279                 delete m_pStoreSelection;\r
1280                 m_pStoreSelection = NULL;\r
1281         }\r
1282         else\r
1283         {\r
1284                 // If no selection has been set then this must be the first time\r
1285                 // the revisions are shown. Let's preselect the topmost revision.\r
1286                 if ( m_LogList.GetItemCount()>0 )\r
1287                 {\r
1288                         m_LogList.SetSelectionMark(0);\r
1289                         m_LogList.SetItemState(0, LVIS_SELECTED, LVIS_SELECTED);\r
1290                 }\r
1291         }\r
1292 \r
1293         if (!GetDlgItem(IDOK)->IsWindowVisible())\r
1294         {\r
1295                 temp.LoadString(IDS_MSGBOX_OK);\r
1296                 SetDlgItemText(IDCANCEL, temp);\r
1297         }\r
1298 \r
1299         RefreshCursor();\r
1300         // make sure the filter is applied (if any) now, after we refreshed/fetched\r
1301         // the log messages\r
1302         PostMessage(WM_TIMER, LOGFILTER_TIMER);\r
1303 \r
1304         return 0;\r
1305 }\r
1306 \r
1307 void CLogDlg::CopySelectionToClipBoard()\r
1308 {\r
1309 #if 0\r
1310         CString sClipdata;\r
1311         POSITION pos = m_LogList.GetFirstSelectedItemPosition();\r
1312         if (pos != NULL)\r
1313         {\r
1314                 CString sRev;\r
1315                 sRev.LoadString(IDS_LOG_REVISION);\r
1316                 CString sAuthor;\r
1317                 sAuthor.LoadString(IDS_LOG_AUTHOR);\r
1318                 CString sDate;\r
1319                 sDate.LoadString(IDS_LOG_DATE);\r
1320                 CString sMessage;\r
1321                 sMessage.LoadString(IDS_LOG_MESSAGE);\r
1322                 while (pos)\r
1323                 {\r
1324                         CString sLogCopyText;\r
1325                         CString sPaths;\r
1326                         PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(m_LogList.GetNextSelectedItem(pos)));\r
1327                         LogChangedPathArray * cpatharray = pLogEntry->pArChangedPaths;\r
1328                         for (INT_PTR cpPathIndex = 0; cpPathIndex<cpatharray->GetCount(); ++cpPathIndex)\r
1329                         {\r
1330                                 LogChangedPath * cpath = cpatharray->GetAt(cpPathIndex);\r
1331                                 sPaths += cpath->GetAction() + _T(" : ") + cpath->sPath;\r
1332                                 if (cpath->sCopyFromPath.IsEmpty())\r
1333                                         sPaths += _T("\r\n");\r
1334                                 else\r
1335                                 {\r
1336                                         CString sCopyFrom;\r
1337                                         sCopyFrom.Format(_T(" (%s: %s, %s, %ld)\r\n"), CString(MAKEINTRESOURCE(IDS_LOG_COPYFROM)), \r
1338                                                 (LPCTSTR)cpath->sCopyFromPath, \r
1339                                                 (LPCTSTR)CString(MAKEINTRESOURCE(IDS_LOG_REVISION)), \r
1340                                                 (LPCTSTR)cpath->lCopyFromRev);\r
1341                                         sPaths += sCopyFrom;\r
1342                                 }\r
1343                         }\r
1344                         sPaths.Trim();\r
1345                         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
1346                                 (LPCTSTR)sRev, pLogEntry->Rev,\r
1347                                 (LPCTSTR)sAuthor, (LPCTSTR)pLogEntry->sAuthor,\r
1348                                 (LPCTSTR)sDate, (LPCTSTR)pLogEntry->sDate,\r
1349                                 (LPCTSTR)sMessage, (LPCTSTR)pLogEntry->sMessage,\r
1350                                 (LPCTSTR)sPaths);\r
1351                         sClipdata +=  sLogCopyText;\r
1352                 }\r
1353                 CStringUtils::WriteAsciiStringToClipboard(sClipdata, GetSafeHwnd());\r
1354         }\r
1355 #endif\r
1356 }\r
1357 \r
1358 void CLogDlg::CopyChangedSelectionToClipBoard()\r
1359 {\r
1360 #if 0\r
1361         POSITION pos = m_LogList.GetFirstSelectedItemPosition();\r
1362         if (pos == NULL)\r
1363                 return; // nothing is selected, get out of here\r
1364 \r
1365         CString sPaths;\r
1366 \r
1367         PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(m_LogList.GetNextSelectedItem(pos)));\r
1368         if (pos)\r
1369         {\r
1370                 POSITION pos = m_ChangedFileListCtrl.GetFirstSelectedItemPosition();\r
1371                 while (pos)\r
1372                 {\r
1373                         int nItem = m_ChangedFileListCtrl.GetNextSelectedItem(pos);\r
1374                         sPaths += m_currentChangedPathList[nItem].GetGitPathString();\r
1375                         sPaths += _T("\r\n");\r
1376                 }\r
1377         }\r
1378         else\r
1379         {\r
1380                 // only one revision is selected in the log dialog top pane\r
1381                 // but multiple items could be selected  in the changed items list\r
1382                 POSITION pos = m_ChangedFileListCtrl.GetFirstSelectedItemPosition();\r
1383                 while (pos)\r
1384                 {\r
1385                         int nItem = m_ChangedFileListCtrl.GetNextSelectedItem(pos);\r
1386                         LogChangedPath * changedlogpath = pLogEntry->pArChangedPaths->GetAt(nItem);\r
1387 \r
1388                         if ((m_cHidePaths.GetState() & 0x0003)==BST_CHECKED)\r
1389                         {\r
1390                                 // some items are hidden! So find out which item the user really selected\r
1391                                 INT_PTR selRealIndex = -1;\r
1392                                 for (INT_PTR hiddenindex=0; hiddenindex<pLogEntry->pArChangedPaths->GetCount(); ++hiddenindex)\r
1393                                 {\r
1394                                         if (pLogEntry->pArChangedPaths->GetAt(hiddenindex)->sPath.Left(m_sRelativeRoot.GetLength()).Compare(m_sRelativeRoot)==0)\r
1395                                                 selRealIndex++;\r
1396                                         if (selRealIndex == nItem)\r
1397                                         {\r
1398                                                 changedlogpath = pLogEntry->pArChangedPaths->GetAt(hiddenindex);\r
1399                                                 break;\r
1400                                         }\r
1401                                 }\r
1402                         }\r
1403                         if (changedlogpath)\r
1404                         {\r
1405                                 sPaths += changedlogpath->sPath;\r
1406                                 sPaths += _T("\r\n");\r
1407                         }\r
1408                 }\r
1409         }\r
1410         sPaths.Trim();\r
1411         CStringUtils::WriteAsciiStringToClipboard(sPaths, GetSafeHwnd());\r
1412 #endif\r
1413 }\r
1414 \r
1415 BOOL CLogDlg::IsDiffPossible(LogChangedPath * changedpath, git_revnum_t rev)\r
1416 {\r
1417 #if 0\r
1418         CString added, deleted;\r
1419         if (changedpath == NULL)\r
1420                 return false;\r
1421 \r
1422         if ((rev > 1)&&(changedpath->action != LOGACTIONS_DELETED))\r
1423         {\r
1424                 if (changedpath->action == LOGACTIONS_ADDED) // file is added\r
1425                 {\r
1426                         if (changedpath->lCopyFromRev == 0)\r
1427                                 return FALSE; // but file was not added with history\r
1428                 }\r
1429                 return TRUE;\r
1430         }\r
1431 #endif\r
1432         return FALSE;\r
1433 }\r
1434 \r
1435 void CLogDlg::OnContextMenu(CWnd* pWnd, CPoint point)\r
1436 {\r
1437         // we have two separate context menus:\r
1438         // one shown on the log message list control,\r
1439         // the other shown in the changed-files list control\r
1440         int selCount = m_LogList.GetSelectedCount();\r
1441         if (pWnd == &m_LogList)\r
1442         {\r
1443                 ShowContextMenuForRevisions(pWnd, point);\r
1444         }\r
1445         else if (pWnd == &m_ChangedFileListCtrl)\r
1446         {\r
1447                 ShowContextMenuForChangedpaths(pWnd, point);\r
1448         }\r
1449         else if ((selCount == 1)&&(pWnd == GetDlgItem(IDC_MSGVIEW)))\r
1450         {\r
1451                 POSITION pos = m_LogList.GetFirstSelectedItemPosition();\r
1452                 int selIndex = -1;\r
1453                 if (pos)\r
1454                         selIndex = m_LogList.GetNextSelectedItem(pos);\r
1455                 if ((point.x == -1) && (point.y == -1))\r
1456                 {\r
1457                         CRect rect;\r
1458                         GetDlgItem(IDC_MSGVIEW)->GetClientRect(&rect);\r
1459                         ClientToScreen(&rect);\r
1460                         point = rect.CenterPoint();\r
1461                 }\r
1462                 CString sMenuItemText;\r
1463                 CMenu popup;\r
1464                 if (popup.CreatePopupMenu())\r
1465                 {\r
1466                         // add the 'default' entries\r
1467                         sMenuItemText.LoadString(IDS_SCIEDIT_COPY);\r
1468                         popup.AppendMenu(MF_STRING | MF_ENABLED, WM_COPY, sMenuItemText);\r
1469                         sMenuItemText.LoadString(IDS_SCIEDIT_SELECTALL);\r
1470                         popup.AppendMenu(MF_STRING | MF_ENABLED, EM_SETSEL, sMenuItemText);\r
1471 \r
1472                         if (selIndex >= 0)\r
1473                         {\r
1474                                 popup.AppendMenu(MF_SEPARATOR);\r
1475                                 sMenuItemText.LoadString(IDS_LOG_POPUP_EDITLOG);\r
1476                                 popup.AppendMenu(MF_STRING | MF_ENABLED, ID_EDITAUTHOR, sMenuItemText);\r
1477                         }\r
1478 \r
1479                         int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this, 0);\r
1480                         switch (cmd)\r
1481                         {\r
1482                         case 0:\r
1483                                 break;  // no command selected\r
1484                         case EM_SETSEL:\r
1485                         case WM_COPY:\r
1486                                 ::SendMessage(GetDlgItem(IDC_MSGVIEW)->GetSafeHwnd(), cmd, 0, -1);\r
1487                                 break;\r
1488                         case ID_EDITAUTHOR:\r
1489                                 EditLogMessage(selIndex);\r
1490                                 break;\r
1491                         }\r
1492                 }\r
1493         }\r
1494 }\r
1495 \r
1496 bool CLogDlg::IsSelectionContinuous()\r
1497 {\r
1498         if ( m_LogList.GetSelectedCount()==1 )\r
1499         {\r
1500                 // if only one revision is selected, the selection is of course\r
1501                 // continuous\r
1502                 return true;\r
1503         }\r
1504 \r
1505         POSITION pos = m_LogList.GetFirstSelectedItemPosition();\r
1506         bool bContinuous = (m_arShownList.GetCount() == (INT_PTR)m_logEntries.size());\r
1507         if (bContinuous)\r
1508         {\r
1509                 int itemindex = m_LogList.GetNextSelectedItem(pos);\r
1510                 while (pos)\r
1511                 {\r
1512                         int nextindex = m_LogList.GetNextSelectedItem(pos);\r
1513                         if (nextindex - itemindex > 1)\r
1514                         {\r
1515                                 bContinuous = false;\r
1516                                 break;\r
1517                         }\r
1518                         itemindex = nextindex;\r
1519                 }\r
1520         }\r
1521         return bContinuous;\r
1522 }\r
1523 \r
1524 LRESULT CLogDlg::OnFindDialogMessage(WPARAM /*wParam*/, LPARAM /*lParam*/)\r
1525 {\r
1526 #if 0\r
1527     ASSERT(m_pFindDialog != NULL);\r
1528 \r
1529     if (m_pFindDialog->IsTerminating())\r
1530     {\r
1531             // invalidate the handle identifying the dialog box.\r
1532         m_pFindDialog = NULL;\r
1533         return 0;\r
1534     }\r
1535 \r
1536     if(m_pFindDialog->FindNext())\r
1537     {\r
1538         //read data from dialog\r
1539         CString FindText = m_pFindDialog->GetFindString();\r
1540         bool bMatchCase = (m_pFindDialog->MatchCase() == TRUE);\r
1541                 bool bFound = false;\r
1542                 tr1::wregex pat;\r
1543                 bool bRegex = ValidateRegexp(FindText, pat, bMatchCase);\r
1544 \r
1545                 tr1::regex_constants::match_flag_type flags = tr1::regex_constants::match_not_null;\r
1546 \r
1547                 int i;\r
1548                 for (i = this->m_nSearchIndex; i<m_arShownList.GetCount()&&!bFound; i++)\r
1549                 {\r
1550                         if (bRegex)\r
1551                         {\r
1552                                 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(i));\r
1553 \r
1554                                 if (regex_search(wstring((LPCTSTR)pLogEntry->sMessage), pat, flags))\r
1555                                 {\r
1556                                         bFound = true;\r
1557                                         break;\r
1558                                 }\r
1559                                 LogChangedPathArray * cpatharray = pLogEntry->pArChangedPaths;\r
1560                                 for (INT_PTR cpPathIndex = 0; cpPathIndex<cpatharray->GetCount(); ++cpPathIndex)\r
1561                                 {\r
1562                                         LogChangedPath * cpath = cpatharray->GetAt(cpPathIndex);\r
1563                                         if (regex_search(wstring((LPCTSTR)cpath->sCopyFromPath), pat, flags))\r
1564                                         {\r
1565                                                 bFound = true;\r
1566                                                 --i;\r
1567                                                 break;\r
1568                                         }\r
1569                                         if (regex_search(wstring((LPCTSTR)cpath->sPath), pat, flags))\r
1570                                         {\r
1571                                                 bFound = true;\r
1572                                                 --i;\r
1573                                                 break;\r
1574                                         }\r
1575                                 }\r
1576                         }\r
1577                         else\r
1578                         {\r
1579                                 if (bMatchCase)\r
1580                                 {\r
1581                                         if (m_logEntries[i]->sMessage.Find(FindText) >= 0)\r
1582                                         {\r
1583                                                 bFound = true;\r
1584                                                 break;\r
1585                                         }\r
1586                                         PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(i));\r
1587                                         LogChangedPathArray * cpatharray = pLogEntry->pArChangedPaths;\r
1588                                         for (INT_PTR cpPathIndex = 0; cpPathIndex<cpatharray->GetCount(); ++cpPathIndex)\r
1589                                         {\r
1590                                                 LogChangedPath * cpath = cpatharray->GetAt(cpPathIndex);\r
1591                                                 if (cpath->sCopyFromPath.Find(FindText)>=0)\r
1592                                                 {\r
1593                                                         bFound = true;\r
1594                                                         --i;\r
1595                                                         break;\r
1596                                                 }\r
1597                                                 if (cpath->sPath.Find(FindText)>=0)\r
1598                                                 {\r
1599                                                         bFound = true;\r
1600                                                         --i;\r
1601                                                         break;\r
1602                                                 }\r
1603                                         }\r
1604                                 }\r
1605                                 else\r
1606                                 {\r
1607                                     PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(i));\r
1608                                         CString msg = pLogEntry->sMessage;\r
1609                                         msg = msg.MakeLower();\r
1610                                         CString find = FindText.MakeLower();\r
1611                                         if (msg.Find(find) >= 0)\r
1612                                         {\r
1613                                                 bFound = TRUE;\r
1614                                                 break;\r
1615                                         }\r
1616                                         LogChangedPathArray * cpatharray = pLogEntry->pArChangedPaths;\r
1617                                         for (INT_PTR cpPathIndex = 0; cpPathIndex<cpatharray->GetCount(); ++cpPathIndex)\r
1618                                         {\r
1619                                                 LogChangedPath * cpath = cpatharray->GetAt(cpPathIndex);\r
1620                                                 CString lowerpath = cpath->sCopyFromPath;\r
1621                                                 lowerpath.MakeLower();\r
1622                                                 if (lowerpath.Find(find)>=0)\r
1623                                                 {\r
1624                                                         bFound = TRUE;\r
1625                                                         --i;\r
1626                                                         break;\r
1627                                                 }\r
1628                                                 lowerpath = cpath->sPath;\r
1629                                                 lowerpath.MakeLower();\r
1630                                                 if (lowerpath.Find(find)>=0)\r
1631                                                 {\r
1632                                                         bFound = TRUE;\r
1633                                                         --i;\r
1634                                                         break;\r
1635                                                 }\r
1636                                         }\r
1637                                 } \r
1638                         }\r
1639                 } // for (i = this->m_nSearchIndex; i<m_arShownList.GetItemCount()&&!bFound; i++)\r
1640                 if (bFound)\r
1641                 {\r
1642                         this->m_nSearchIndex = (i+1);\r
1643                         m_LogList.EnsureVisible(i, FALSE);\r
1644                         m_LogList.SetItemState(m_LogList.GetSelectionMark(), 0, LVIS_SELECTED);\r
1645                         m_LogList.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);\r
1646                         m_LogList.SetSelectionMark(i);\r
1647                         FillLogMessageCtrl();\r
1648                         UpdateData(FALSE);\r
1649                         m_nSearchIndex++;\r
1650                         if (m_nSearchIndex >= m_arShownList.GetCount())\r
1651                                 m_nSearchIndex = (int)m_arShownList.GetCount()-1;\r
1652                 }\r
1653     } // if(m_pFindDialog->FindNext()) \r
1654         UpdateLogInfoLabel();\r
1655 #endif\r
1656     return 0;\r
1657 }\r
1658 \r
1659 void CLogDlg::OnOK()\r
1660 {\r
1661 #if 0 \r
1662         // since the log dialog is also used to select revisions for other\r
1663         // dialogs, we have to do some work before closing this dialog\r
1664         if (GetFocus() != GetDlgItem(IDOK))\r
1665                 return; // if the "OK" button doesn't have the focus, do nothing: this prevents closing the dialog when pressing enter\r
1666         if (!GetDlgItem(IDOK)->IsWindowVisible() && GetFocus() != GetDlgItem(IDCANCEL))\r
1667                 return; // the Cancel button works as the OK button. But if the cancel button has not the focus, do nothing.\r
1668 \r
1669         CString temp;\r
1670         CString buttontext;\r
1671         GetDlgItemText(IDOK, buttontext);\r
1672         temp.LoadString(IDS_MSGBOX_CANCEL);\r
1673         if (temp.Compare(buttontext) != 0)\r
1674                 __super::OnOK();        // only exit if the button text matches, and that will match only if the thread isn't running anymore\r
1675         m_bCancelled = TRUE;\r
1676         m_selectedRevs.Clear();\r
1677         m_selectedRevsOneRange.Clear();\r
1678         if (m_pNotifyWindow)\r
1679         {\r
1680                 int selIndex = m_LogList.GetSelectionMark();\r
1681                 if (selIndex >= 0)\r
1682                 {       \r
1683                     PLOGENTRYDATA pLogEntry = NULL;\r
1684                         POSITION pos = m_LogList.GetFirstSelectedItemPosition();\r
1685                         pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(m_LogList.GetNextSelectedItem(pos)));\r
1686                         m_selectedRevs.AddRevision(pLogEntry->Rev);\r
1687                         git_revnum_t lowerRev = pLogEntry->Rev;\r
1688                         git_revnum_t higherRev = lowerRev;\r
1689                         while (pos)\r
1690                         {\r
1691                             pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(m_LogList.GetNextSelectedItem(pos)));\r
1692                                 git_revnum_t rev = pLogEntry->Rev;\r
1693                                 m_selectedRevs.AddRevision(pLogEntry->Rev);\r
1694                                 if (lowerRev > rev)\r
1695                                         lowerRev = rev;\r
1696                                 if (higherRev < rev)\r
1697                                         higherRev = rev;\r
1698                         }\r
1699                         if (m_sFilterText.IsEmpty() && m_nSortColumn == 0 && IsSelectionContinuous())\r
1700                         {\r
1701                                 m_selectedRevsOneRange.AddRevRange(lowerRev, higherRev);\r
1702                         }\r
1703                         BOOL bSentMessage = FALSE;\r
1704                         if (m_LogList.GetSelectedCount() == 1)\r
1705                         {\r
1706                                 // if only one revision is selected, check if the path/url with which the dialog was started\r
1707                                 // was directly affected in that revision. If it was, then check if our path was copied from somewhere.\r
1708                                 // if it was copied, use the copy from revision as lowerRev\r
1709                                 if ((pLogEntry)&&(pLogEntry->pArChangedPaths)&&(lowerRev == higherRev))\r
1710                                 {\r
1711                                         CString sUrl = m_path.GetGitPathString();\r
1712                                         if (!m_path.IsUrl())\r
1713                                         {\r
1714                                                 sUrl = GetURLFromPath(m_path);\r
1715                                         }\r
1716                                         sUrl = sUrl.Mid(m_sRepositoryRoot.GetLength());\r
1717                                         for (int cp = 0; cp < pLogEntry->pArChangedPaths->GetCount(); ++cp)\r
1718                                         {\r
1719                                                 LogChangedPath * pData = pLogEntry->pArChangedPaths->GetAt(cp);\r
1720                                                 if (pData)\r
1721                                                 {\r
1722                                                         if (sUrl.Compare(pData->sPath) == 0)\r
1723                                                         {\r
1724                                                                 if (!pData->sCopyFromPath.IsEmpty())\r
1725                                                                 {\r
1726                                                                         lowerRev = pData->lCopyFromRev;\r
1727                                                                         m_pNotifyWindow->SendMessage(WM_REVSELECTED, m_wParam & (MERGE_REVSELECTSTART), lowerRev);\r
1728                                                                         m_pNotifyWindow->SendMessage(WM_REVSELECTED, m_wParam & (MERGE_REVSELECTEND), higherRev);\r
1729                                                                         m_pNotifyWindow->SendMessage(WM_REVLIST, m_selectedRevs.GetCount(), (LPARAM)&m_selectedRevs);\r
1730                                                                         bSentMessage = TRUE;\r
1731                                                                 }\r
1732                                                         }\r
1733                                                 }\r
1734                                         }\r
1735                                 }\r
1736                         }\r
1737                         if ( !bSentMessage )\r
1738                         {\r
1739                                 m_pNotifyWindow->SendMessage(WM_REVSELECTED, m_wParam & (MERGE_REVSELECTSTART | MERGE_REVSELECTMINUSONE), lowerRev);\r
1740                                 m_pNotifyWindow->SendMessage(WM_REVSELECTED, m_wParam & (MERGE_REVSELECTEND | MERGE_REVSELECTMINUSONE), higherRev);\r
1741                                 m_pNotifyWindow->SendMessage(WM_REVLIST, m_selectedRevs.GetCount(), (LPARAM)&m_selectedRevs);\r
1742                                 if (m_selectedRevsOneRange.GetCount())\r
1743                                         m_pNotifyWindow->SendMessage(WM_REVLISTONERANGE, 0, (LPARAM)&m_selectedRevsOneRange);\r
1744                         }\r
1745                 }\r
1746         }\r
1747         UpdateData();\r
1748         if (m_bSaveStrict)\r
1749                 m_regLastStrict = m_bStrict;\r
1750         CRegDWORD reg = CRegDWORD(_T("Software\\TortoiseGit\\ShowAllEntry"));\r
1751         reg = m_btnShow.GetCurrentEntry();\r
1752         SaveSplitterPos();\r
1753 #endif \r
1754 }\r
1755 \r
1756 void CLogDlg::OnNMDblclkChangedFileList(NMHDR * /*pNMHDR*/, LRESULT *pResult)\r
1757 {\r
1758         // a double click on an entry in the changed-files list has happened\r
1759         *pResult = 0;\r
1760 \r
1761         DiffSelectedFile();\r
1762 }\r
1763 \r
1764 void CLogDlg::DiffSelectedFile()\r
1765 {\r
1766 #if 0\r
1767         if (m_bThreadRunning)\r
1768                 return;\r
1769         UpdateLogInfoLabel();\r
1770         INT_PTR selIndex = m_ChangedFileListCtrl.GetSelectionMark();\r
1771         if (selIndex < 0)\r
1772                 return;\r
1773         if (m_ChangedFileListCtrl.GetSelectedCount() == 0)\r
1774                 return;\r
1775         // find out if there's an entry selected in the log list\r
1776         POSITION pos = m_LogList.GetFirstSelectedItemPosition();\r
1777         PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(m_LogList.GetNextSelectedItem(pos)));\r
1778         git_revnum_t rev1 = pLogEntry->Rev;\r
1779         git_revnum_t rev2 = rev1;\r
1780         if (pos)\r
1781         {\r
1782                 while (pos)\r
1783                 {\r
1784                         // there's at least a second entry selected in the log list: several revisions selected!\r
1785                         pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(m_LogList.GetNextSelectedItem(pos)));\r
1786                         if (pLogEntry)\r
1787                         {\r
1788                                 rev1 = max(rev1,(long)pLogEntry->Rev);\r
1789                                 rev2 = min(rev2,(long)pLogEntry->Rev);\r
1790                         }\r
1791                 }\r
1792                 rev2--;\r
1793                 // now we have both revisions selected in the log list, so we can do a diff of the selected\r
1794                 // entry in the changed files list with these two revisions.\r
1795                 DoDiffFromLog(selIndex, rev1, rev2, false, false);\r
1796         }\r
1797         else\r
1798         {\r
1799                 rev2 = rev1-1;\r
1800                 // nothing or only one revision selected in the log list\r
1801                 LogChangedPath * changedpath = pLogEntry->pArChangedPaths->GetAt(selIndex);\r
1802 \r
1803                 if ((m_cHidePaths.GetState() & 0x0003)==BST_CHECKED)\r
1804                 {\r
1805                         // some items are hidden! So find out which item the user really clicked on\r
1806                         INT_PTR selRealIndex = -1;\r
1807                         for (INT_PTR hiddenindex=0; hiddenindex<pLogEntry->pArChangedPaths->GetCount(); ++hiddenindex)\r
1808                         {\r
1809                                 if (pLogEntry->pArChangedPaths->GetAt(hiddenindex)->sPath.Left(m_sRelativeRoot.GetLength()).Compare(m_sRelativeRoot)==0)\r
1810                                         selRealIndex++;\r
1811                                 if (selRealIndex == selIndex)\r
1812                                 {\r
1813                                         selIndex = hiddenindex;\r
1814                                         changedpath = pLogEntry->pArChangedPaths->GetAt(selIndex);\r
1815                                         break;\r
1816                                 }\r
1817                         }\r
1818                 }\r
1819 \r
1820                 if (IsDiffPossible(changedpath, rev1))\r
1821                 {\r
1822                         // diffs with renamed files are possible\r
1823                         if ((changedpath)&&(!changedpath->sCopyFromPath.IsEmpty()))\r
1824                                 rev2 = changedpath->lCopyFromRev;\r
1825                         else\r
1826                         {\r
1827                                 // if the path was modified but the parent path was 'added with history'\r
1828                                 // then we have to use the copy from revision of the parent path\r
1829                                 CTGitPath cpath = CTGitPath(changedpath->sPath);\r
1830                                 for (int flist = 0; flist < pLogEntry->pArChangedPaths->GetCount(); ++flist)\r
1831                                 {\r
1832                                         CTGitPath p = CTGitPath(pLogEntry->pArChangedPaths->GetAt(flist)->sPath);\r
1833                                         if (p.IsAncestorOf(cpath))\r
1834                                         {\r
1835                                                 if (!pLogEntry->pArChangedPaths->GetAt(flist)->sCopyFromPath.IsEmpty())\r
1836                                                         rev2 = pLogEntry->pArChangedPaths->GetAt(flist)->lCopyFromRev;\r
1837                                         }\r
1838                                 }\r
1839                         }\r
1840                         DoDiffFromLog(selIndex, rev1, rev2, false, false);\r
1841                 }\r
1842                 else \r
1843                 {\r
1844                         CTGitPath tempfile = CTempFiles::Instance().GetTempFilePath(false, CTGitPath(changedpath->sPath));\r
1845                         CTGitPath tempfile2 = CTempFiles::Instance().GetTempFilePath(false, CTGitPath(changedpath->sPath));\r
1846                         GitRev r = rev1;\r
1847                         // deleted files must be opened from the revision before the deletion\r
1848                         if (changedpath->action == LOGACTIONS_DELETED)\r
1849                                 r = rev1-1;\r
1850                         m_bCancelled = false;\r
1851 \r
1852                         CProgressDlg progDlg;\r
1853                         progDlg.SetTitle(IDS_APPNAME);\r
1854                         progDlg.SetAnimation(IDR_DOWNLOAD);\r
1855                         CString sInfoLine;\r
1856                         sInfoLine.Format(IDS_PROGRESSGETFILEREVISION, (LPCTSTR)(m_sRepositoryRoot + changedpath->sPath), (LPCTSTR)r.ToString());\r
1857                         progDlg.SetLine(1, sInfoLine, true);\r
1858                         SetAndClearProgressInfo(&progDlg);\r
1859                         progDlg.ShowModeless(m_hWnd);\r
1860 \r
1861                         if (!Cat(CTGitPath(m_sRepositoryRoot + changedpath->sPath), r, r, tempfile))\r
1862                         {\r
1863                                 m_bCancelled = false;\r
1864                                 if (!Cat(CTGitPath(m_sRepositoryRoot + changedpath->sPath), GitRev::REV_HEAD, r, tempfile))\r
1865                                 {\r
1866                                         progDlg.Stop();\r
1867                                         SetAndClearProgressInfo((HWND)NULL);\r
1868                                         CMessageBox::Show(m_hWnd, GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);\r
1869                                         return;\r
1870                                 }\r
1871                         }\r
1872                         progDlg.Stop();\r
1873                         SetAndClearProgressInfo((HWND)NULL);\r
1874 \r
1875                         CString sName1, sName2;\r
1876                         sName1.Format(_T("%s - Revision %ld"), (LPCTSTR)CPathUtils::GetFileNameFromPath(changedpath->sPath), (git_revnum_t)rev1);\r
1877                         sName2.Format(_T("%s - Revision %ld"), (LPCTSTR)CPathUtils::GetFileNameFromPath(changedpath->sPath), (git_revnum_t)rev1-1);\r
1878                         CAppUtils::DiffFlags flags;\r
1879                         flags.AlternativeTool(!!(GetAsyncKeyState(VK_SHIFT) & 0x8000));\r
1880                         if (changedpath->action == LOGACTIONS_DELETED)\r
1881                                 CAppUtils::StartExtDiff(tempfile, tempfile2, sName2, sName1, flags);\r
1882                         else\r
1883                                 CAppUtils::StartExtDiff(tempfile2, tempfile, sName2, sName1, flags);\r
1884                 }\r
1885         }\r
1886 #endif \r
1887 }\r
1888 \r
1889 \r
1890 void CLogDlg::OnNMDblclkLoglist(NMHDR * /*pNMHDR*/, LRESULT *pResult)\r
1891 {\r
1892         // a double click on an entry in the revision list has happened\r
1893         *pResult = 0;\r
1894 \r
1895   if (CRegDWORD(_T("Software\\TortoiseGit\\DiffByDoubleClickInLog"), FALSE))\r
1896           DiffSelectedRevWithPrevious();\r
1897 }\r
1898 \r
1899 void CLogDlg::DiffSelectedRevWithPrevious()\r
1900 {\r
1901 #if 0\r
1902         if (m_bThreadRunning)\r
1903                 return;\r
1904         UpdateLogInfoLabel();\r
1905         int selIndex = m_LogList.GetSelectionMark();\r
1906         if (selIndex < 0)\r
1907                 return;\r
1908         int selCount = m_LogList.GetSelectedCount();\r
1909         if (selCount != 1)\r
1910                 return;\r
1911 \r
1912         // Find selected entry in the log list\r
1913         POSITION pos = m_LogList.GetFirstSelectedItemPosition();\r
1914         PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(m_LogList.GetNextSelectedItem(pos)));\r
1915         long rev1 = pLogEntry->Rev;\r
1916         long rev2 = rev1-1;\r
1917         CTGitPath path = m_path;\r
1918 \r
1919         // See how many files under the relative root were changed in selected revision\r
1920         int nChanged = 0;\r
1921         LogChangedPath * changed = NULL;\r
1922         for (INT_PTR c = 0; c < pLogEntry->pArChangedPaths->GetCount(); ++c)\r
1923         {\r
1924                 LogChangedPath * cpath = pLogEntry->pArChangedPaths->GetAt(c);\r
1925                 if (cpath  &&  cpath -> sPath.Left(m_sRelativeRoot.GetLength()).Compare(m_sRelativeRoot)==0)\r
1926                 {\r
1927                         ++nChanged;\r
1928                         changed = cpath;\r
1929                 }\r
1930         }\r
1931 \r
1932         if (m_path.IsDirectory() && nChanged == 1) \r
1933         {\r
1934                 // We're looking at the log for a directory and only one file under dir was changed in the revision\r
1935                 // Do diff on that file instead of whole directory\r
1936                 path.AppendPathString(changed->sPath.Mid(m_sRelativeRoot.GetLength()));\r
1937         } \r
1938 \r
1939         m_bCancelled = FALSE;\r
1940         DialogEnableWindow(IDOK, FALSE);\r
1941         SetPromptApp(&theApp);\r
1942         theApp.DoWaitCursor(1);\r
1943 \r
1944         if (PromptShown())\r
1945         {\r
1946                 GitDiff diff(this, m_hWnd, true);\r
1947                 diff.SetAlternativeTool(!!(GetAsyncKeyState(VK_SHIFT) & 0x8000));\r
1948                 diff.SetHEADPeg(m_LogRevision);\r
1949                 diff.ShowCompare(path, rev2, path, rev1);\r
1950         }\r
1951         else\r
1952         {\r
1953                 CAppUtils::StartShowCompare(m_hWnd, path, rev2, path, rev1, GitRev(), m_LogRevision, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000));\r
1954         }\r
1955 \r
1956         theApp.DoWaitCursor(-1);\r
1957         EnableOKButton();\r
1958 #endif\r
1959 }\r
1960 \r
1961 void CLogDlg::DoDiffFromLog(INT_PTR selIndex, GitRev* rev1, GitRev* rev2, bool blame, bool unified)\r
1962 {\r
1963         DialogEnableWindow(IDOK, FALSE);\r
1964 //      SetPromptApp(&theApp);\r
1965         theApp.DoWaitCursor(1);\r
1966 \r
1967         CString temppath;\r
1968         GetTempPath(temppath);\r
1969         \r
1970         CString file1;\r
1971         file1.Format(_T("%s%s_%s%s"),\r
1972                                 temppath,                                               \r
1973                                 (*m_currentChangedArray)[selIndex].GetBaseFilename(),\r
1974                                 rev1->m_CommitHash.Left(6),\r
1975                                 (*m_currentChangedArray)[selIndex].GetFileExtension());\r
1976 \r
1977         CString file2;\r
1978         file2.Format(_T("%s\\%s_%s%s"),\r
1979                                 temppath,                                               \r
1980                                 (*m_currentChangedArray)[selIndex].GetBaseFilename(),\r
1981                                 rev2->m_CommitHash.Left(6),\r
1982                                 (*m_currentChangedArray)[selIndex].GetFileExtension());\r
1983 \r
1984         CString cmd;\r
1985 \r
1986         cmd.Format(_T("git.cmd cat-file -p %s:%s"),rev1->m_CommitHash,(*m_currentChangedArray)[selIndex].GetGitPathString());\r
1987         g_Git.RunLogFile(cmd,file1);\r
1988         cmd.Format(_T("git.cmd cat-file -p %s:%s"),rev2->m_CommitHash,(*m_currentChangedArray)[selIndex].GetGitPathString());\r
1989         g_Git.RunLogFile(cmd,file2);\r
1990 \r
1991         CAppUtils::DiffFlags flags;\r
1992         CAppUtils::StartExtDiff(file1,file2,_T("A"),_T("B"),flags);\r
1993 \r
1994 #if 0\r
1995         //get the filename\r
1996         CString filepath;\r
1997         if (Git::PathIsURL(m_path))\r
1998         {\r
1999                 filepath = m_path.GetGitPathString();\r
2000         }\r
2001         else\r
2002         {\r
2003                 filepath = GetURLFromPath(m_path);\r
2004                 if (filepath.IsEmpty())\r
2005                 {\r
2006                         theApp.DoWaitCursor(-1);\r
2007                         CString temp;\r
2008                         temp.Format(IDS_ERR_NOURLOFFILE, (LPCTSTR)filepath);\r
2009                         CMessageBox::Show(this->m_hWnd, temp, _T("TortoiseGit"), MB_ICONERROR);\r
2010                         TRACE(_T("could not retrieve the URL of the file!\n"));\r
2011                         EnableOKButton();\r
2012                         theApp.DoWaitCursor(-11);\r
2013                         return;         //exit\r
2014                 }\r
2015         }\r
2016         m_bCancelled = FALSE;\r
2017         filepath = GetRepositoryRoot(CTGitPath(filepath));\r
2018 \r
2019         CString firstfile, secondfile;\r
2020         if (m_LogList.GetSelectedCount()==1)\r
2021         {\r
2022                 int s = m_LogList.GetSelectionMark();\r
2023                 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(s));\r
2024                 LogChangedPath * changedpath = pLogEntry->pArChangedPaths->GetAt(selIndex);\r
2025                 firstfile = changedpath->sPath;\r
2026                 secondfile = firstfile;\r
2027                 if ((rev2 == rev1-1)&&(changedpath->lCopyFromRev > 0)) // is it an added file with history?\r
2028                 {\r
2029                         secondfile = changedpath->sCopyFromPath;\r
2030                         rev2 = changedpath->lCopyFromRev;\r
2031                 }\r
2032         }\r
2033         else\r
2034         {\r
2035                 firstfile = m_currentChangedPathList[selIndex].GetGitPathString();\r
2036                 secondfile = firstfile;\r
2037         }\r
2038 \r
2039         firstfile = filepath + firstfile.Trim();\r
2040         secondfile = filepath + secondfile.Trim();\r
2041 \r
2042         GitDiff diff(this, this->m_hWnd, true);\r
2043         diff.SetAlternativeTool(!!(GetAsyncKeyState(VK_SHIFT) & 0x8000));\r
2044         diff.SetHEADPeg(m_LogRevision);\r
2045         if (unified)\r
2046         {\r
2047                 if (PromptShown())\r
2048                         diff.ShowUnifiedDiff(CTGitPath(secondfile), rev2, CTGitPath(firstfile), rev1);\r
2049                 else\r
2050                         CAppUtils::StartShowUnifiedDiff(m_hWnd, CTGitPath(secondfile), rev2, CTGitPath(firstfile), rev1, GitRev(), m_LogRevision);\r
2051         }\r
2052         else\r
2053         {\r
2054                 if (diff.ShowCompare(CTGitPath(secondfile), rev2, CTGitPath(firstfile), rev1, GitRev(), false, blame))\r
2055                 {\r
2056                         if (firstfile.Compare(secondfile)==0)\r
2057                         {\r
2058                                 git_revnum_t baseRev = 0;\r
2059                                 diff.DiffProps(CTGitPath(firstfile), rev2, rev1, baseRev);\r
2060                         }\r
2061                 }\r
2062         }\r
2063 \r
2064 #endif\r
2065 \r
2066         theApp.DoWaitCursor(-1);\r
2067         EnableOKButton();\r
2068 }\r
2069 \r
2070 BOOL CLogDlg::Open(bool bOpenWith,CString changedpath, git_revnum_t rev)\r
2071 {\r
2072 #if 0\r
2073         DialogEnableWindow(IDOK, FALSE);\r
2074         SetPromptApp(&theApp);\r
2075         theApp.DoWaitCursor(1);\r
2076         CString filepath;\r
2077         if (Git::PathIsURL(m_path))\r
2078         {\r
2079                 filepath = m_path.GetGitPathString();\r
2080         }\r
2081         else\r
2082         {\r
2083                 filepath = GetURLFromPath(m_path);\r
2084                 if (filepath.IsEmpty())\r
2085                 {\r
2086                         theApp.DoWaitCursor(-1);\r
2087                         CString temp;\r
2088                         temp.Format(IDS_ERR_NOURLOFFILE, (LPCTSTR)filepath);\r
2089                         CMessageBox::Show(this->m_hWnd, temp, _T("TortoiseGit"), MB_ICONERROR);\r
2090                         TRACE(_T("could not retrieve the URL of the file!\n"));\r
2091                         EnableOKButton();\r
2092                         return FALSE;\r
2093                 }\r
2094         }\r
2095         m_bCancelled = false;\r
2096         filepath = GetRepositoryRoot(CTGitPath(filepath));\r
2097         filepath += changedpath;\r
2098 \r
2099         CProgressDlg progDlg;\r
2100         progDlg.SetTitle(IDS_APPNAME);\r
2101         progDlg.SetAnimation(IDR_DOWNLOAD);\r
2102         CString sInfoLine;\r
2103         sInfoLine.Format(IDS_PROGRESSGETFILEREVISION, (LPCTSTR)filepath, (LPCTSTR)GitRev(rev).ToString());\r
2104         progDlg.SetLine(1, sInfoLine, true);\r
2105         SetAndClearProgressInfo(&progDlg);\r
2106         progDlg.ShowModeless(m_hWnd);\r
2107 \r
2108         CTGitPath tempfile = CTempFiles::Instance().GetTempFilePath(false, CTGitPath(filepath), rev);\r
2109         m_bCancelled = false;\r
2110         if (!Cat(CTGitPath(filepath), GitRev(rev), rev, tempfile))\r
2111         {\r
2112                 progDlg.Stop();\r
2113                 SetAndClearProgressInfo((HWND)NULL);\r
2114                 CMessageBox::Show(this->m_hWnd, GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);\r
2115                 EnableOKButton();\r
2116                 theApp.DoWaitCursor(-1);\r
2117                 return FALSE;\r
2118         }\r
2119         progDlg.Stop();\r
2120         SetAndClearProgressInfo((HWND)NULL);\r
2121         SetFileAttributes(tempfile.GetWinPath(), FILE_ATTRIBUTE_READONLY);\r
2122         if (!bOpenWith)\r
2123         {\r
2124                 int ret = (int)ShellExecute(this->m_hWnd, NULL, tempfile.GetWinPath(), NULL, NULL, SW_SHOWNORMAL);\r
2125                 if (ret <= HINSTANCE_ERROR)\r
2126                         bOpenWith = true;\r
2127         }\r
2128         if (bOpenWith)\r
2129         {\r
2130                 CString cmd = _T("RUNDLL32 Shell32,OpenAs_RunDLL ");\r
2131                 cmd += tempfile.GetWinPathString() + _T(" ");\r
2132                 CAppUtils::LaunchApplication(cmd, NULL, false);\r
2133         }\r
2134         EnableOKButton();\r
2135         theApp.DoWaitCursor(-1);\r
2136 #endif\r
2137         return TRUE;\r
2138 }\r
2139 \r
2140 void CLogDlg::EditAuthor(const CLogDataVector& logs)\r
2141 {\r
2142 #if 0\r
2143         CString url;\r
2144         CString name;\r
2145         if (logs.size() == 0)\r
2146                 return;\r
2147         DialogEnableWindow(IDOK, FALSE);\r
2148         SetPromptApp(&theApp);\r
2149         theApp.DoWaitCursor(1);\r
2150         if (Git::PathIsURL(m_path))\r
2151                 url = m_path.GetGitPathString();\r
2152         else\r
2153         {\r
2154                 url = GetURLFromPath(m_path);\r
2155         }\r
2156         name = Git_PROP_REVISION_AUTHOR;\r
2157 \r
2158         CString value = RevPropertyGet(name, CTGitPath(url), logs[0]->Rev);\r
2159         CString sOldValue = value;\r
2160         value.Replace(_T("\n"), _T("\r\n"));\r
2161         CInputDlg dlg(this);\r
2162         dlg.m_sHintText.LoadString(IDS_LOG_AUTHOR);\r
2163         dlg.m_sInputText = value;\r
2164         dlg.m_sTitle.LoadString(IDS_LOG_AUTHOREDITTITLE);\r
2165         dlg.m_pProjectProperties = &m_ProjectProperties;\r
2166         dlg.m_bUseLogWidth = false;\r
2167         if (dlg.DoModal() == IDOK)\r
2168         {\r
2169                 dlg.m_sInputText.Replace(_T("\r"), _T(""));\r
2170 \r
2171                 LogCache::CCachedLogInfo* toUpdate \r
2172                         = GetLogCache (CTGitPath (m_sRepositoryRoot));\r
2173 \r
2174                 CProgressDlg progDlg;\r
2175                 progDlg.SetTitle(IDS_APPNAME);\r
2176                 progDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_PROGRESSWAIT)));\r
2177                 progDlg.SetTime(true);\r
2178                 progDlg.SetShowProgressBar(true);\r
2179                 progDlg.ShowModeless(m_hWnd);\r
2180                 for (DWORD i=0; i<logs.size(); ++i)\r
2181                 {\r
2182                         if (!RevPropertySet(name, dlg.m_sInputText, sOldValue, CTGitPath(url), logs[i]->Rev))\r
2183                         {\r
2184                                 progDlg.Stop();\r
2185                                 CMessageBox::Show(this->m_hWnd, GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);\r
2186                                 break;\r
2187                         }\r
2188                         else\r
2189                         {\r
2190 \r
2191                                 logs[i]->sAuthor = dlg.m_sInputText;\r
2192                                 m_LogList.Invalidate();\r
2193 \r
2194                                 // update the log cache \r
2195 \r
2196                                 if (toUpdate != NULL)\r
2197                                 {\r
2198                                         // log caching is active\r
2199 \r
2200                                         LogCache::CCachedLogInfo newInfo;\r
2201                                         newInfo.Insert ( logs[i]->Rev\r
2202                                                 , (const char*) CUnicodeUtils::GetUTF8 (logs[i]->sAuthor)\r
2203                                                 , ""\r
2204                                                 , 0\r
2205                                                 , LogCache::CRevisionInfoContainer::HAS_AUTHOR);\r
2206 \r
2207                                         toUpdate->Update (newInfo);\r
2208                                 }\r
2209                         }\r
2210                         progDlg.SetProgress64(i, logs.size());\r
2211                 }\r
2212                 progDlg.Stop();\r
2213         }\r
2214         theApp.DoWaitCursor(-1);\r
2215         EnableOKButton();\r
2216 #endif\r
2217 }\r
2218 \r
2219 void CLogDlg::EditLogMessage(int index)\r
2220 {\r
2221 #if 0\r
2222         CString url;\r
2223         CString name;\r
2224         DialogEnableWindow(IDOK, FALSE);\r
2225         SetPromptApp(&theApp);\r
2226         theApp.DoWaitCursor(1);\r
2227         if (Git::PathIsURL(m_path))\r
2228                 url = m_path.GetGitPathString();\r
2229         else\r
2230         {\r
2231                 url = GetURLFromPath(m_path);\r
2232         }\r
2233         name = Git_PROP_REVISION_LOG;\r
2234 \r
2235         PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(index));\r
2236         m_bCancelled = FALSE;\r
2237         CString value = RevPropertyGet(name, CTGitPath(url), pLogEntry->Rev);\r
2238         CString sOldValue = value;\r
2239         value.Replace(_T("\n"), _T("\r\n"));\r
2240         CInputDlg dlg(this);\r
2241         dlg.m_sHintText.LoadString(IDS_LOG_MESSAGE);\r
2242         dlg.m_sInputText = value;\r
2243         dlg.m_sTitle.LoadString(IDS_LOG_MESSAGEEDITTITLE);\r
2244         dlg.m_pProjectProperties = &m_ProjectProperties;\r
2245         dlg.m_bUseLogWidth = true;\r
2246         if (dlg.DoModal() == IDOK)\r
2247         {\r
2248                 dlg.m_sInputText.Replace(_T("\r"), _T(""));\r
2249                 if (!RevPropertySet(name, dlg.m_sInputText, sOldValue, CTGitPath(url), pLogEntry->Rev))\r
2250                 {\r
2251                         CMessageBox::Show(this->m_hWnd, GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);\r
2252                 }\r
2253                 else\r
2254                 {\r
2255                         pLogEntry->sShortMessage = MakeShortMessage(dlg.m_sInputText);\r
2256                         // split multi line log entries and concatenate them\r
2257                         // again but this time with \r\n as line separators\r
2258                         // so that the edit control recognizes them\r
2259                         if (dlg.m_sInputText.GetLength()>0)\r
2260                         {\r
2261                                 m_sMessageBuf = dlg.m_sInputText;\r
2262                                 dlg.m_sInputText.Replace(_T("\n\r"), _T("\n"));\r
2263                                 dlg.m_sInputText.Replace(_T("\r\n"), _T("\n"));\r
2264                                 if (dlg.m_sInputText.Right(1).Compare(_T("\n"))==0)\r
2265                                         dlg.m_sInputText = dlg.m_sInputText.Left(dlg.m_sInputText.GetLength()-1);\r
2266                         } \r
2267                         else\r
2268                                 dlg.m_sInputText.Empty();\r
2269                         pLogEntry->sMessage = dlg.m_sInputText;\r
2270                         pLogEntry->sBugIDs = m_ProjectProperties.FindBugID(dlg.m_sInputText);\r
2271                         CWnd * pMsgView = GetDlgItem(IDC_MSGVIEW);\r
2272                         pMsgView->SetWindowText(_T(" "));\r
2273                         pMsgView->SetWindowText(dlg.m_sInputText);\r
2274                         m_ProjectProperties.FindBugID(dlg.m_sInputText, pMsgView);\r
2275                         m_LogList.Invalidate();\r
2276         \r
2277             // update the log cache \r
2278 \r
2279             LogCache::CCachedLogInfo* toUpdate \r
2280                 = GetLogCache (CTGitPath (m_sRepositoryRoot));\r
2281             if (toUpdate != NULL)\r
2282             {\r
2283                 // log caching is active\r
2284 \r
2285                 LogCache::CCachedLogInfo newInfo;\r
2286                 newInfo.Insert ( pLogEntry->Rev\r
2287                                , ""\r
2288                                , (const char*) CUnicodeUtils::GetUTF8 (pLogEntry->sMessage)\r
2289                                , 0\r
2290                                , LogCache::CRevisionInfoContainer::HAS_COMMENT);\r
2291 \r
2292                 toUpdate->Update (newInfo);\r
2293             }\r
2294         }\r
2295         }\r
2296         theApp.DoWaitCursor(-1);\r
2297         EnableOKButton();\r
2298 #endif\r
2299 }\r
2300 \r
2301 BOOL CLogDlg::PreTranslateMessage(MSG* pMsg)\r
2302 {\r
2303         // Skip Ctrl-C when copying text out of the log message or search filter\r
2304         BOOL bSkipAccelerator = ( pMsg->message == WM_KEYDOWN && pMsg->wParam=='C' && (GetFocus()==GetDlgItem(IDC_MSGVIEW) || GetFocus()==GetDlgItem(IDC_SEARCHEDIT) ) && GetKeyState(VK_CONTROL)&0x8000 );\r
2305         if (pMsg->message == WM_KEYDOWN && pMsg->wParam=='\r')\r
2306         {\r
2307                 if (GetFocus()==GetDlgItem(IDC_LOGLIST))\r
2308                 {\r
2309                         if (CRegDWORD(_T("Software\\TortoiseGit\\DiffByDoubleClickInLog"), FALSE))\r
2310                         {\r
2311                                 DiffSelectedRevWithPrevious();\r
2312                                 return TRUE;\r
2313                         }\r
2314                 }\r
2315                 if (GetFocus()==GetDlgItem(IDC_LOGMSG))\r
2316                 {\r
2317                         DiffSelectedFile();\r
2318                         return TRUE;\r
2319                 }\r
2320         }\r
2321         if (m_hAccel && !bSkipAccelerator)\r
2322         {\r
2323                 int ret = TranslateAccelerator(m_hWnd, m_hAccel, pMsg);\r
2324                 if (ret)\r
2325                         return TRUE;\r
2326         }\r
2327         \r
2328         m_tooltips.RelayEvent(pMsg);\r
2329         return __super::PreTranslateMessage(pMsg);\r
2330 }\r
2331 \r
2332 BOOL CLogDlg::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)\r
2333 {\r
2334         if (m_bThreadRunning)\r
2335         {\r
2336                 // only show the wait cursor over the list control\r
2337                 if ((pWnd)&&\r
2338                         ((pWnd == GetDlgItem(IDC_LOGLIST))||\r
2339                         (pWnd == GetDlgItem(IDC_MSGVIEW))||\r
2340                         (pWnd == GetDlgItem(IDC_LOGMSG))))\r
2341                 {\r
2342                         HCURSOR hCur = LoadCursor(NULL, MAKEINTRESOURCE(IDC_WAIT));\r
2343                         SetCursor(hCur);\r
2344                         return TRUE;\r
2345                 }\r
2346         }\r
2347         if ((pWnd) && (pWnd == GetDlgItem(IDC_MSGVIEW)))\r
2348                 return CResizableStandAloneDialog::OnSetCursor(pWnd, nHitTest, message);\r
2349 \r
2350         HCURSOR hCur = LoadCursor(NULL, MAKEINTRESOURCE(IDC_ARROW));\r
2351         SetCursor(hCur);\r
2352         return CResizableStandAloneDialog::OnSetCursor(pWnd, nHitTest, message);\r
2353 }\r
2354 \r
2355 void CLogDlg::OnBnClickedHelp()\r
2356 {\r
2357         OnHelp();\r
2358 }\r
2359 \r
2360 void CLogDlg::OnLvnItemchangedLoglist(NMHDR *pNMHDR, LRESULT *pResult)\r
2361 {\r
2362         LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);\r
2363         *pResult = 0;\r
2364         if (m_bThreadRunning)\r
2365                 return;\r
2366         if (pNMLV->iItem >= 0)\r
2367         {\r
2368                 m_nSearchIndex = pNMLV->iItem;\r
2369                 if (pNMLV->iSubItem != 0)\r
2370                         return;\r
2371                 if ((pNMLV->iItem == m_arShownList.GetCount())&&(m_bStrict)&&(m_bStrictStopped))\r
2372                 {\r
2373                         // remove the selected state\r
2374                         if (pNMLV->uChanged & LVIF_STATE)\r
2375                         {\r
2376                                 m_LogList.SetItemState(pNMLV->iItem, 0, LVIS_SELECTED);\r
2377                                 FillLogMessageCtrl();\r
2378                                 UpdateData(FALSE);\r
2379                                 UpdateLogInfoLabel();\r
2380                         }\r
2381                         return;\r
2382                 }\r
2383                 if (pNMLV->uChanged & LVIF_STATE)\r
2384                 {\r
2385                         FillLogMessageCtrl();\r
2386                         UpdateData(FALSE);\r
2387                 }\r
2388         }\r
2389         else\r
2390         {\r
2391                 FillLogMessageCtrl();\r
2392                 UpdateData(FALSE);\r
2393         }\r
2394         EnableOKButton();\r
2395         UpdateLogInfoLabel();\r
2396 }\r
2397 \r
2398 void CLogDlg::OnEnLinkMsgview(NMHDR *pNMHDR, LRESULT *pResult)\r
2399 {\r
2400         ENLINK *pEnLink = reinterpret_cast<ENLINK *>(pNMHDR);\r
2401         if (pEnLink->msg == WM_LBUTTONUP)\r
2402         {\r
2403                 CString url, msg;\r
2404                 GetDlgItemText(IDC_MSGVIEW, msg);\r
2405                 msg.Replace(_T("\r\n"), _T("\n"));\r
2406                 url = msg.Mid(pEnLink->chrg.cpMin, pEnLink->chrg.cpMax-pEnLink->chrg.cpMin);\r
2407                 if (!::PathIsURL(url))\r
2408                 {\r
2409                         url = m_ProjectProperties.GetBugIDUrl(url);\r
2410                         url = GetAbsoluteUrlFromRelativeUrl(url);\r
2411                 }\r
2412                 if (!url.IsEmpty())\r
2413                         ShellExecute(this->m_hWnd, _T("open"), url, NULL, NULL, SW_SHOWDEFAULT);\r
2414         }\r
2415         *pResult = 0;\r
2416 }\r
2417 \r
2418 void CLogDlg::OnBnClickedStatbutton()\r
2419 {\r
2420 #if 0\r
2421         if (m_bThreadRunning)\r
2422                 return;\r
2423         if (m_arShownList.IsEmpty())\r
2424                 return;         // nothing is shown, so no statistics.\r
2425         // the statistics dialog expects the log entries to be sorted by date\r
2426         SortByColumn(3, false);\r
2427         CPtrArray shownlist;\r
2428         RecalculateShownList(&shownlist);\r
2429         // create arrays which are aware of the current filter\r
2430         CStringArray m_arAuthorsFiltered;\r
2431         CDWordArray m_arDatesFiltered;\r
2432         CDWordArray m_arFileChangesFiltered;\r
2433         for (INT_PTR i=0; i<shownlist.GetCount(); ++i)\r
2434         {\r
2435                 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(shownlist.GetAt(i));\r
2436                 CString strAuthor = pLogEntry->sAuthor;\r
2437                 if ( strAuthor.IsEmpty() )\r
2438                 {\r
2439                         strAuthor.LoadString(IDS_STATGRAPH_EMPTYAUTHOR);\r
2440                 }\r
2441                 m_arAuthorsFiltered.Add(strAuthor);\r
2442                 m_arDatesFiltered.Add(static_cast<DWORD>(pLogEntry->tmDate));\r
2443                 m_arFileChangesFiltered.Add(pLogEntry->dwFileChanges);\r
2444         }\r
2445         CStatGraphDlg dlg;\r
2446         dlg.m_parAuthors = &m_arAuthorsFiltered;\r
2447         dlg.m_parDates = &m_arDatesFiltered;\r
2448         dlg.m_parFileChanges = &m_arFileChangesFiltered;\r
2449         dlg.m_path = m_path;\r
2450         dlg.DoModal();\r
2451         // restore the previous sorting\r
2452         SortByColumn(m_nSortColumn, m_bAscending);\r
2453         OnTimer(LOGFILTER_TIMER);\r
2454 #endif\r
2455 }\r
2456 \r
2457 void CLogDlg::OnNMCustomdrawLoglist(NMHDR *pNMHDR, LRESULT *pResult)\r
2458 {\r
2459 \r
2460         NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>( pNMHDR );\r
2461         // Take the default processing unless we set this to something else below.\r
2462         *pResult = CDRF_DODEFAULT;\r
2463 \r
2464         if (m_bNoDispUpdates)\r
2465                 return;\r
2466 \r
2467         switch (pLVCD->nmcd.dwDrawStage)\r
2468         {\r
2469         case CDDS_PREPAINT:\r
2470                 {\r
2471                         *pResult = CDRF_NOTIFYITEMDRAW;\r
2472                         return;\r
2473                 }\r
2474                 break;\r
2475         case CDDS_ITEMPREPAINT:\r
2476                 {\r
2477                         // This is the prepaint stage for an item. Here's where we set the\r
2478                         // item's text color. \r
2479                         \r
2480                         // Tell Windows to send draw notifications for each subitem.\r
2481                         *pResult = CDRF_NOTIFYSUBITEMDRAW;\r
2482 \r
2483                         COLORREF crText = GetSysColor(COLOR_WINDOWTEXT);\r
2484 \r
2485                         if (m_arShownList.GetCount() > (INT_PTR)pLVCD->nmcd.dwItemSpec)\r
2486                         {\r
2487                                 GitRev* data = (GitRev*)m_arShownList.GetAt(pLVCD->nmcd.dwItemSpec);\r
2488                                 if (data)\r
2489                                 {\r
2490 #if 0\r
2491                                         if (data->bCopiedSelf)\r
2492                                         {\r
2493                                                 // only change the background color if the item is not 'hot' (on vista with themes enabled)\r
2494                                                 if (!theme.IsAppThemed() || !m_bVista || ((pLVCD->nmcd.uItemState & CDIS_HOT)==0))\r
2495                                                         pLVCD->clrTextBk = GetSysColor(COLOR_MENU);\r
2496                                         }\r
2497 \r
2498                                         if (data->bCopies)\r
2499                                                 crText = m_Colors.GetColor(CColors::Modified);\r
2500 #endif\r
2501 //                                      if ((data->childStackDepth)||(m_mergedRevs.find(data->Rev) != m_mergedRevs.end()))\r
2502 //                                              crText = GetSysColor(COLOR_GRAYTEXT);\r
2503 //                                      if (data->Rev == m_wcRev)\r
2504 //                                      {\r
2505 //                                              SelectObject(pLVCD->nmcd.hdc, m_boldFont);\r
2506                                                 // We changed the font, so we're returning CDRF_NEWFONT. This\r
2507                                                 // tells the control to recalculate the extent of the text.\r
2508 //                                              *pResult = CDRF_NOTIFYSUBITEMDRAW | CDRF_NEWFONT;\r
2509 //                                      }\r
2510                                 }\r
2511                         }\r
2512                         if (m_arShownList.GetCount() == (INT_PTR)pLVCD->nmcd.dwItemSpec)\r
2513                         {\r
2514                                 if (m_bStrictStopped)\r
2515                                         crText = GetSysColor(COLOR_GRAYTEXT);\r
2516                         }\r
2517                         // Store the color back in the NMLVCUSTOMDRAW struct.\r
2518                         pLVCD->clrText = crText;\r
2519                         return;\r
2520                 }\r
2521                 break;\r
2522         case CDDS_ITEMPREPAINT|CDDS_ITEM|CDDS_SUBITEM:\r
2523                 {\r
2524                         if ((m_bStrictStopped)&&(m_arShownList.GetCount() == (INT_PTR)pLVCD->nmcd.dwItemSpec))\r
2525                         {\r
2526                                 pLVCD->nmcd.uItemState &= ~(CDIS_SELECTED|CDIS_FOCUS);\r
2527                         }\r
2528                         if (pLVCD->iSubItem == 1)\r
2529                         {\r
2530                                 *pResult = CDRF_DODEFAULT;\r
2531 \r
2532                                 if (m_arShownList.GetCount() <= (INT_PTR)pLVCD->nmcd.dwItemSpec)\r
2533                                         return;\r
2534 \r
2535                                 int             nIcons = 0;\r
2536                                 int             iconwidth = ::GetSystemMetrics(SM_CXSMICON);\r
2537                                 int             iconheight = ::GetSystemMetrics(SM_CYSMICON);\r
2538 \r
2539                                 GitRev* pLogEntry = reinterpret_cast<GitRev *>(m_arShownList.GetAt(pLVCD->nmcd.dwItemSpec));\r
2540 \r
2541                                 // Get the selected state of the\r
2542                                 // item being drawn.\r
2543                                 LVITEM   rItem;\r
2544                                 SecureZeroMemory(&rItem, sizeof(LVITEM));\r
2545                                 rItem.mask  = LVIF_STATE;\r
2546                                 rItem.iItem = pLVCD->nmcd.dwItemSpec;\r
2547                                 rItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED;\r
2548                                 m_LogList.GetItem(&rItem);\r
2549 \r
2550                                 CRect rect;\r
2551                                 m_LogList.GetSubItemRect(pLVCD->nmcd.dwItemSpec, pLVCD->iSubItem, LVIR_BOUNDS, rect);\r
2552 \r
2553                                 // Fill the background\r
2554                                 if (theme.IsAppThemed() && m_bVista)\r
2555                                 {\r
2556                                         theme.Open(m_hWnd, L"Explorer");\r
2557                                         int state = LISS_NORMAL;\r
2558                                         if (rItem.state & LVIS_SELECTED)\r
2559                                         {\r
2560                                                 if (::GetFocus() == m_LogList.m_hWnd)\r
2561                                                         state |= LISS_SELECTED;\r
2562                                                 else\r
2563                                                         state |= LISS_SELECTEDNOTFOCUS;\r
2564                                         }\r
2565                                         else\r
2566                                         {\r
2567 #if 0\r
2568                                                 if (pLogEntry->bCopiedSelf)\r
2569                                                 {\r
2570                                                         // unfortunately, the pLVCD->nmcd.uItemState does not contain valid\r
2571                                                         // information at this drawing stage. But we can check the whether the\r
2572                                                         // previous stage changed the background color of the item\r
2573                                                         if (pLVCD->clrTextBk == GetSysColor(COLOR_MENU))\r
2574                                                         {\r
2575                                                                 HBRUSH brush;\r
2576                                                                 brush = ::CreateSolidBrush(::GetSysColor(COLOR_MENU));\r
2577                                                                 if (brush)\r
2578                                                                 {\r
2579                                                                         ::FillRect(pLVCD->nmcd.hdc, &rect, brush);\r
2580                                                                         ::DeleteObject(brush);\r
2581                                                                 }\r
2582                                                         }\r
2583                                                 }\r
2584 #endif\r
2585                                         }\r
2586 \r
2587                                         if (theme.IsBackgroundPartiallyTransparent(LVP_LISTDETAIL, state))\r
2588                                                 theme.DrawParentBackground(m_hWnd, pLVCD->nmcd.hdc, &rect);\r
2589 \r
2590                                         theme.DrawBackground(pLVCD->nmcd.hdc, LVP_LISTDETAIL, state, &rect, NULL);\r
2591                                 }\r
2592                                 else\r
2593                                 {\r
2594                                         HBRUSH brush;\r
2595                                         if (rItem.state & LVIS_SELECTED)\r
2596                                         {\r
2597                                                 if (::GetFocus() == m_LogList.m_hWnd)\r
2598                                                         brush = ::CreateSolidBrush(::GetSysColor(COLOR_HIGHLIGHT));\r
2599                                                 else\r
2600                                                         brush = ::CreateSolidBrush(::GetSysColor(COLOR_BTNFACE));\r
2601                                         }\r
2602                                         else\r
2603                                         {\r
2604                                                 //if (pLogEntry->bCopiedSelf)\r
2605                                                 //      brush = ::CreateSolidBrush(::GetSysColor(COLOR_MENU));\r
2606                                                 //else\r
2607                                                         brush = ::CreateSolidBrush(::GetSysColor(COLOR_WINDOW));\r
2608                                         }\r
2609                                         if (brush == NULL)\r
2610                                                 return;\r
2611 \r
2612                                         ::FillRect(pLVCD->nmcd.hdc, &rect, brush);\r
2613                                         ::DeleteObject(brush);\r
2614                                 }\r
2615 \r
2616                                 // Draw the icon(s) into the compatible DC\r
2617                                 if (pLogEntry->m_Action & CTGitPath::LOGACTIONS_MODIFIED)\r
2618                                         ::DrawIconEx(pLVCD->nmcd.hdc, rect.left + ICONITEMBORDER, rect.top, m_hModifiedIcon, iconwidth, iconheight, 0, NULL, DI_NORMAL);\r
2619                                 nIcons++;\r
2620 \r
2621                                 if (pLogEntry->m_Action & CTGitPath::LOGACTIONS_ADDED)\r
2622                                         ::DrawIconEx(pLVCD->nmcd.hdc, rect.left+nIcons*iconwidth + ICONITEMBORDER, rect.top, m_hAddedIcon, iconwidth, iconheight, 0, NULL, DI_NORMAL);\r
2623                                 nIcons++;\r
2624 \r
2625                                 if (pLogEntry->m_Action & CTGitPath::LOGACTIONS_DELETED)\r
2626                                         ::DrawIconEx(pLVCD->nmcd.hdc, rect.left+nIcons*iconwidth + ICONITEMBORDER, rect.top, m_hDeletedIcon, iconwidth, iconheight, 0, NULL, DI_NORMAL);\r
2627                                 nIcons++;\r
2628 \r
2629                                 if (pLogEntry->m_Action & CTGitPath::LOGACTIONS_REPLACED)\r
2630                                         ::DrawIconEx(pLVCD->nmcd.hdc, rect.left+nIcons*iconwidth + ICONITEMBORDER, rect.top, m_hReplacedIcon, iconwidth, iconheight, 0, NULL, DI_NORMAL);\r
2631                                 nIcons++;\r
2632                                 *pResult = CDRF_SKIPDEFAULT;\r
2633                                 return;\r
2634                         }\r
2635                 }\r
2636                 break;\r
2637         }\r
2638         *pResult = CDRF_DODEFAULT;\r
2639 \r
2640 }\r
2641 void CLogDlg::OnNMCustomdrawChangedFileList(NMHDR *pNMHDR, LRESULT *pResult)\r
2642 {\r
2643 \r
2644         NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>( pNMHDR );\r
2645         // Take the default processing unless we set this to something else below.\r
2646         *pResult = CDRF_DODEFAULT;\r
2647 \r
2648         if (m_bNoDispUpdates)\r
2649                 return;\r
2650 \r
2651         // First thing - check the draw stage. If it's the control's prepaint\r
2652         // stage, then tell Windows we want messages for every item.\r
2653 \r
2654         if ( CDDS_PREPAINT == pLVCD->nmcd.dwDrawStage )\r
2655         {\r
2656                 *pResult = CDRF_NOTIFYITEMDRAW;\r
2657         }\r
2658         else if ( CDDS_ITEMPREPAINT == pLVCD->nmcd.dwDrawStage )\r
2659         {\r
2660                 // This is the prepaint stage for an item. Here's where we set the\r
2661                 // item's text color. Our return value will tell Windows to draw the\r
2662                 // item itself, but it will use the new color we set here.\r
2663 \r
2664                 // Tell Windows to paint the control itself.\r
2665                 *pResult = CDRF_DODEFAULT;\r
2666 \r
2667                 COLORREF crText = GetSysColor(COLOR_WINDOWTEXT);\r
2668                 bool bGrayed = false;\r
2669 #if 0\r
2670                 if ((m_cHidePaths.GetState() & 0x0003)==BST_INDETERMINATE)\r
2671                 {\r
2672                         if ((m_currentChangedArray)&&((m_currentChangedArray->GetCount() > (INT_PTR)pLVCD->nmcd.dwItemSpec)))\r
2673                         {\r
2674                                 //if ((*m_currentChangedArray)[(pLVCD->nmcd.dwItemSpec)]sPath.Left(m_sRelativeRoot.GetLength()).Compare(m_sRelativeRoot)!=0)\r
2675                                 {\r
2676                                         crText = GetSysColor(COLOR_GRAYTEXT);\r
2677                                         bGrayed = true;\r
2678                                 }\r
2679                         }\r
2680                         else if (m_currentChangedPathList.GetCount() > (INT_PTR)pLVCD->nmcd.dwItemSpec)\r
2681                         {\r
2682                                 //if (m_currentChangedPathList[pLVCD->nmcd.dwItemSpec].GetGitPathString().Left(m_sRelativeRoot.GetLength()).Compare(m_sRelativeRoot)!=0)\r
2683                                 {\r
2684                                         crText = GetSysColor(COLOR_GRAYTEXT);\r
2685                                         bGrayed = true;\r
2686                                 }\r
2687                         }\r
2688                 }\r
2689 \r
2690 #endif\r
2691                 if ((!bGrayed)&&(m_currentChangedArray)&&(m_currentChangedArray->GetCount() > (INT_PTR)pLVCD->nmcd.dwItemSpec))\r
2692                 {\r
2693                         DWORD action = ((*m_currentChangedArray)[pLVCD->nmcd.dwItemSpec]).m_Action;\r
2694                         if (action == CTGitPath::LOGACTIONS_MODIFIED)\r
2695                                 crText = m_Colors.GetColor(CColors::Modified);\r
2696                         if (action == CTGitPath::LOGACTIONS_REPLACED)\r
2697                                 crText = m_Colors.GetColor(CColors::Deleted);\r
2698                         if (action == CTGitPath::LOGACTIONS_ADDED)\r
2699                                 crText = m_Colors.GetColor(CColors::Added);\r
2700                         if (action == CTGitPath::LOGACTIONS_DELETED)\r
2701                                 crText = m_Colors.GetColor(CColors::Deleted);\r
2702                 }\r
2703 \r
2704                 // Store the color back in the NMLVCUSTOMDRAW struct.\r
2705                 pLVCD->clrText = crText;\r
2706         }\r
2707 }\r
2708 \r
2709 void CLogDlg::DoSizeV1(int delta)\r
2710 {\r
2711 \r
2712         RemoveAnchor(IDC_LOGLIST);\r
2713         RemoveAnchor(IDC_SPLITTERTOP);\r
2714         RemoveAnchor(IDC_MSGVIEW);\r
2715         RemoveAnchor(IDC_SPLITTERBOTTOM);\r
2716         RemoveAnchor(IDC_LOGMSG);\r
2717         CSplitterControl::ChangeHeight(&m_LogList, delta, CW_TOPALIGN);\r
2718         CSplitterControl::ChangeHeight(GetDlgItem(IDC_MSGVIEW), -delta, CW_BOTTOMALIGN);\r
2719         AddAnchor(IDC_LOGLIST, TOP_LEFT, TOP_RIGHT);\r
2720         AddAnchor(IDC_SPLITTERTOP, TOP_LEFT, TOP_RIGHT);\r
2721         AddAnchor(IDC_MSGVIEW, TOP_LEFT, BOTTOM_RIGHT);\r
2722         AddAnchor(IDC_SPLITTERBOTTOM, BOTTOM_LEFT, BOTTOM_RIGHT);\r
2723         AddAnchor(IDC_LOGMSG, BOTTOM_LEFT, BOTTOM_RIGHT);\r
2724         ArrangeLayout();\r
2725         AdjustMinSize();\r
2726         SetSplitterRange();\r
2727         m_LogList.Invalidate();\r
2728         GetDlgItem(IDC_MSGVIEW)->Invalidate();\r
2729 \r
2730 }\r
2731 \r
2732 void CLogDlg::DoSizeV2(int delta)\r
2733 {\r
2734 \r
2735         RemoveAnchor(IDC_LOGLIST);\r
2736         RemoveAnchor(IDC_SPLITTERTOP);\r
2737         RemoveAnchor(IDC_MSGVIEW);\r
2738         RemoveAnchor(IDC_SPLITTERBOTTOM);\r
2739         RemoveAnchor(IDC_LOGMSG);\r
2740         CSplitterControl::ChangeHeight(GetDlgItem(IDC_MSGVIEW), delta, CW_TOPALIGN);\r
2741         CSplitterControl::ChangeHeight(&m_ChangedFileListCtrl, -delta, CW_BOTTOMALIGN);\r
2742         AddAnchor(IDC_LOGLIST, TOP_LEFT, TOP_RIGHT);\r
2743         AddAnchor(IDC_SPLITTERTOP, TOP_LEFT, TOP_RIGHT);\r
2744         AddAnchor(IDC_MSGVIEW, TOP_LEFT, BOTTOM_RIGHT);\r
2745         AddAnchor(IDC_SPLITTERBOTTOM, BOTTOM_LEFT, BOTTOM_RIGHT);\r
2746         AddAnchor(IDC_LOGMSG, BOTTOM_LEFT, BOTTOM_RIGHT);\r
2747         ArrangeLayout();\r
2748         AdjustMinSize();\r
2749         SetSplitterRange();\r
2750         GetDlgItem(IDC_MSGVIEW)->Invalidate();\r
2751         m_ChangedFileListCtrl.Invalidate();\r
2752 \r
2753 }\r
2754 \r
2755 void CLogDlg::AdjustMinSize()\r
2756 {\r
2757         // adjust the minimum size of the dialog to prevent the resizing from\r
2758         // moving the list control too far down.\r
2759         CRect rcChgListView;\r
2760         m_ChangedFileListCtrl.GetClientRect(rcChgListView);\r
2761         CRect rcLogList;\r
2762         m_LogList.GetClientRect(rcLogList);\r
2763 \r
2764         SetMinTrackSize(CSize(m_DlgOrigRect.Width(), \r
2765                 m_DlgOrigRect.Height()-m_ChgOrigRect.Height()-m_LogListOrigRect.Height()-m_MsgViewOrigRect.Height()\r
2766                 +rcChgListView.Height()+rcLogList.Height()+60));\r
2767 }\r
2768 \r
2769 LRESULT CLogDlg::DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam) \r
2770 {\r
2771         switch (message) {\r
2772         case WM_NOTIFY:\r
2773                 if (wParam == IDC_SPLITTERTOP)\r
2774                 { \r
2775                         SPC_NMHDR* pHdr = (SPC_NMHDR*) lParam;\r
2776                         DoSizeV1(pHdr->delta);\r
2777                 }\r
2778                 else if (wParam == IDC_SPLITTERBOTTOM)\r
2779                 { \r
2780                         SPC_NMHDR* pHdr = (SPC_NMHDR*) lParam;\r
2781                         DoSizeV2(pHdr->delta);\r
2782                 }\r
2783                 break;\r
2784         }\r
2785 \r
2786         return CResizableDialog::DefWindowProc(message, wParam, lParam);\r
2787 }\r
2788 \r
2789 void CLogDlg::SetSplitterRange()\r
2790 {\r
2791         if ((m_LogList)&&(m_ChangedFileListCtrl))\r
2792         {\r
2793                 CRect rcTop;\r
2794                 m_LogList.GetWindowRect(rcTop);\r
2795                 ScreenToClient(rcTop);\r
2796                 CRect rcMiddle;\r
2797                 GetDlgItem(IDC_MSGVIEW)->GetWindowRect(rcMiddle);\r
2798                 ScreenToClient(rcMiddle);\r
2799                 m_wndSplitter1.SetRange(rcTop.top+30, rcMiddle.bottom-20);\r
2800                 CRect rcBottom;\r
2801                 m_ChangedFileListCtrl.GetWindowRect(rcBottom);\r
2802                 ScreenToClient(rcBottom);\r
2803                 m_wndSplitter2.SetRange(rcMiddle.top+30, rcBottom.bottom-20);\r
2804         }\r
2805 }\r
2806 \r
2807 LRESULT CLogDlg::OnClickedInfoIcon(WPARAM /*wParam*/, LPARAM lParam)\r
2808 {\r
2809         RECT * rect = (LPRECT)lParam;\r
2810         CPoint point;\r
2811         CString temp;\r
2812         point = CPoint(rect->left, rect->bottom);\r
2813 #define LOGMENUFLAGS(x) (MF_STRING | MF_ENABLED | (m_nSelectedFilter == x ? MF_CHECKED : MF_UNCHECKED))\r
2814         CMenu popup;\r
2815         if (popup.CreatePopupMenu())\r
2816         {\r
2817                 temp.LoadString(IDS_LOG_FILTER_ALL);\r
2818                 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_ALL), LOGFILTER_ALL, temp);\r
2819 \r
2820                 popup.AppendMenu(MF_SEPARATOR, NULL);\r
2821                 \r
2822                 temp.LoadString(IDS_LOG_FILTER_MESSAGES);\r
2823                 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_MESSAGES), LOGFILTER_MESSAGES, temp);\r
2824                 temp.LoadString(IDS_LOG_FILTER_PATHS);\r
2825                 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_PATHS), LOGFILTER_PATHS, temp);\r
2826                 temp.LoadString(IDS_LOG_FILTER_AUTHORS);\r
2827                 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_AUTHORS), LOGFILTER_AUTHORS, temp);\r
2828                 temp.LoadString(IDS_LOG_FILTER_REVS);\r
2829                 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_REVS), LOGFILTER_REVS, temp);\r
2830                 temp.LoadString(IDS_LOG_FILTER_BUGIDS);\r
2831                 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_BUGID), LOGFILTER_BUGID, temp);\r
2832                 \r
2833                 popup.AppendMenu(MF_SEPARATOR, NULL);\r
2834 \r
2835                 temp.LoadString(IDS_LOG_FILTER_REGEX);\r
2836                 popup.AppendMenu(MF_STRING | MF_ENABLED | (m_bFilterWithRegex ? MF_CHECKED : MF_UNCHECKED), LOGFILTER_REGEX, temp);\r
2837 \r
2838                 m_tooltips.Pop();\r
2839                 int selection = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this, 0);\r
2840                 if (selection != 0)\r
2841                 {\r
2842 \r
2843                         if (selection == LOGFILTER_REGEX)\r
2844                         {\r
2845                                 m_bFilterWithRegex = !m_bFilterWithRegex;\r
2846                                 CRegDWORD b = CRegDWORD(_T("Software\\TortoiseGit\\UseRegexFilter"), TRUE);\r
2847                                 b = m_bFilterWithRegex;\r
2848                                 CheckRegexpTooltip();\r
2849                         }\r
2850                         else\r
2851                         {\r
2852                                 m_nSelectedFilter = selection;\r
2853                                 SetFilterCueText();\r
2854                         }\r
2855                         SetTimer(LOGFILTER_TIMER, 1000, NULL);\r
2856                 }\r
2857         }\r
2858         return 0L;\r
2859 }\r
2860 \r
2861 LRESULT CLogDlg::OnClickedCancelFilter(WPARAM /*wParam*/, LPARAM /*lParam*/)\r
2862 {\r
2863 #if 0\r
2864         KillTimer(LOGFILTER_TIMER);\r
2865 \r
2866         m_sFilterText.Empty();\r
2867         UpdateData(FALSE);\r
2868         theApp.DoWaitCursor(1);\r
2869         CStoreSelection storeselection(this);\r
2870         FillLogMessageCtrl(false);\r
2871         InterlockedExchange(&m_bNoDispUpdates, TRUE);\r
2872         m_arShownList.RemoveAll();\r
2873 \r
2874         // reset the time filter too\r
2875         m_timFrom = (__time64_t(m_tFrom));\r
2876         m_timTo = (__time64_t(m_tTo));\r
2877         m_DateFrom.SetTime(&m_timFrom);\r
2878         m_DateTo.SetTime(&m_timTo);\r
2879         m_DateFrom.SetRange(&m_timFrom, &m_timTo);\r
2880         m_DateTo.SetRange(&m_timFrom, &m_timTo);\r
2881 \r
2882         for (DWORD i=0; i<m_logEntries.size(); ++i)\r
2883         {\r
2884                 m_arShownList.Add(m_logEntries[i]);\r
2885         }\r
2886         InterlockedExchange(&m_bNoDispUpdates, FALSE);\r
2887         m_LogList.DeleteAllItems();\r
2888         m_LogList.SetItemCountEx(ShownCountWithStopped());\r
2889         m_LogList.RedrawItems(0, ShownCountWithStopped());\r
2890         m_LogList.SetRedraw(false);\r
2891         ResizeAllListCtrlCols();\r
2892         m_LogList.SetRedraw(true);\r
2893         theApp.DoWaitCursor(-1);\r
2894         GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_HIDE);\r
2895         GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_SHOW);\r
2896         GetDlgItem(IDC_SEARCHEDIT)->SetFocus();\r
2897         UpdateLogInfoLabel();\r
2898 #endif\r
2899         return 0L;      \r
2900 }\r
2901 \r
2902 \r
2903 void CLogDlg::SetFilterCueText()\r
2904 {\r
2905         CString temp;\r
2906         switch (m_nSelectedFilter)\r
2907         {\r
2908         case LOGFILTER_ALL:\r
2909                 temp.LoadString(IDS_LOG_FILTER_ALL);\r
2910                 break;\r
2911         case LOGFILTER_MESSAGES:\r
2912                 temp.LoadString(IDS_LOG_FILTER_MESSAGES);\r
2913                 break;\r
2914         case LOGFILTER_PATHS:\r
2915                 temp.LoadString(IDS_LOG_FILTER_PATHS);\r
2916                 break;\r
2917         case LOGFILTER_AUTHORS:\r
2918                 temp.LoadString(IDS_LOG_FILTER_AUTHORS);\r
2919                 break;\r
2920         case LOGFILTER_REVS:\r
2921                 temp.LoadString(IDS_LOG_FILTER_REVS);\r
2922                 break;\r
2923         }\r
2924         // to make the cue banner text appear more to the right of the edit control\r
2925         temp = _T("   ")+temp;\r
2926         m_cFilter.SetCueBanner(temp);\r
2927 }\r
2928 \r
2929 void CLogDlg::OnLvnGetdispinfoLoglist(NMHDR *pNMHDR, LRESULT *pResult)\r
2930 {\r
2931         NMLVDISPINFO *pDispInfo = reinterpret_cast<NMLVDISPINFO*>(pNMHDR);\r
2932 \r
2933         // Create a pointer to the item\r
2934         LV_ITEM* pItem = &(pDispInfo)->item;\r
2935 \r
2936         // Do the list need text information?\r
2937         if (!(pItem->mask & LVIF_TEXT))\r
2938                 return;\r
2939 \r
2940         // By default, clear text buffer.\r
2941         lstrcpyn(pItem->pszText, _T(""), pItem->cchTextMax);\r
2942 \r
2943         bool bOutOfRange = pItem->iItem >= ShownCountWithStopped();\r
2944         \r
2945         *pResult = 0;\r
2946         if (m_bNoDispUpdates || m_bThreadRunning || bOutOfRange)\r
2947                 return;\r
2948 \r
2949         // Which item number?\r
2950         int itemid = pItem->iItem;\r
2951         GitRev * pLogEntry = NULL;\r
2952         if (itemid < m_arShownList.GetCount())\r
2953                 pLogEntry = reinterpret_cast<GitRev*>(m_arShownList.GetAt(pItem->iItem));\r
2954     \r
2955         // Which column?\r
2956         switch (pItem->iSubItem)\r
2957         {\r
2958         case this->LOGLIST_GRAPH:       //Graphic\r
2959                 if (pLogEntry)\r
2960                 {\r
2961                 }\r
2962                 break;\r
2963         case this->LOGLIST_ACTION: //action -- no text in the column\r
2964                 break;\r
2965         case this->LOGLIST_MESSAGE: //Message\r
2966                 if (pLogEntry)\r
2967                         lstrcpyn(pItem->pszText, (LPCTSTR)pLogEntry->m_Subject, pItem->cchTextMax);\r
2968                 break;\r
2969         case this->LOGLIST_AUTHOR: //Author\r
2970                 if (pLogEntry)\r
2971                         lstrcpyn(pItem->pszText, (LPCTSTR)pLogEntry->m_AuthorName, pItem->cchTextMax);\r
2972                 break;\r
2973         case this->LOGLIST_DATE: //Date\r
2974                 if (pLogEntry)\r
2975                         lstrcpyn(pItem->pszText, (LPCTSTR)pLogEntry->m_AuthorDate.Format(_T("%Y-%m-%d %H:%M")), pItem->cchTextMax);\r
2976                 break;\r
2977                 \r
2978         case 5:\r
2979 \r
2980                 break;\r
2981         default:\r
2982                 ASSERT(false);\r
2983         }\r
2984 }\r
2985 \r
2986 void CLogDlg::OnLvnGetdispinfoChangedFileList(NMHDR *pNMHDR, LRESULT *pResult)\r
2987 {\r
2988 \r
2989         NMLVDISPINFO *pDispInfo = reinterpret_cast<NMLVDISPINFO*>(pNMHDR);\r
2990 \r
2991         //Create a pointer to the item\r
2992         LV_ITEM* pItem= &(pDispInfo)->item;\r
2993 \r
2994         *pResult = 0;\r
2995         if ((m_bNoDispUpdates)||(m_bThreadRunning))\r
2996         {\r
2997                 if (pItem->mask & LVIF_TEXT)\r
2998                         lstrcpyn(pItem->pszText, _T(""), pItem->cchTextMax);\r
2999                 return;\r
3000         }\r
3001         if ((m_currentChangedArray!=NULL)&&(pItem->iItem >= m_currentChangedArray->GetCount()))\r
3002         {\r
3003                 if (pItem->mask & LVIF_TEXT)\r
3004                         lstrcpyn(pItem->pszText, _T(""), pItem->cchTextMax);\r
3005                 return;\r
3006         }\r
3007         if ((m_currentChangedArray==NULL)&&(pItem->iItem >= m_currentChangedPathList.GetCount()))\r
3008         {\r
3009                 if (pItem->mask & LVIF_TEXT)\r
3010                         lstrcpyn(pItem->pszText, _T(""), pItem->cchTextMax);\r
3011                 return;\r
3012         }\r
3013         CTGitPath lcpath = NULL;\r
3014         if (m_currentChangedArray)\r
3015                 lcpath = (*m_currentChangedArray)[pItem->iItem];\r
3016         //Does the list need text information?\r
3017         if (pItem->mask & LVIF_TEXT)\r
3018         {\r
3019                 //Which column?\r
3020                 switch (pItem->iSubItem)\r
3021                 {\r
3022                 case this->FILELIST_ACTION:     //Action\r
3023 #if 0\r
3024                         if (lcpath)\r
3025                                 lstrcpyn(pItem->pszText, (LPCTSTR)lcpath->GetAction(), pItem->cchTextMax);\r
3026                         else\r
3027                                 lstrcpyn(pItem->pszText, _T(""), pItem->cchTextMax);                            \r
3028 #endif\r
3029                         lstrcpyn(pItem->pszText, (LPCTSTR)lcpath.GetActionName(), pItem->cchTextMax);\r
3030 \r
3031                         break;\r
3032 \r
3033                 case this->FILELIST_ADD: //add\r
3034 #if 0\r
3035                         if (lcpath)\r
3036                                 lstrcpyn(pItem->pszText, (LPCTSTR)lcpath->sPath, pItem->cchTextMax);\r
3037                         else\r
3038                                 lstrcpyn(pItem->pszText, (LPCTSTR)m_currentChangedPathList[pItem->iItem].GetGitPathString(), pItem->cchTextMax);\r
3039 #endif\r
3040                         lstrcpyn(pItem->pszText, (LPCTSTR)lcpath.m_StatAdd, pItem->cchTextMax);\r
3041                         break;\r
3042 \r
3043                 case this->FILELIST_DEL: //del\r
3044 #if 0\r
3045                         if (lcpath)\r
3046                                 lstrcpyn(pItem->pszText, (LPCTSTR)lcpath->sCopyFromPath, pItem->cchTextMax);\r
3047                         else\r
3048                                 lstrcpyn(pItem->pszText, _T(""), pItem->cchTextMax);\r
3049 #endif\r
3050                         lstrcpyn(pItem->pszText, (LPCTSTR)lcpath.m_StatDel, pItem->cchTextMax);\r
3051                         break;\r
3052                 case this->FILELIST_PATH: //path\r
3053 #if 0\r
3054                         if ((lcpath==NULL)||(lcpath->sCopyFromPath.IsEmpty()))\r
3055                                 lstrcpyn(pItem->pszText, _T(""), pItem->cchTextMax);\r
3056                         else\r
3057                                 _stprintf_s(pItem->pszText, pItem->cchTextMax, _T("%ld"), lcpath->lCopyFromRev);\r
3058 #endif\r
3059                         lstrcpyn(pItem->pszText, (LPCTSTR)lcpath.GetGitPathString(), pItem->cchTextMax);\r
3060                         break;\r
3061                 }\r
3062         }\r
3063 \r
3064         *pResult = 0;\r
3065 }\r
3066 \r
3067 void CLogDlg::OnEnChangeSearchedit()\r
3068 {\r
3069 #if 0\r
3070         UpdateData();\r
3071         if (m_sFilterText.IsEmpty())\r
3072         {\r
3073                 CStoreSelection storeselection(this);\r
3074                 // clear the filter, i.e. make all entries appear\r
3075                 theApp.DoWaitCursor(1);\r
3076                 KillTimer(LOGFILTER_TIMER);\r
3077                 FillLogMessageCtrl(false);\r
3078                 InterlockedExchange(&m_bNoDispUpdates, TRUE);\r
3079                 m_arShownList.RemoveAll();\r
3080                 for (DWORD i=0; i<m_logEntries.size(); ++i)\r
3081                 {\r
3082                         if (IsEntryInDateRange(i))\r
3083                                 m_arShownList.Add(m_logEntries[i]);\r
3084                 }\r
3085                 InterlockedExchange(&m_bNoDispUpdates, FALSE);\r
3086                 m_LogList.DeleteAllItems();\r
3087                 m_LogList.SetItemCountEx(ShownCountWithStopped());\r
3088                 m_LogList.RedrawItems(0, ShownCountWithStopped());\r
3089                 m_LogList.SetRedraw(false);\r
3090                 ResizeAllListCtrlCols();\r
3091                 m_LogList.SetRedraw(true);\r
3092                 theApp.DoWaitCursor(-1);\r
3093                 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_HIDE);\r
3094                 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_SHOW);\r
3095                 GetDlgItem(IDC_SEARCHEDIT)->SetFocus();\r
3096                 DialogEnableWindow(IDC_STATBUTTON, !(((m_bThreadRunning)||(m_arShownList.IsEmpty()))));\r
3097                 return;\r
3098         }\r
3099         if (Validate(m_sFilterText))\r
3100                 SetTimer(LOGFILTER_TIMER, 1000, NULL);\r
3101         else\r
3102                 KillTimer(LOGFILTER_TIMER);\r
3103 #endif\r
3104 }\r
3105 \r
3106 bool CLogDlg::ValidateRegexp(LPCTSTR regexp_str, tr1::wregex& pat, bool bMatchCase /* = false */)\r
3107 {\r
3108         try\r
3109         {\r
3110                 tr1::regex_constants::syntax_option_type type = tr1::regex_constants::ECMAScript;\r
3111                 if (!bMatchCase)\r
3112                         type |= tr1::regex_constants::icase;\r
3113                 pat = tr1::wregex(regexp_str, type);\r
3114                 return true;\r
3115         }\r
3116         catch (exception) {}\r
3117         return false;\r
3118 }\r
3119 \r
3120 bool CLogDlg::Validate(LPCTSTR string)\r
3121 {\r
3122         if (!m_bFilterWithRegex)\r
3123                 return true;\r
3124         tr1::wregex pat;\r
3125         return ValidateRegexp(string, pat, false);\r
3126 }\r
3127 \r
3128 void CLogDlg::RecalculateShownList(CPtrArray * pShownlist)\r
3129 {\r
3130 #if 0\r
3131         pShownlist->RemoveAll();\r
3132         tr1::wregex pat;//(_T("Remove"), tr1::regex_constants::icase);\r
3133         bool bRegex = false;\r
3134         if (m_bFilterWithRegex)\r
3135                 bRegex = ValidateRegexp(m_sFilterText, pat, false);\r
3136 \r
3137         tr1::regex_constants::match_flag_type flags = tr1::regex_constants::match_any;\r
3138         CString sRev;\r
3139         for (DWORD i=0; i<m_logEntries.size(); ++i)\r
3140         {\r
3141                 if ((bRegex)&&(m_bFilterWithRegex))\r
3142                 {\r
3143                         if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_BUGID))\r
3144                         {\r
3145                                 ATLTRACE(_T("bugID = \"%s\"\n"), (LPCTSTR)m_logEntries[i]->sBugIDs);\r
3146                                 if (regex_search(wstring((LPCTSTR)m_logEntries[i]->sBugIDs), pat, flags)&&IsEntryInDateRange(i))\r
3147                                 {\r
3148                                         pShownlist->Add(m_logEntries[i]);\r
3149                                         continue;\r
3150                                 }\r
3151                         }\r
3152                         if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_MESSAGES))\r
3153                         {\r
3154                                 ATLTRACE(_T("messge = \"%s\"\n"), (LPCTSTR)m_logEntries[i]->sMessage);\r
3155                                 if (regex_search(wstring((LPCTSTR)m_logEntries[i]->sMessage), pat, flags)&&IsEntryInDateRange(i))\r
3156                                 {\r
3157                                         pShownlist->Add(m_logEntries[i]);\r
3158                                         continue;\r
3159                                 }\r
3160                         }\r
3161                         if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_PATHS))\r
3162                         {\r
3163                                 LogChangedPathArray * cpatharray = m_logEntries[i]->pArChangedPaths;\r
3164 \r
3165                                 bool bGoing = true;\r
3166                                 for (INT_PTR cpPathIndex = 0; cpPathIndex<cpatharray->GetCount() && bGoing; ++cpPathIndex)\r
3167                                 {\r
3168                                         LogChangedPath * cpath = cpatharray->GetAt(cpPathIndex);\r
3169                                         if (regex_search(wstring((LPCTSTR)cpath->sCopyFromPath), pat, flags)&&IsEntryInDateRange(i))\r
3170                                         {\r
3171                                                 pShownlist->Add(m_logEntries[i]);\r
3172                                                 bGoing = false;\r
3173                                                 continue;\r
3174                                         }\r
3175                                         if (regex_search(wstring((LPCTSTR)cpath->sPath), pat, flags)&&IsEntryInDateRange(i))\r
3176                                         {\r
3177                                                 pShownlist->Add(m_logEntries[i]);\r
3178                                                 bGoing = false;\r
3179                                                 continue;\r
3180                                         }\r
3181                                         if (regex_search(wstring((LPCTSTR)cpath->GetAction()), pat, flags)&&IsEntryInDateRange(i))\r
3182                                         {\r
3183                                                 pShownlist->Add(m_logEntries[i]);\r
3184                                                 bGoing = false;\r
3185                                                 continue;\r
3186                                         }\r
3187                                 }\r
3188                                 if (!bGoing)\r
3189                                         continue;\r
3190                         }\r
3191                         if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_AUTHORS))\r
3192                         {\r
3193                                 if (regex_search(wstring((LPCTSTR)m_logEntries[i]->sAuthor), pat, flags)&&IsEntryInDateRange(i))\r
3194                                 {\r
3195                                         pShownlist->Add(m_logEntries[i]);\r
3196                                         continue;\r
3197                                 }\r
3198                         }\r
3199                         if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_REVS))\r
3200                         {\r
3201                                 sRev.Format(_T("%ld"), m_logEntries[i]->Rev);\r
3202                                 if (regex_search(wstring((LPCTSTR)sRev), pat, flags)&&IsEntryInDateRange(i))\r
3203                                 {\r
3204                                         pShownlist->Add(m_logEntries[i]);\r
3205                                         continue;\r
3206                                 }\r
3207                         }\r
3208                 } // if (bRegex)\r
3209                 else\r
3210                 {\r
3211                         CString find = m_sFilterText;\r
3212                         find.MakeLower();\r
3213                         if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_BUGID))\r
3214                         {\r
3215                                 CString sBugIDs = m_logEntries[i]->sBugIDs;\r
3216 \r
3217                                 sBugIDs = sBugIDs.MakeLower();\r
3218                                 if ((sBugIDs.Find(find) >= 0)&&(IsEntryInDateRange(i)))\r
3219                                 {\r
3220                                         pShownlist->Add(m_logEntries[i]);\r
3221                                         continue;\r
3222                                 }\r
3223                         }\r
3224                         if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_MESSAGES))\r
3225                         {\r
3226                                 CString msg = m_logEntries[i]->sMessage;\r
3227 \r
3228                                 msg = msg.MakeLower();\r
3229                                 if ((msg.Find(find) >= 0)&&(IsEntryInDateRange(i)))\r
3230                                 {\r
3231                                         pShownlist->Add(m_logEntries[i]);\r
3232                                         continue;\r
3233                                 }\r
3234                         }\r
3235                         if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_PATHS))\r
3236                         {\r
3237                                 LogChangedPathArray * cpatharray = m_logEntries[i]->pArChangedPaths;\r
3238 \r
3239                                 bool bGoing = true;\r
3240                                 for (INT_PTR cpPathIndex = 0; cpPathIndex<cpatharray->GetCount() && bGoing; ++cpPathIndex)\r
3241                                 {\r
3242                                         LogChangedPath * cpath = cpatharray->GetAt(cpPathIndex);\r
3243                                         CString path = cpath->sCopyFromPath;\r
3244                                         path.MakeLower();\r
3245                                         if ((path.Find(find)>=0)&&(IsEntryInDateRange(i)))\r
3246                                         {\r
3247                                                 pShownlist->Add(m_logEntries[i]);\r
3248                                                 bGoing = false;\r
3249                                                 continue;\r
3250                                         }\r
3251                                         path = cpath->sPath;\r
3252                                         path.MakeLower();\r
3253                                         if ((path.Find(find)>=0)&&(IsEntryInDateRange(i)))\r
3254                                         {\r
3255                                                 pShownlist->Add(m_logEntries[i]);\r
3256                                                 bGoing = false;\r
3257                                                 continue;\r
3258                                         }\r
3259                                         path = cpath->GetAction();\r
3260                                         path.MakeLower();\r
3261                                         if ((path.Find(find)>=0)&&(IsEntryInDateRange(i)))\r
3262                                         {\r
3263                                                 pShownlist->Add(m_logEntries[i]);\r
3264                                                 bGoing = false;\r
3265                                                 continue;\r
3266                                         }\r
3267                                 }\r
3268                         }\r
3269                         if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_AUTHORS))\r
3270                         {\r
3271                                 CString msg = m_logEntries[i]->sAuthor;\r
3272                                 msg = msg.MakeLower();\r
3273                                 if ((msg.Find(find) >= 0)&&(IsEntryInDateRange(i)))\r
3274                                 {\r
3275                                         pShownlist->Add(m_logEntries[i]);\r
3276                                         continue;\r
3277                                 }\r
3278                         }\r
3279                         if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_REVS))\r
3280                         {\r
3281                                 sRev.Format(_T("%ld"), m_logEntries[i]->Rev);\r
3282                                 if ((sRev.Find(find) >= 0)&&(IsEntryInDateRange(i)))\r
3283                                 {\r
3284                                         pShownlist->Add(m_logEntries[i]);\r
3285                                         continue;\r
3286                                 }\r
3287                         }\r
3288                 } // else (from if (bRegex))    \r
3289         } // for (DWORD i=0; i<m_logEntries.size(); ++i) \r
3290 #endif\r
3291 }\r
3292 \r
3293 void CLogDlg::OnTimer(UINT_PTR nIDEvent)\r
3294 {\r
3295         if (nIDEvent == LOGFILTER_TIMER)\r
3296         {\r
3297                 if (m_bThreadRunning)\r
3298                 {\r
3299                         // thread still running! So just restart the timer.\r
3300                         SetTimer(LOGFILTER_TIMER, 1000, NULL);\r
3301                         return;\r
3302                 }\r
3303                 CWnd * focusWnd = GetFocus();\r
3304                 bool bSetFocusToFilterControl = ((focusWnd != GetDlgItem(IDC_DATEFROM))&&(focusWnd != GetDlgItem(IDC_DATETO))\r
3305                         && (focusWnd != GetDlgItem(IDC_LOGLIST)));\r
3306                 if (m_sFilterText.IsEmpty())\r
3307                 {\r
3308                         DialogEnableWindow(IDC_STATBUTTON, !(((m_bThreadRunning)||(m_arShownList.IsEmpty()))));\r
3309                         // do not return here!\r
3310                         // we also need to run the filter if the filter text is empty:\r
3311                         // 1. to clear an existing filter\r
3312                         // 2. to rebuild the m_arShownList after sorting\r
3313                 }\r
3314                 theApp.DoWaitCursor(1);\r
3315                 CStoreSelection storeselection(this);\r
3316                 KillTimer(LOGFILTER_TIMER);\r
3317                 FillLogMessageCtrl(false);\r
3318 \r
3319                 // now start filter the log list\r
3320                 InterlockedExchange(&m_bNoDispUpdates, TRUE);\r
3321                 RecalculateShownList(&m_arShownList);\r
3322                 InterlockedExchange(&m_bNoDispUpdates, FALSE);\r
3323 \r
3324 \r
3325                 m_LogList.DeleteAllItems();\r
3326                 m_LogList.SetItemCountEx(ShownCountWithStopped());\r
3327                 m_LogList.RedrawItems(0, ShownCountWithStopped());\r
3328                 m_LogList.SetRedraw(false);\r
3329                 ResizeAllListCtrlCols();\r
3330                 m_LogList.SetRedraw(true);\r
3331                 m_LogList.Invalidate();\r
3332                 if ( m_LogList.GetItemCount()==1 )\r
3333                 {\r
3334                         m_LogList.SetSelectionMark(0);\r
3335                         m_LogList.SetItemState(0, LVIS_SELECTED, LVIS_SELECTED);\r
3336                 }\r
3337                 theApp.DoWaitCursor(-1);\r
3338                 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_HIDE);\r
3339                 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_SHOW);\r
3340                 if (bSetFocusToFilterControl)\r
3341                         GetDlgItem(IDC_SEARCHEDIT)->SetFocus();\r
3342                 UpdateLogInfoLabel();\r
3343         } // if (nIDEvent == LOGFILTER_TIMER)\r
3344         DialogEnableWindow(IDC_STATBUTTON, !(((m_bThreadRunning)||(m_arShownList.IsEmpty()))));\r
3345         __super::OnTimer(nIDEvent);\r
3346 }\r
3347 \r
3348 void CLogDlg::OnDtnDatetimechangeDateto(NMHDR * /*pNMHDR*/, LRESULT *pResult)\r
3349 {\r
3350         CTime _time;\r
3351         m_DateTo.GetTime(_time);\r
3352         try\r
3353         {\r
3354                 CTime time(_time.GetYear(), _time.GetMonth(), _time.GetDay(), 23, 59, 59);\r
3355                 if (time.GetTime() != m_tTo)\r
3356                 {\r
3357                         m_tTo = (DWORD)time.GetTime();\r
3358                         SetTimer(LOGFILTER_TIMER, 10, NULL);\r
3359                 }\r
3360         }\r
3361         catch (CAtlException)\r
3362         {\r
3363         }\r
3364         \r
3365         *pResult = 0;\r
3366 }\r
3367 \r
3368 void CLogDlg::OnDtnDatetimechangeDatefrom(NMHDR * /*pNMHDR*/, LRESULT *pResult)\r
3369 {\r
3370         CTime _time;\r
3371         m_DateFrom.GetTime(_time);\r
3372         try\r
3373         {\r
3374                 CTime time(_time.GetYear(), _time.GetMonth(), _time.GetDay(), 0, 0, 0);\r
3375                 if (time.GetTime() != m_tFrom)\r
3376                 {\r
3377                         m_tFrom = (DWORD)time.GetTime();\r
3378                         SetTimer(LOGFILTER_TIMER, 10, NULL);\r
3379                 }\r
3380         }\r
3381         catch (CAtlException)\r
3382         {\r
3383         }\r
3384         \r
3385         *pResult = 0;\r
3386 }\r
3387 \r
3388 BOOL CLogDlg::IsEntryInDateRange(int i)\r
3389 {\r
3390 #if 0\r
3391         __time64_t time = m_logEntries[i]->tmDate;\r
3392         if ((time >= m_tFrom)&&(time <= m_tTo))\r
3393                 return TRUE;\r
3394 #endif\r
3395         return FALSE;\r
3396 \r
3397 }\r
3398 \r
3399 CTGitPathList CLogDlg::GetChangedPathsFromSelectedRevisions(bool bRelativePaths /* = false */, bool bUseFilter /* = true */)\r
3400 {\r
3401         CTGitPathList pathList;\r
3402 #if 0\r
3403         \r
3404         if (m_sRepositoryRoot.IsEmpty() && (bRelativePaths == false))\r
3405         {\r
3406                 m_sRepositoryRoot = GetRepositoryRoot(m_path);\r
3407         }\r
3408         if (m_sRepositoryRoot.IsEmpty() && (bRelativePaths == false))\r
3409                 return pathList;\r
3410         \r
3411         POSITION pos = m_LogList.GetFirstSelectedItemPosition();\r
3412         if (pos != NULL)\r
3413         {\r
3414                 while (pos)\r
3415                 {\r
3416                         int nextpos = m_LogList.GetNextSelectedItem(pos);\r
3417                         if (nextpos >= m_arShownList.GetCount())\r
3418                                 continue;\r
3419                         PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(nextpos));\r
3420                         LogChangedPathArray * cpatharray = pLogEntry->pArChangedPaths;\r
3421                         for (INT_PTR cpPathIndex = 0; cpPathIndex<cpatharray->GetCount(); ++cpPathIndex)\r
3422                         {\r
3423                                 LogChangedPath * cpath = cpatharray->GetAt(cpPathIndex);\r
3424                                 if (cpath == NULL)\r
3425                                         continue;\r
3426                                 CTGitPath path;\r
3427                                 if (!bRelativePaths)\r
3428                                         path.SetFromGit(m_sRepositoryRoot);\r
3429                                 path.AppendPathString(cpath->sPath);\r
3430                                 if ((!bUseFilter)||\r
3431                                         ((m_cHidePaths.GetState() & 0x0003)!=BST_CHECKED)||\r
3432                                         (cpath->sPath.Left(m_sRelativeRoot.GetLength()).Compare(m_sRelativeRoot)==0))\r
3433                                         pathList.AddPath(path);\r
3434                                 \r
3435                         }\r
3436                 }\r
3437         }\r
3438         pathList.RemoveDuplicates();\r
3439 #endif\r
3440         return pathList;\r
3441 }\r
3442 \r
3443 void CLogDlg::SortByColumn(int nSortColumn, bool bAscending)\r
3444 {\r
3445 #if 0\r
3446         switch(nSortColumn)\r
3447         {\r
3448         case 0: // Revision\r
3449                 {\r
3450                         if(bAscending)\r
3451                                 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscRevSort());\r
3452                         else\r
3453                                 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescRevSort());\r
3454                 }\r
3455                 break;\r
3456         case 1: // action\r
3457                 {\r
3458                         if(bAscending)\r
3459                                 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscActionSort());\r
3460                         else\r
3461                                 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescActionSort());\r
3462                 }\r
3463                 break;\r
3464         case 2: // Author\r
3465                 {\r
3466                         if(bAscending)\r
3467                                 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscAuthorSort());\r
3468                         else\r
3469                                 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescAuthorSort());\r
3470                 }\r
3471                 break;\r
3472         case 3: // Date\r
3473                 {\r
3474                         if(bAscending)\r
3475                                 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscDateSort());\r
3476                         else\r
3477                                 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescDateSort());\r
3478                 }\r
3479                 break;\r
3480         case 4: // Message or bug id\r
3481                 if (m_bShowBugtraqColumn)\r
3482                 {\r
3483                         if(bAscending)\r
3484                                 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscBugIDSort());\r
3485                         else\r
3486                                 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescBugIDSort());\r
3487                         break;\r
3488                 }\r
3489                 // fall through here\r
3490         case 5: // Message\r
3491                 {\r
3492                         if(bAscending)\r
3493                                 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscMessageSort());\r
3494                         else\r
3495                                 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescMessageSort());\r
3496                 }\r
3497                 break;\r
3498         default:\r
3499                 ATLASSERT(0);\r
3500                 break;\r
3501         }\r
3502 #endif\r
3503 }\r
3504 \r
3505 void CLogDlg::OnLvnColumnclick(NMHDR *pNMHDR, LRESULT *pResult)\r
3506 {\r
3507         if (m_bThreadRunning)\r
3508                 return;         //no sorting while the arrays are filled\r
3509         LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);\r
3510         const int nColumn = pNMLV->iSubItem;\r
3511         m_bAscending = nColumn == m_nSortColumn ? !m_bAscending : TRUE;\r
3512         m_nSortColumn = nColumn;\r
3513         SortByColumn(m_nSortColumn, m_bAscending);\r
3514         SetSortArrow(&m_LogList, m_nSortColumn, !!m_bAscending);\r
3515         SortShownListArray();\r
3516         m_LogList.Invalidate();\r
3517         UpdateLogInfoLabel();\r
3518         // the "next 100" button only makes sense if the log messages\r
3519         // are sorted by revision in descending order\r
3520         if ((m_nSortColumn)||(m_bAscending))\r
3521         {\r
3522                 DialogEnableWindow(IDC_NEXTHUNDRED, false);\r
3523         }\r
3524         else\r
3525         {\r
3526                 DialogEnableWindow(IDC_NEXTHUNDRED, true);\r
3527         }\r
3528         *pResult = 0;\r
3529 }\r
3530 \r
3531 void CLogDlg::SortShownListArray()\r
3532 {\r
3533         // make sure the shown list still matches the filter after sorting.\r
3534     OnTimer(LOGFILTER_TIMER);\r
3535     // clear the selection states\r
3536         POSITION pos = m_LogList.GetFirstSelectedItemPosition();\r
3537         while (pos)\r
3538         {\r
3539                 m_LogList.SetItemState(m_LogList.GetNextSelectedItem(pos), 0, LVIS_SELECTED);\r
3540         }    \r
3541         m_LogList.SetSelectionMark(-1);\r
3542 }\r
3543 \r
3544 void CLogDlg::SetSortArrow(CListCtrl * control, int nColumn, bool bAscending)\r
3545 {\r
3546         if (control == NULL)\r
3547                 return;\r
3548         // set the sort arrow\r
3549         CHeaderCtrl * pHeader = control->GetHeaderCtrl();\r
3550         HDITEM HeaderItem = {0};\r
3551         HeaderItem.mask = HDI_FORMAT;\r
3552         for (int i=0; i<pHeader->GetItemCount(); ++i)\r
3553         {\r
3554                 pHeader->GetItem(i, &HeaderItem);\r
3555                 HeaderItem.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);\r
3556                 pHeader->SetItem(i, &HeaderItem);\r
3557         }\r
3558         if (nColumn >= 0)\r
3559         {\r
3560                 pHeader->GetItem(nColumn, &HeaderItem);\r
3561                 HeaderItem.fmt |= (bAscending ? HDF_SORTUP : HDF_SORTDOWN);\r
3562                 pHeader->SetItem(nColumn, &HeaderItem);\r
3563         }\r
3564 }\r
3565 void CLogDlg::OnLvnColumnclickChangedFileList(NMHDR *pNMHDR, LRESULT *pResult)\r
3566 {\r
3567         if (m_bThreadRunning)\r
3568                 return;         //no sorting while the arrays are filled\r
3569         if (m_currentChangedArray == NULL)\r
3570                 return;\r
3571         LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);\r
3572         const int nColumn = pNMLV->iSubItem;\r
3573         m_bAscendingPathList = nColumn == m_nSortColumnPathList ? !m_bAscendingPathList : TRUE;\r
3574         m_nSortColumnPathList = nColumn;\r
3575 //      qsort(m_currentChangedArray->GetData(), m_currentChangedArray->GetSize(), sizeof(LogChangedPath*), (GENERICCOMPAREFN)SortCompare);\r
3576 \r
3577         SetSortArrow(&m_ChangedFileListCtrl, m_nSortColumnPathList, m_bAscendingPathList);\r
3578         m_ChangedFileListCtrl.Invalidate();\r
3579         *pResult = 0;\r
3580 }\r
3581 \r
3582 int CLogDlg::m_nSortColumnPathList = 0;\r
3583 bool CLogDlg::m_bAscendingPathList = false;\r
3584 \r
3585 int CLogDlg::SortCompare(const void * pElem1, const void * pElem2)\r
3586 {\r
3587 #if 0\r
3588         LogChangedPath * cpath1 = *((LogChangedPath**)pElem1);\r
3589         LogChangedPath * cpath2 = *((LogChangedPath**)pElem2);\r
3590 \r
3591         if (m_bAscendingPathList)\r
3592                 std::swap (cpath1, cpath2);\r
3593 \r
3594         int cmp = 0;\r
3595         switch (m_nSortColumnPathList)\r
3596         {\r
3597         case 0: // action\r
3598                         cmp = cpath2->GetAction().Compare(cpath1->GetAction());\r
3599                         if (cmp)\r
3600                                 return cmp;\r
3601                         // fall through\r
3602         case 1: // path\r
3603                         cmp = cpath2->sPath.CompareNoCase(cpath1->sPath);\r
3604                         if (cmp)\r
3605                                 return cmp;\r
3606                         // fall through\r
3607         case 2: // copy from path\r
3608                         cmp = cpath2->sCopyFromPath.Compare(cpath1->sCopyFromPath);\r
3609                         if (cmp)\r
3610                                 return cmp;\r
3611                         // fall through\r
3612         case 3: // copy from revision\r
3613                         return cpath2->lCopyFromRev > cpath1->lCopyFromRev;\r
3614         }\r
3615 #endif\r
3616         return 0;\r
3617 }\r
3618 \r
3619 void CLogDlg::ResizeAllListCtrlCols()\r
3620 {\r
3621 \r
3622         const int nMinimumWidth = ICONITEMBORDER+16*4;\r
3623         int maxcol = ((CHeaderCtrl*)(m_LogList.GetDlgItem(0)))->GetItemCount()-1;\r
3624         int nItemCount = m_LogList.GetItemCount();\r
3625         TCHAR textbuf[MAX_PATH];\r
3626         CHeaderCtrl * pHdrCtrl = (CHeaderCtrl*)(m_LogList.GetDlgItem(0));\r
3627         if (pHdrCtrl)\r
3628         {\r
3629                 for (int col = 0; col <= maxcol; col++)\r
3630                 {\r
3631                         HDITEM hdi = {0};\r
3632                         hdi.mask = HDI_TEXT;\r
3633                         hdi.pszText = textbuf;\r
3634                         hdi.cchTextMax = sizeof(textbuf);\r
3635                         pHdrCtrl->GetItem(col, &hdi);\r
3636                         int cx = m_LogList.GetStringWidth(hdi.pszText)+20; // 20 pixels for col separator and margin\r
3637                         for (int index = 0; index<nItemCount; ++index)\r
3638                         {\r
3639                                 // get the width of the string and add 14 pixels for the column separator and margins\r
3640                                 int linewidth = m_LogList.GetStringWidth(m_LogList.GetItemText(index, col)) + 14;\r
3641                                 if (index < m_arShownList.GetCount())\r
3642                                 {\r
3643                                         GitRev * pCurLogEntry = reinterpret_cast<GitRev*>(m_arShownList.GetAt(index));\r
3644                                         if ((pCurLogEntry)&&(pCurLogEntry->m_CommitHash == m_wcRev.m_CommitHash))\r
3645                                         {\r
3646                                                 // set the bold font and ask for the string width again\r
3647                                                 m_LogList.SendMessage(WM_SETFONT, (WPARAM)m_boldFont, NULL);\r
3648                                                 linewidth = m_LogList.GetStringWidth(m_LogList.GetItemText(index, col)) + 14;\r
3649                                                 // restore the system font\r
3650                                                 m_LogList.SendMessage(WM_SETFONT, NULL, NULL);\r
3651                                         }\r
3652                                 }\r
3653                                 if (index == 0)\r
3654                                 {\r
3655                                         // add the image size\r
3656                                         CImageList * pImgList = m_LogList.GetImageList(LVSIL_SMALL);\r
3657                                         if ((pImgList)&&(pImgList->GetImageCount()))\r
3658                                         {\r
3659                                                 IMAGEINFO imginfo;\r
3660                                                 pImgList->GetImageInfo(0, &imginfo);\r
3661                                                 linewidth += (imginfo.rcImage.right - imginfo.rcImage.left);\r
3662                                                 linewidth += 3; // 3 pixels between icon and text\r
3663                                         }\r
3664                                 }\r
3665                                 if (cx < linewidth)\r
3666                                         cx = linewidth;\r
3667                         }\r
3668                         // Adjust columns "Actions" containing icons\r
3669                         if (col == this->LOGLIST_ACTION)\r
3670                         {\r
3671                                 if (cx < nMinimumWidth)\r
3672                                 {\r
3673                                         cx = nMinimumWidth;\r
3674                                 }\r
3675                         }\r
3676                         \r
3677                         if (col == this->LOGLIST_MESSAGE)\r
3678                         {\r
3679                                 if (cx > LOGLIST_MESSAGE_MAX)\r
3680                                 {\r
3681                                         cx = LOGLIST_MESSAGE_MAX;\r
3682                                 }\r
3683 \r
3684                         }\r
3685                         // keep the bug id column small\r
3686                         if ((col == 4)&&(m_bShowBugtraqColumn))\r
3687                         {\r
3688                                 if (cx > (int)(DWORD)m_regMaxBugIDColWidth)\r
3689                                 {\r
3690                                         cx = (int)(DWORD)m_regMaxBugIDColWidth;\r
3691                                 }\r
3692                         }\r
3693 \r
3694                         m_LogList.SetColumnWidth(col, cx);\r
3695                 }\r
3696         }\r
3697 \r
3698 }\r
3699 \r
3700 void CLogDlg::OnBnClickedHidepaths()\r
3701 {\r
3702         FillLogMessageCtrl();\r
3703         m_ChangedFileListCtrl.Invalidate();\r
3704 }\r
3705 \r
3706 \r
3707 void CLogDlg::OnLvnOdfinditemLoglist(NMHDR *pNMHDR, LRESULT *pResult)\r
3708 {\r
3709         LPNMLVFINDITEM pFindInfo = reinterpret_cast<LPNMLVFINDITEM>(pNMHDR);\r
3710         *pResult = -1;\r
3711         \r
3712         if (pFindInfo->lvfi.flags & LVFI_PARAM)\r
3713                 return; \r
3714         if ((pFindInfo->iStart < 0)||(pFindInfo->iStart >= m_arShownList.GetCount()))\r
3715                 return;\r
3716         if (pFindInfo->lvfi.psz == 0)\r
3717                 return;\r
3718 #if 0\r
3719         CString sCmp = pFindInfo->lvfi.psz;\r
3720         CString sRev;   \r
3721         for (int i=pFindInfo->iStart; i<m_arShownList.GetCount(); ++i)\r
3722         {\r
3723                 GitRev * pLogEntry = reinterpret_cast<GitRev*>(m_arShownList.GetAt(i));\r
3724                 sRev.Format(_T("%ld"), pLogEntry->Rev);\r
3725                 if (pFindInfo->lvfi.flags & LVFI_PARTIAL)\r
3726                 {\r
3727                         if (sCmp.Compare(sRev.Left(sCmp.GetLength()))==0)\r
3728                         {\r
3729                                 *pResult = i;\r
3730                                 return;\r
3731                         }\r
3732                 }\r
3733                 else\r
3734                 {\r
3735                         if (sCmp.Compare(sRev)==0)\r
3736                         {\r
3737                                 *pResult = i;\r
3738                                 return;\r
3739                         }\r
3740                 }\r
3741         }\r
3742         if (pFindInfo->lvfi.flags & LVFI_WRAP)\r
3743         {\r
3744                 for (int i=0; i<pFindInfo->iStart; ++i)\r
3745                 {\r
3746                         PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(i));\r
3747                         sRev.Format(_T("%ld"), pLogEntry->Rev);\r
3748                         if (pFindInfo->lvfi.flags & LVFI_PARTIAL)\r
3749                         {\r
3750                                 if (sCmp.Compare(sRev.Left(sCmp.GetLength()))==0)\r
3751                                 {\r
3752                                         *pResult = i;\r
3753                                         return;\r
3754                                 }\r
3755                         }\r
3756                         else\r
3757                         {\r
3758                                 if (sCmp.Compare(sRev)==0)\r
3759                                 {\r
3760                                         *pResult = i;\r
3761                                         return;\r
3762                                 }\r
3763                         }\r
3764                 }\r
3765         }\r
3766 #endif\r
3767         *pResult = -1;\r
3768 }\r
3769 \r
3770 void CLogDlg::OnBnClickedCheckStoponcopy()\r
3771 {\r
3772 #if 0\r
3773         if (!GetDlgItem(IDC_GETALL)->IsWindowEnabled())\r
3774                 return;\r
3775 \r
3776         // ignore old fetch limits when switching\r
3777         // between copy-following and stop-on-copy\r
3778         // (otherwise stop-on-copy will limit what\r
3779         // we see immediately after switching to\r
3780         // copy-following)\r
3781 \r
3782         m_endrev = 0;\r
3783 \r
3784         // now, restart the query\r
3785 #endif\r
3786         Refresh();\r
3787 }\r
3788 \r
3789 void CLogDlg::OnBnClickedIncludemerge()\r
3790 {\r
3791 #if 0\r
3792         m_endrev = 0;\r
3793 \r
3794         m_limit = 0;\r
3795 #endif\r
3796         Refresh();\r
3797 }\r
3798 \r
3799 void CLogDlg::UpdateLogInfoLabel()\r
3800 {\r
3801 #if 0\r
3802         git_revnum_t rev1 = 0;\r
3803         git_revnum_t rev2 = 0;\r
3804         long selectedrevs = 0;\r
3805         if (m_arShownList.GetCount())\r
3806         {\r
3807                 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(0));\r
3808                 rev1 = pLogEntry->Rev;\r
3809                 pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(m_arShownList.GetCount()-1));\r
3810                 rev2 = pLogEntry->Rev;\r
3811                 selectedrevs = m_LogList.GetSelectedCount();\r
3812         }\r
3813         CString sTemp;\r
3814         sTemp.Format(IDS_LOG_LOGINFOSTRING, m_arShownList.GetCount(), rev2, rev1, selectedrevs);\r
3815         m_sLogInfo = sTemp;\r
3816 #endif\r
3817         UpdateData(FALSE);\r
3818 }\r
3819 \r
3820 void CLogDlg::ShowContextMenuForRevisions(CWnd* /*pWnd*/, CPoint point)\r
3821 {\r
3822 \r
3823         int selIndex = m_LogList.GetSelectionMark();\r
3824         if (selIndex < 0)\r
3825                 return; // nothing selected, nothing to do with a context menu\r
3826 \r
3827         // if the user selected the info text telling about not all revisions shown due to\r
3828         // the "stop on copy/rename" option, we also don't show the context menu\r
3829         if ((m_bStrictStopped)&&(selIndex == m_arShownList.GetCount()))\r
3830                 return;\r
3831 \r
3832         // if the context menu is invoked through the keyboard, we have to use\r
3833         // a calculated position on where to anchor the menu on\r
3834         if ((point.x == -1) && (point.y == -1))\r
3835         {\r
3836                 CRect rect;\r
3837                 m_LogList.GetItemRect(selIndex, &rect, LVIR_LABEL);\r
3838                 m_LogList.ClientToScreen(&rect);\r
3839                 point = rect.CenterPoint();\r
3840         }\r
3841         m_nSearchIndex = selIndex;\r
3842         m_bCancelled = FALSE;\r
3843 \r
3844         // calculate some information the context menu commands can use\r
3845 //      CString pathURL = GetURLFromPath(m_path);\r
3846 \r
3847         POSITION pos = m_LogList.GetFirstSelectedItemPosition();\r
3848         int indexNext = m_LogList.GetNextSelectedItem(pos);\r
3849         if (indexNext < 0)\r
3850                 return;\r
3851 \r
3852         GitRev* pSelLogEntry = reinterpret_cast<GitRev*>(m_arShownList.GetAt(indexNext));\r
3853 #if 0\r
3854         GitRev revSelected = pSelLogEntry->Rev;\r
3855         GitRev revPrevious = git_revnum_t(revSelected)-1;\r
3856         if ((pSelLogEntry->pArChangedPaths)&&(pSelLogEntry->pArChangedPaths->GetCount() <= 2))\r
3857         {\r
3858                 for (int i=0; i<pSelLogEntry->pArChangedPaths->GetCount(); ++i)\r
3859                 {\r
3860                         LogChangedPath * changedpath = (LogChangedPath *)pSelLogEntry->pArChangedPaths->GetAt(i);\r
3861                         if (changedpath->lCopyFromRev)\r
3862                                 revPrevious = changedpath->lCopyFromRev;\r
3863                 }\r
3864         }\r
3865         GitRev revSelected2;\r
3866         if (pos)\r
3867         {\r
3868                 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(m_LogList.GetNextSelectedItem(pos)));\r
3869                 revSelected2 = pLogEntry->Rev;\r
3870         }\r
3871         bool bAllFromTheSameAuthor = true;\r
3872         CString firstAuthor;\r
3873         CLogDataVector selEntries;\r
3874         GitRev revLowest, revHighest;\r
3875         GitRevRangeArray revisionRanges;\r
3876         {\r
3877                 POSITION pos = m_LogList.GetFirstSelectedItemPosition();\r
3878                 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(m_LogList.GetNextSelectedItem(pos)));\r
3879                 revisionRanges.AddRevision(pLogEntry->Rev);\r
3880                 selEntries.push_back(pLogEntry);\r
3881                 firstAuthor = pLogEntry->sAuthor;\r
3882                 revLowest = pLogEntry->Rev;\r
3883                 revHighest = pLogEntry->Rev;\r
3884                 while (pos)\r
3885                 {\r
3886                         pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(m_LogList.GetNextSelectedItem(pos)));\r
3887                         revisionRanges.AddRevision(pLogEntry->Rev);\r
3888                         selEntries.push_back(pLogEntry);\r
3889                         if (firstAuthor.Compare(pLogEntry->sAuthor))\r
3890                                 bAllFromTheSameAuthor = false;\r
3891                         revLowest = (git_revnum_t(pLogEntry->Rev) > git_revnum_t(revLowest) ? revLowest : pLogEntry->Rev);\r
3892                         revHighest = (git_revnum_t(pLogEntry->Rev) < git_revnum_t(revHighest) ? revHighest : pLogEntry->Rev);\r
3893                 }\r
3894         }\r
3895 \r
3896 #endif\r
3897 \r
3898         int FirstSelect=-1, LastSelect=-1;\r
3899         pos = m_LogList.GetFirstSelectedItemPosition();\r
3900         FirstSelect = m_LogList.GetNextSelectedItem(pos);\r
3901         while(pos)\r
3902         {\r
3903                 LastSelect = m_LogList.GetNextSelectedItem(pos);\r
3904         }\r
3905         //entry is selected, now show the popup menu\r
3906         CIconMenu popup;\r
3907         if (popup.CreatePopupMenu())\r
3908         {\r
3909                 if (m_LogList.GetSelectedCount() == 1)\r
3910                 {\r
3911 #if 0\r
3912                         if (!m_path.IsDirectory())\r
3913                         {\r
3914                                 if (m_hasWC)\r
3915                                 {\r
3916                                         popup.AppendMenuIcon(ID_COMPARE, IDS_LOG_POPUP_COMPARE, IDI_DIFF);\r
3917                                         popup.AppendMenuIcon(ID_BLAMECOMPARE, IDS_LOG_POPUP_BLAMECOMPARE, IDI_BLAME);\r
3918                                 }\r
3919                                 popup.AppendMenuIcon(ID_GNUDIFF1, IDS_LOG_POPUP_GNUDIFF_CH, IDI_DIFF);\r
3920                                 popup.AppendMenuIcon(ID_COMPAREWITHPREVIOUS, IDS_LOG_POPUP_COMPAREWITHPREVIOUS, IDI_DIFF);\r
3921                                 popup.AppendMenu(MF_SEPARATOR, NULL);\r
3922                                 popup.AppendMenuIcon(ID_SAVEAS, IDS_LOG_POPUP_SAVE, IDI_SAVEAS);\r
3923                                 popup.AppendMenuIcon(ID_OPEN, IDS_LOG_POPUP_OPEN, IDI_OPEN);\r
3924                                 popup.AppendMenuIcon(ID_OPENWITH, IDS_LOG_POPUP_OPENWITH, IDI_OPEN);\r
3925                                 popup.AppendMenuIcon(ID_BLAME, IDS_LOG_POPUP_BLAME, IDI_BLAME);\r
3926                                 popup.AppendMenu(MF_SEPARATOR, NULL);\r
3927                         }\r
3928                         else\r
3929 #endif \r
3930                         {\r
3931                                 if (m_hasWC)\r
3932                                 {\r
3933                                         popup.AppendMenuIcon(ID_COMPARE, IDS_LOG_POPUP_COMPARE, IDI_DIFF);\r
3934                                         // TODO:\r
3935                                         // TortoiseMerge could be improved to take a /blame switch\r
3936                                         // and then not 'cat' the files from a unified diff but\r
3937                                         // blame then.\r
3938                                         // But until that's implemented, the context menu entry for\r
3939                                         // this feature is commented out.\r
3940                                         //popup.AppendMenu(ID_BLAMECOMPARE, IDS_LOG_POPUP_BLAMECOMPARE, IDI_BLAME);\r
3941                                 }\r
3942                                 popup.AppendMenuIcon(ID_GNUDIFF1, IDS_LOG_POPUP_GNUDIFF_CH, IDI_DIFF);\r
3943                                 popup.AppendMenuIcon(ID_COMPAREWITHPREVIOUS, IDS_LOG_POPUP_COMPAREWITHPREVIOUS, IDI_DIFF);\r
3944                                 popup.AppendMenuIcon(ID_BLAMEWITHPREVIOUS, IDS_LOG_POPUP_BLAMEWITHPREVIOUS, IDI_BLAME);\r
3945                                 popup.AppendMenu(MF_SEPARATOR, NULL);\r
3946                         }\r
3947 \r
3948 //                      if (!m_ProjectProperties.sWebViewerRev.IsEmpty())\r
3949 //                      {\r
3950 //                              popup.AppendMenuIcon(ID_VIEWREV, IDS_LOG_POPUP_VIEWREV);\r
3951 //                      }\r
3952 //                      if (!m_ProjectProperties.sWebViewerPathRev.IsEmpty())\r
3953 //                      {\r
3954 //                              popup.AppendMenuIcon(ID_VIEWPATHREV, IDS_LOG_POPUP_VIEWPATHREV);\r
3955 //                      }\r
3956 //                      if ((!m_ProjectProperties.sWebViewerPathRev.IsEmpty())||\r
3957 //                              (!m_ProjectProperties.sWebViewerRev.IsEmpty()))\r
3958 //                      {\r
3959 //                              popup.AppendMenu(MF_SEPARATOR, NULL);\r
3960 //                      }\r
3961 \r
3962 //                      popup.AppendMenuIcon(ID_REPOBROWSE, IDS_LOG_BROWSEREPO, IDI_REPOBROWSE);\r
3963 //                      popup.AppendMenuIcon(ID_COPY, IDS_LOG_POPUP_COPY);\r
3964 //                      if (m_hasWC)\r
3965 //                              popup.AppendMenuIcon(ID_UPDATE, IDS_LOG_POPUP_UPDATE, IDI_UPDATE);\r
3966                         if (m_hasWC)\r
3967                                 popup.AppendMenuIcon(ID_REVERTTOREV, IDS_LOG_POPUP_REVERTTOREV, IDI_REVERT);\r
3968                         if (m_hasWC)\r
3969                                 popup.AppendMenuIcon(ID_REVERTREV, IDS_LOG_POPUP_REVERTREV, IDI_REVERT);\r
3970 //                      if (m_hasWC)\r
3971 //                              popup.AppendMenuIcon(ID_MERGEREV, IDS_LOG_POPUP_MERGEREV, IDI_MERGE);\r
3972                         popup.AppendMenuIcon(ID_CHECKOUT, IDS_MENUCHECKOUT, IDI_CHECKOUT);\r
3973                         popup.AppendMenuIcon(ID_EXPORT, IDS_MENUEXPORT, IDI_EXPORT);\r
3974                         popup.AppendMenu(MF_SEPARATOR, NULL);\r
3975                 }\r
3976                 else if (m_LogList.GetSelectedCount() >= 2)\r
3977                 {\r
3978                         bool bAddSeparator = false;\r
3979                         if (IsSelectionContinuous() || (m_LogList.GetSelectedCount() == 2))\r
3980                         {\r
3981                                 popup.AppendMenuIcon(ID_COMPARETWO, IDS_LOG_POPUP_COMPARETWO, IDI_DIFF);\r
3982                         }\r
3983                         if (m_LogList.GetSelectedCount() == 2)\r
3984                         {\r
3985                                 popup.AppendMenuIcon(ID_BLAMETWO, IDS_LOG_POPUP_BLAMEREVS, IDI_BLAME);\r
3986                                 popup.AppendMenuIcon(ID_GNUDIFF2, IDS_LOG_POPUP_GNUDIFF, IDI_DIFF);\r
3987                                 bAddSeparator = true;\r
3988                         }\r
3989                         if (m_hasWC)\r
3990                         {\r
3991                                 popup.AppendMenuIcon(ID_REVERTREV, IDS_LOG_POPUP_REVERTREVS, IDI_REVERT);\r
3992 //                              if (m_hasWC)\r
3993 //                                      popup.AppendMenuIcon(ID_MERGEREV, IDS_LOG_POPUP_MERGEREVS, IDI_MERGE);\r
3994                                 bAddSeparator = true;\r
3995                         }\r
3996                         if (bAddSeparator)\r
3997                                 popup.AppendMenu(MF_SEPARATOR, NULL);\r
3998                 }\r
3999 #if 0\r
4000 //              if ((selEntries.size() > 0)&&(bAllFromTheSameAuthor))\r
4001 //              {\r
4002 //                      popup.AppendMenuIcon(ID_EDITAUTHOR, IDS_LOG_POPUP_EDITAUTHOR);\r
4003 //              }\r
4004 //              if (m_LogList.GetSelectedCount() == 1)\r
4005 //              {\r
4006 //                      popup.AppendMenuIcon(ID_EDITLOG, IDS_LOG_POPUP_EDITLOG);\r
4007 //                      popup.AppendMenuIcon(ID_REVPROPS, IDS_REPOBROWSE_SHOWREVPROP, IDI_PROPERTIES); // "Show Revision Properties"\r
4008 //                      popup.AppendMenu(MF_SEPARATOR, NULL);\r
4009 //              }\r
4010 #endif\r
4011                 if (m_LogList.GetSelectedCount() != 0)\r
4012                 {\r
4013                         popup.AppendMenuIcon(ID_COPYCLIPBOARD, IDS_LOG_POPUP_COPYTOCLIPBOARD);\r
4014                 }\r
4015                 popup.AppendMenuIcon(ID_FINDENTRY, IDS_LOG_POPUP_FIND);\r
4016 \r
4017                 int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this, 0);\r
4018                 DialogEnableWindow(IDOK, FALSE);\r
4019 //              SetPromptApp(&theApp);\r
4020                 theApp.DoWaitCursor(1);\r
4021                 bool bOpenWith = false;\r
4022 \r
4023                 switch (cmd)\r
4024                 {\r
4025                         case ID_GNUDIFF1:\r
4026                         {\r
4027                                 CString tempfile=GetTempFile();\r
4028                                 CString cmd;\r
4029                                 GitRev * r1 = reinterpret_cast<GitRev*>(m_arShownList.GetAt(FirstSelect));\r
4030                                 cmd.Format(_T("git.cmd diff-tree -r -p --stat %s"),r1->m_CommitHash);\r
4031                                 g_Git.RunLogFile(cmd,tempfile);\r
4032                                 CAppUtils::StartUnifiedDiffViewer(tempfile,r1->m_CommitHash.Left(6)+_T(":")+r1->m_Subject);\r
4033                         }\r
4034                         break;\r
4035 \r
4036                         case ID_GNUDIFF2:\r
4037                         {\r
4038                                 CString tempfile=GetTempFile();\r
4039                                 CString cmd;\r
4040                                 GitRev * r1 = reinterpret_cast<GitRev*>(m_arShownList.GetAt(FirstSelect));\r
4041                                 GitRev * r2 = reinterpret_cast<GitRev*>(m_arShownList.GetAt(LastSelect));\r
4042                                 cmd.Format(_T("git.cmd diff-tree -r -p --stat %s %s"),r1->m_CommitHash,r2->m_CommitHash);\r
4043                                 g_Git.RunLogFile(cmd,tempfile);\r
4044                                 CAppUtils::StartUnifiedDiffViewer(tempfile,r1->m_CommitHash.Left(6)+_T(":")+r2->m_CommitHash.Left(6));\r
4045 \r
4046                         }\r
4047                         break;\r
4048 \r
4049                 case ID_COMPARETWO:\r
4050                         {\r
4051                                 GitRev * r1 = reinterpret_cast<GitRev*>(m_arShownList.GetAt(FirstSelect));\r
4052                                 GitRev * r2 = reinterpret_cast<GitRev*>(m_arShownList.GetAt(LastSelect));\r
4053                                 CFileDiffDlg dlg;\r
4054                                 dlg.SetDiff(NULL,*r1,*r2);\r
4055                                 dlg.DoModal();\r
4056                                 \r
4057                         }\r
4058                         break;\r
4059 \r
4060 #if 0\r
4061                 case ID_GNUDIFF1:\r
4062                         {\r
4063                                 if (PromptShown())\r
4064                                 {\r
4065                                         GitDiff diff(this, this->m_hWnd, true);\r
4066                                         diff.SetHEADPeg(m_LogRevision);\r
4067                                         diff.ShowUnifiedDiff(m_path, revPrevious, m_path, revSelected);\r
4068                                 }\r
4069                                 else\r
4070                                         CAppUtils::StartShowUnifiedDiff(m_hWnd, m_path, revPrevious, m_path, revSelected, GitRev(), m_LogRevision);\r
4071                         }\r
4072                         break;\r
4073 \r
4074                 case ID_GNUDIFF2:\r
4075                         {\r
4076                                 if (PromptShown())\r
4077                                 {\r
4078                                         GitDiff diff(this, this->m_hWnd, true);\r
4079                                         diff.SetHEADPeg(m_LogRevision);\r
4080                                         diff.ShowUnifiedDiff(m_path, revSelected2, m_path, revSelected);\r
4081                                 }\r
4082                                 else\r
4083                                         CAppUtils::StartShowUnifiedDiff(m_hWnd, m_path, revSelected2, m_path, revSelected, GitRev(), m_LogRevision);\r
4084                         }\r
4085                         break;\r
4086                 case ID_REVERTREV:\r
4087                         {\r
4088                                 // we need an URL to complete this command, so error out if we can't get an URL\r
4089                                 if (pathURL.IsEmpty())\r
4090                                 {\r
4091                                         CString strMessage;\r
4092                                         strMessage.Format(IDS_ERR_NOURLOFFILE, (LPCTSTR)(m_path.GetUIPathString()));\r
4093                                         CMessageBox::Show(this->m_hWnd, strMessage, _T("TortoiseGit"), MB_ICONERROR);\r
4094                                         TRACE(_T("could not retrieve the URL of the folder!\n"));\r
4095                                         break;          //exit\r
4096                                 }\r
4097                                 CString msg;\r
4098                                 msg.Format(IDS_LOG_REVERT_CONFIRM, m_path.GetWinPath());\r
4099                                 if (CMessageBox::Show(this->m_hWnd, msg, _T("TortoiseGit"), MB_YESNO | MB_ICONQUESTION) == IDYES)\r
4100                                 {\r
4101                                         CGitProgressDlg dlg;\r
4102                                         dlg.SetCommand(CGitProgressDlg::GitProgress_Merge);\r
4103                                         dlg.SetPathList(CTGitPathList(m_path));\r
4104                                         dlg.SetUrl(pathURL);\r
4105                                         dlg.SetSecondUrl(pathURL);\r
4106                                         revisionRanges.AdjustForMerge(true);\r
4107                                         dlg.SetRevisionRanges(revisionRanges);\r
4108                                         dlg.SetPegRevision(m_LogRevision);\r
4109                                         dlg.DoModal();\r
4110                                 }\r
4111                         }\r
4112                         break;\r
4113                 case ID_MERGEREV:\r
4114                         {\r
4115                                 // we need an URL to complete this command, so error out if we can't get an URL\r
4116                                 if (pathURL.IsEmpty())\r
4117                                 {\r
4118                                         CString strMessage;\r
4119                                         strMessage.Format(IDS_ERR_NOURLOFFILE, (LPCTSTR)(m_path.GetUIPathString()));\r
4120                                         CMessageBox::Show(this->m_hWnd, strMessage, _T("TortoiseGit"), MB_ICONERROR);\r
4121                                         TRACE(_T("could not retrieve the URL of the folder!\n"));\r
4122                                         break;          //exit\r
4123                                 }\r
4124 \r
4125                                 CString path = m_path.GetWinPathString();\r
4126                                 bool bGotSavePath = false;\r
4127                                 if ((m_LogList.GetSelectedCount() == 1)&&(!m_path.IsDirectory()))\r
4128                                 {\r
4129                                         bGotSavePath = CAppUtils::FileOpenSave(path, NULL, IDS_LOG_MERGETO, IDS_COMMONFILEFILTER, true, GetSafeHwnd());\r
4130                                 }\r
4131                                 else\r
4132                                 {\r
4133                                         CBrowseFolder folderBrowser;\r
4134                                         folderBrowser.SetInfo(CString(MAKEINTRESOURCE(IDS_LOG_MERGETO)));\r
4135                                         bGotSavePath = (folderBrowser.Show(GetSafeHwnd(), path, path) == CBrowseFolder::OK);\r
4136                                 }\r
4137                                 if (bGotSavePath)\r
4138                                 {\r
4139                                         CGitProgressDlg dlg;\r
4140                                         dlg.SetCommand(CGitProgressDlg::GitProgress_Merge);\r
4141                                         dlg.SetPathList(CTGitPathList(CTGitPath(path)));\r
4142                                         dlg.SetUrl(pathURL);\r
4143                                         dlg.SetSecondUrl(pathURL);\r
4144                                         revisionRanges.AdjustForMerge(false);\r
4145                                         dlg.SetRevisionRanges(revisionRanges);\r
4146                                         dlg.SetPegRevision(m_LogRevision);\r
4147                                         dlg.DoModal();\r
4148                                 }\r
4149                         }\r
4150                         break;\r
4151                 case ID_REVERTTOREV:\r
4152                         {\r
4153                                 // we need an URL to complete this command, so error out if we can't get an URL\r
4154                                 if (pathURL.IsEmpty())\r
4155                                 {\r
4156                                         CString strMessage;\r
4157                                         strMessage.Format(IDS_ERR_NOURLOFFILE, (LPCTSTR)(m_path.GetUIPathString()));\r
4158                                         CMessageBox::Show(this->m_hWnd, strMessage, _T("TortoiseGit"), MB_ICONERROR);\r
4159                                         TRACE(_T("could not retrieve the URL of the folder!\n"));\r
4160                                         break;          //exit\r
4161                                 }\r
4162 \r
4163                                 CString msg;\r
4164                                 msg.Format(IDS_LOG_REVERTTOREV_CONFIRM, m_path.GetWinPath());\r
4165                                 if (CMessageBox::Show(this->m_hWnd, msg, _T("TortoiseGit"), MB_YESNO | MB_ICONQUESTION) == IDYES)\r
4166                                 {\r
4167                                         CGitProgressDlg dlg;\r
4168                                         dlg.SetCommand(CGitProgressDlg::GitProgress_Merge);\r
4169                                         dlg.SetPathList(CTGitPathList(m_path));\r
4170                                         dlg.SetUrl(pathURL);\r
4171                                         dlg.SetSecondUrl(pathURL);\r
4172                                         GitRevRangeArray revarray;\r
4173                                         revarray.AddRevRange(GitRev::REV_HEAD, revSelected);\r
4174                                         dlg.SetRevisionRanges(revarray);\r
4175                                         dlg.SetPegRevision(m_LogRevision);\r
4176                                         dlg.DoModal();\r
4177                                 }\r
4178                         }\r
4179                         break;\r
4180                 case ID_COPY:\r
4181                         {\r
4182                                 // we need an URL to complete this command, so error out if we can't get an URL\r
4183                                 if (pathURL.IsEmpty())\r
4184                                 {\r
4185                                         CString strMessage;\r
4186                                         strMessage.Format(IDS_ERR_NOURLOFFILE, (LPCTSTR)(m_path.GetUIPathString()));\r
4187                                         CMessageBox::Show(this->m_hWnd, strMessage, _T("TortoiseGit"), MB_ICONERROR);\r
4188                                         TRACE(_T("could not retrieve the URL of the folder!\n"));\r
4189                                         break;          //exit\r
4190                                 }\r
4191 \r
4192                                 CCopyDlg dlg;\r
4193                                 dlg.m_URL = pathURL;\r
4194                                 dlg.m_path = m_path;\r
4195                                 dlg.m_CopyRev = revSelected;\r
4196                                 if (dlg.DoModal() == IDOK)\r
4197                                 {\r
4198                                         // should we show a progress dialog here? Copies are done really fast\r
4199                                         // and without much network traffic.\r
4200                                         if (!Copy(CTGitPathList(CTGitPath(pathURL)), CTGitPath(dlg.m_URL), dlg.m_CopyRev, dlg.m_CopyRev, dlg.m_sLogMessage))\r
4201                                                 CMessageBox::Show(this->m_hWnd, GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);\r
4202                                         else\r
4203                                                 CMessageBox::Show(this->m_hWnd, IDS_LOG_COPY_SUCCESS, IDS_APPNAME, MB_ICONINFORMATION);\r
4204                                 }\r
4205                         } \r
4206                         break;\r
4207                 case ID_COMPARE:\r
4208                         {\r
4209                                 //user clicked on the menu item "compare with working copy"\r
4210                                 if (PromptShown())\r
4211                                 {\r
4212                                         GitDiff diff(this, m_hWnd, true);\r
4213                                         diff.SetAlternativeTool(!!(GetAsyncKeyState(VK_SHIFT) & 0x8000));\r
4214                                         diff.SetHEADPeg(m_LogRevision);\r
4215                                         diff.ShowCompare(m_path, GitRev::REV_WC, m_path, revSelected);\r
4216                                 }\r
4217                                 else\r
4218                                         CAppUtils::StartShowCompare(m_hWnd, m_path, GitRev::REV_WC, m_path, revSelected, GitRev(), m_LogRevision, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000));\r
4219                         }\r
4220                         break;\r
4221                 case ID_COMPARETWO:\r
4222                         {\r
4223                                 GitRev r1 = revSelected;\r
4224                                 GitRev r2 = revSelected2;\r
4225                                 if (m_LogList.GetSelectedCount() > 2)\r
4226                                 {\r
4227                                         r1 = revHighest;\r
4228                                         r2 = revLowest;\r
4229                                 }\r
4230                                 //user clicked on the menu item "compare revisions"\r
4231                                 if (PromptShown())\r
4232                                 {\r
4233                                         GitDiff diff(this, m_hWnd, true);\r
4234                                         diff.SetAlternativeTool(!!(GetAsyncKeyState(VK_SHIFT) & 0x8000));\r
4235                                         diff.SetHEADPeg(m_LogRevision);\r
4236                                         diff.ShowCompare(CTGitPath(pathURL), r2, CTGitPath(pathURL), r1);\r
4237                                 }\r
4238                                 else\r
4239                                         CAppUtils::StartShowCompare(m_hWnd, CTGitPath(pathURL), r2, CTGitPath(pathURL), r1, GitRev(), m_LogRevision, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000));\r
4240                         }\r
4241                         break;\r
4242                 case ID_COMPAREWITHPREVIOUS:\r
4243                         {\r
4244                                 if (PromptShown())\r
4245                                 {\r
4246                                         GitDiff diff(this, m_hWnd, true);\r
4247                                         diff.SetAlternativeTool(!!(GetAsyncKeyState(VK_SHIFT) & 0x8000));\r
4248                                         diff.SetHEADPeg(m_LogRevision);\r
4249                                         diff.ShowCompare(CTGitPath(pathURL), revPrevious, CTGitPath(pathURL), revSelected);\r
4250                                 }\r
4251                                 else\r
4252                                         CAppUtils::StartShowCompare(m_hWnd, CTGitPath(pathURL), revPrevious, CTGitPath(pathURL), revSelected, GitRev(), m_LogRevision, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000));\r
4253                         }\r
4254                         break;\r
4255                 case ID_BLAMECOMPARE:\r
4256                         {\r
4257                                 //user clicked on the menu item "compare with working copy"\r
4258                                 //now first get the revision which is selected\r
4259                                 if (PromptShown())\r
4260                                 {\r
4261                                         GitDiff diff(this, this->m_hWnd, true);\r
4262                                         diff.SetHEADPeg(m_LogRevision);\r
4263                                         diff.ShowCompare(m_path, GitRev::REV_BASE, m_path, revSelected, GitRev(), false, true);\r
4264                                 }\r
4265                                 else\r
4266                                         CAppUtils::StartShowCompare(m_hWnd, m_path, GitRev::REV_BASE, m_path, revSelected, GitRev(), m_LogRevision, false, false, true);\r
4267                         }\r
4268                         break;\r
4269                 case ID_BLAMETWO:\r
4270                         {\r
4271                                 //user clicked on the menu item "compare and blame revisions"\r
4272                                 if (PromptShown())\r
4273                                 {\r
4274                                         GitDiff diff(this, this->m_hWnd, true);\r
4275                                         diff.SetHEADPeg(m_LogRevision);\r
4276                                         diff.ShowCompare(CTGitPath(pathURL), revSelected2, CTGitPath(pathURL), revSelected, GitRev(), false, true);\r
4277                                 }\r
4278                                 else\r
4279                                         CAppUtils::StartShowCompare(m_hWnd, CTGitPath(pathURL), revSelected2, CTGitPath(pathURL), revSelected, GitRev(), m_LogRevision, false, false, true);\r
4280                         }\r
4281                         break;\r
4282                 case ID_BLAMEWITHPREVIOUS:\r
4283                         {\r
4284                                 //user clicked on the menu item "Compare and Blame with previous revision"\r
4285                                 if (PromptShown())\r
4286                                 {\r
4287                                         GitDiff diff(this, this->m_hWnd, true);\r
4288                                         diff.SetHEADPeg(m_LogRevision);\r
4289                                         diff.ShowCompare(CTGitPath(pathURL), revPrevious, CTGitPath(pathURL), revSelected, GitRev(), false, true);\r
4290                                 }\r
4291                                 else\r
4292                                         CAppUtils::StartShowCompare(m_hWnd, CTGitPath(pathURL), revPrevious, CTGitPath(pathURL), revSelected, GitRev(), m_LogRevision, false, false, true);\r
4293                         }\r
4294                         break;\r
4295                 case ID_SAVEAS:\r
4296                         {\r
4297                                 //now first get the revision which is selected\r
4298                                 CString revFilename;\r
4299                                 if (m_hasWC)\r
4300                                 {\r
4301                                         CString strWinPath = m_path.GetWinPathString();\r
4302                                         int rfind = strWinPath.ReverseFind('.');\r
4303                                         if (rfind > 0)\r
4304                                                 revFilename.Format(_T("%s-%ld%s"), (LPCTSTR)strWinPath.Left(rfind), (LONG)revSelected, (LPCTSTR)strWinPath.Mid(rfind));\r
4305                                         else\r
4306                                                 revFilename.Format(_T("%s-%ld"), (LPCTSTR)strWinPath, revSelected);\r
4307                                 }\r
4308                                 if (CAppUtils::FileOpenSave(revFilename, NULL, IDS_LOG_POPUP_SAVE, IDS_COMMONFILEFILTER, false, m_hWnd))\r
4309                                 {\r
4310                                         CTGitPath tempfile;\r
4311                                         tempfile.SetFromWin(revFilename);\r
4312                                         CProgressDlg progDlg;\r
4313                                         progDlg.SetTitle(IDS_APPNAME);\r
4314                                         progDlg.SetAnimation(IDR_DOWNLOAD);\r
4315                                         CString sInfoLine;\r
4316                                         sInfoLine.Format(IDS_PROGRESSGETFILEREVISION, m_path.GetWinPath(), (LPCTSTR)revSelected.ToString());\r
4317                                         progDlg.SetLine(1, sInfoLine, true);\r
4318                                         SetAndClearProgressInfo(&progDlg);\r
4319                                         progDlg.ShowModeless(m_hWnd);\r
4320                                         if (!Cat(m_path, GitRev(GitRev::REV_HEAD), revSelected, tempfile))\r
4321                                         {\r
4322                                                 // try again with another peg revision\r
4323                                                 if (!Cat(m_path, revSelected, revSelected, tempfile))\r
4324                                                 {\r
4325                                                         progDlg.Stop();\r
4326                                                         SetAndClearProgressInfo((HWND)NULL);\r
4327                                                         CMessageBox::Show(this->m_hWnd, GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);\r
4328                                                         EnableOKButton();\r
4329                                                         break;\r
4330                                                 }\r
4331                                         }\r
4332                                         progDlg.Stop();\r
4333                                         SetAndClearProgressInfo((HWND)NULL);\r
4334                                 }\r
4335                         }\r
4336                         break;\r
4337                 case ID_OPENWITH:\r
4338                         bOpenWith = true;\r
4339                 case ID_OPEN:\r
4340                         {\r
4341                                 CProgressDlg progDlg;\r
4342                                 progDlg.SetTitle(IDS_APPNAME);\r
4343                                 progDlg.SetAnimation(IDR_DOWNLOAD);\r
4344                                 CString sInfoLine;\r
4345                                 sInfoLine.Format(IDS_PROGRESSGETFILEREVISION, m_path.GetWinPath(), (LPCTSTR)revSelected.ToString());\r
4346                                 progDlg.SetLine(1, sInfoLine, true);\r
4347                                 SetAndClearProgressInfo(&progDlg);\r
4348                                 progDlg.ShowModeless(m_hWnd);\r
4349                                 CTGitPath tempfile = CTempFiles::Instance().GetTempFilePath(false, m_path, revSelected);\r
4350                                 bool bSuccess = true;\r
4351                                 if (!Cat(m_path, GitRev(GitRev::REV_HEAD), revSelected, tempfile))\r
4352                                 {\r
4353                                         bSuccess = false;\r
4354                                         // try again, but with the selected revision as the peg revision\r
4355                                         if (!Cat(m_path, revSelected, revSelected, tempfile))\r
4356                                         {\r
4357                                                 progDlg.Stop();\r
4358                                                 SetAndClearProgressInfo((HWND)NULL);\r
4359                                                 CMessageBox::Show(this->m_hWnd, GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);\r
4360                                                 EnableOKButton();\r
4361                                                 break;\r
4362                                         }\r
4363                                         bSuccess = true;\r
4364                                 }\r
4365                                 if (bSuccess)\r
4366                                 {\r
4367                                         progDlg.Stop();\r
4368                                         SetAndClearProgressInfo((HWND)NULL);\r
4369                                         SetFileAttributes(tempfile.GetWinPath(), FILE_ATTRIBUTE_READONLY);\r
4370                                         int ret = 0;\r
4371                                         if (!bOpenWith)\r
4372                                                 ret = (int)ShellExecute(this->m_hWnd, NULL, tempfile.GetWinPath(), NULL, NULL, SW_SHOWNORMAL);\r
4373                                         if ((ret <= HINSTANCE_ERROR)||bOpenWith)\r
4374                                         {\r
4375                                                 CString cmd = _T("RUNDLL32 Shell32,OpenAs_RunDLL ");\r
4376                                                 cmd += tempfile.GetWinPathString() + _T(" ");\r
4377                                                 CAppUtils::LaunchApplication(cmd, NULL, false);\r
4378                                         }\r
4379                                 }\r
4380                         }\r
4381                         break;\r
4382                 case ID_BLAME:\r
4383                         {\r
4384                                 CBlameDlg dlg;\r
4385                                 dlg.EndRev = revSelected;\r
4386                                 if (dlg.DoModal() == IDOK)\r
4387                                 {\r
4388                                         CBlame blame;\r
4389                                         CString tempfile;\r
4390                                         CString logfile;\r
4391                                         tempfile = blame.BlameToTempFile(m_path, dlg.StartRev, dlg.EndRev, dlg.EndRev, logfile, _T(""), dlg.m_bIncludeMerge, TRUE, TRUE);\r
4392                                         if (!tempfile.IsEmpty())\r
4393                                         {\r
4394                                                 if (dlg.m_bTextView)\r
4395                                                 {\r
4396                                                         //open the default text editor for the result file\r
4397                                                         CAppUtils::StartTextViewer(tempfile);\r
4398                                                 }\r
4399                                                 else\r
4400                                                 {\r
4401                                                         CString sParams = _T("/path:\"") + m_path.GetGitPathString() + _T("\" ");\r
4402                                                         if(!CAppUtils::LaunchTortoiseBlame(tempfile, logfile, CPathUtils::GetFileNameFromPath(m_path.GetFileOrDirectoryName()),sParams))\r
4403                                                         {\r
4404                                                                 break;\r
4405                                                         }\r
4406                                                 }\r
4407                                         }\r
4408                                         else\r
4409                                         {\r
4410                                                 CMessageBox::Show(this->m_hWnd, blame.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);\r
4411                                         }\r
4412                                 }\r
4413                         }\r
4414                         break;\r
4415                 case ID_UPDATE:\r
4416                         {\r
4417                                 CString sCmd;\r
4418                                 CString url = _T("tgit:")+pathURL;\r
4419                                 sCmd.Format(_T("%s /command:update /path:\"%s\" /rev:%ld"),\r
4420                                         (LPCTSTR)(CPathUtils::GetAppDirectory()+_T("TortoiseProc.exe")),\r
4421                                         (LPCTSTR)m_path.GetWinPath(), (LONG)revSelected);\r
4422                                 CAppUtils::LaunchApplication(sCmd, NULL, false);\r
4423                         }\r
4424                         break;\r
4425                 case ID_FINDENTRY:\r
4426                         {\r
4427                                 m_nSearchIndex = m_LogList.GetSelectionMark();\r
4428                                 if (m_nSearchIndex < 0)\r
4429                                         m_nSearchIndex = 0;\r
4430                                 if (m_pFindDialog)\r
4431                                 {\r
4432                                         break;\r
4433                                 }\r
4434                                 else\r
4435                                 {\r
4436                                         m_pFindDialog = new CFindReplaceDialog();\r
4437                                         m_pFindDialog->Create(TRUE, NULL, NULL, FR_HIDEUPDOWN | FR_HIDEWHOLEWORD, this);                                                                        \r
4438                                 }\r
4439                         }\r
4440                         break;\r
4441                 case ID_REPOBROWSE:\r
4442                         {\r
4443                                 CString sCmd;\r
4444                                 sCmd.Format(_T("%s /command:repobrowser /path:\"%s\" /rev:%s"),\r
4445                                         (LPCTSTR)(CPathUtils::GetAppDirectory()+_T("TortoiseProc.exe")),\r
4446                                         (LPCTSTR)pathURL, (LPCTSTR)revSelected.ToString());\r
4447 \r
4448                                 CAppUtils::LaunchApplication(sCmd, NULL, false);\r
4449                         }\r
4450                         break;\r
4451                 case ID_EDITLOG:\r
4452                         {\r
4453                                 EditLogMessage(selIndex);\r
4454                         }\r
4455                         break;\r
4456                 case ID_EDITAUTHOR:\r
4457                         {\r
4458                                 EditAuthor(selEntries);\r
4459                         }\r
4460                         break;\r
4461                 case ID_REVPROPS:\r
4462                         {\r
4463                                 CEditPropertiesDlg dlg;\r
4464                                 dlg.SetProjectProperties(&m_ProjectProperties);\r
4465                                 CTGitPathList escapedlist;\r
4466                                 dlg.SetPathList(CTGitPathList(CTGitPath(pathURL)));\r
4467                                 dlg.SetRevision(revSelected);\r
4468                                 dlg.RevProps(true);\r
4469                                 dlg.DoModal();\r
4470                         }\r
4471                         break;\r
4472                 case ID_COPYCLIPBOARD:\r
4473                         {\r
4474                                 CopySelectionToClipBoard();\r
4475                         }\r
4476                         break;\r
4477                 case ID_EXPORT:\r
4478                         {\r
4479                                 CString sCmd;\r
4480                                 sCmd.Format(_T("%s /command:export /path:\"%s\" /revision:%ld"),\r
4481                                         (LPCTSTR)(CPathUtils::GetAppDirectory()+_T("TortoiseProc.exe")),\r
4482                                         (LPCTSTR)pathURL, (LONG)revSelected);\r
4483                                 CAppUtils::LaunchApplication(sCmd, NULL, false);\r
4484                         }\r
4485                         break;\r
4486                 case ID_CHECKOUT:\r
4487                         {\r
4488                                 CString sCmd;\r
4489                                 CString url = _T("tgit:")+pathURL;\r
4490                                 sCmd.Format(_T("%s /command:checkout /url:\"%s\" /revision:%ld"),\r
4491                                         (LPCTSTR)(CPathUtils::GetAppDirectory()+_T("TortoiseProc.exe")),\r
4492                                         (LPCTSTR)url, (LONG)revSelected);\r
4493                                 CAppUtils::LaunchApplication(sCmd, NULL, false);\r
4494                         }\r
4495                         break;\r
4496                 case ID_VIEWREV:\r
4497                         {\r
4498                                 CString url = m_ProjectProperties.sWebViewerRev;\r
4499                                 url = GetAbsoluteUrlFromRelativeUrl(url);\r
4500                                 url.Replace(_T("%REVISION%"), revSelected.ToString());\r
4501                                 if (!url.IsEmpty())\r
4502                                         ShellExecute(this->m_hWnd, _T("open"), url, NULL, NULL, SW_SHOWDEFAULT);                                        \r
4503                         }\r
4504                         break;\r
4505                 case ID_VIEWPATHREV:\r
4506                         {\r
4507                                 CString relurl = pathURL;\r
4508                                 CString sRoot = GetRepositoryRoot(CTGitPath(relurl));\r
4509                                 relurl = relurl.Mid(sRoot.GetLength());\r
4510                                 CString url = m_ProjectProperties.sWebViewerPathRev;\r
4511                                 url = GetAbsoluteUrlFromRelativeUrl(url);\r
4512                                 url.Replace(_T("%REVISION%"), revSelected.ToString());\r
4513                                 url.Replace(_T("%PATH%"), relurl);\r
4514                                 if (!url.IsEmpty())\r
4515                                         ShellExecute(this->m_hWnd, _T("open"), url, NULL, NULL, SW_SHOWDEFAULT);                                        \r
4516                         }\r
4517                         break;\r
4518 #endif\r
4519                 default:\r
4520                         break;\r
4521                 } // switch (cmd)\r
4522                 theApp.DoWaitCursor(-1);\r
4523                 EnableOKButton();\r
4524         } // if (popup.CreatePopupMenu())\r
4525 }\r
4526 \r
4527 void CLogDlg::ShowContextMenuForChangedpaths(CWnd* /*pWnd*/, CPoint point)\r
4528 {\r
4529 \r
4530         int selIndex = m_ChangedFileListCtrl.GetSelectionMark();\r
4531         if ((point.x == -1) && (point.y == -1))\r
4532         {\r
4533                 CRect rect;\r
4534                 m_ChangedFileListCtrl.GetItemRect(selIndex, &rect, LVIR_LABEL);\r
4535                 m_ChangedFileListCtrl.ClientToScreen(&rect);\r
4536                 point = rect.CenterPoint();\r
4537         }\r
4538         if (selIndex < 0)\r
4539                 return;\r
4540         int s = m_LogList.GetSelectionMark();\r
4541         if (s < 0)\r
4542                 return;\r
4543         std::vector<CString> changedpaths;\r
4544         std::vector<LogChangedPath*> changedlogpaths;\r
4545         POSITION pos = m_LogList.GetFirstSelectedItemPosition();\r
4546         if (pos == NULL)\r
4547                 return; // nothing is selected, get out of here\r
4548 \r
4549         bool bOneRev = true;\r
4550         int sel=m_LogList.GetNextSelectedItem(pos);\r
4551         GitRev * pLogEntry = reinterpret_cast<GitRev *>(m_arShownList.GetAt(sel));\r
4552         GitRev * rev1 = pLogEntry;\r
4553         GitRev * rev2 = reinterpret_cast<GitRev *>(m_arShownList.GetAt(sel+1));\r
4554 #if 0\r
4555         bool bOneRev = true;\r
4556         if (pos)\r
4557         {\r
4558                 while (pos)\r
4559                 {\r
4560                         pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(m_LogList.GetNextSelectedItem(pos)));\r
4561                         if (pLogEntry)\r
4562                         {\r
4563                                 rev1 = max(rev1,(git_revnum_t)pLogEntry->Rev);\r
4564                                 rev2 = min(rev2,(git_revnum_t)pLogEntry->Rev);\r
4565                                 bOneRev = false;\r
4566                         }                               \r
4567                 }\r
4568                 if (!bOneRev)\r
4569                         rev2--;\r
4570                 POSITION pos = m_ChangedFileListCtrl.GetFirstSelectedItemPosition();\r
4571                 while (pos)\r
4572                 {\r
4573                         int nItem = m_ChangedFileListCtrl.GetNextSelectedItem(pos);\r
4574                         changedpaths.push_back(m_currentChangedPathList[nItem].GetGitPathString());\r
4575                 }\r
4576         }\r
4577         else\r
4578         {\r
4579                 // only one revision is selected in the log dialog top pane\r
4580                 // but multiple items could be selected  in the changed items list\r
4581                 rev2 = rev1-1;\r
4582 \r
4583                 POSITION pos = m_ChangedFileListCtrl.GetFirstSelectedItemPosition();\r
4584                 while (pos)\r
4585                 {\r
4586                         int nItem = m_ChangedFileListCtrl.GetNextSelectedItem(pos);\r
4587                         LogChangedPath * changedlogpath = pLogEntry->pArChangedPaths->GetAt(nItem);\r
4588 \r
4589                         if (m_ChangedFileListCtrl.GetSelectedCount() == 1)\r
4590                         {\r
4591                                 if ((changedlogpath)&&(!changedlogpath->sCopyFromPath.IsEmpty()))\r
4592                                         rev2 = changedlogpath->lCopyFromRev;\r
4593                                 else\r
4594                                 {\r
4595                                         // if the path was modified but the parent path was 'added with history'\r
4596                                         // then we have to use the copy from revision of the parent path\r
4597                                         CTGitPath cpath = CTGitPath(changedlogpath->sPath);\r
4598                                         for (int flist = 0; flist < pLogEntry->pArChangedPaths->GetCount(); ++flist)\r
4599                                         {\r
4600                                                 CTGitPath p = CTGitPath(pLogEntry->pArChangedPaths->GetAt(flist)->sPath);\r
4601                                                 if (p.IsAncestorOf(cpath))\r
4602                                                 {\r
4603                                                         if (!pLogEntry->pArChangedPaths->GetAt(flist)->sCopyFromPath.IsEmpty())\r
4604                                                                 rev2 = pLogEntry->pArChangedPaths->GetAt(flist)->lCopyFromRev;\r
4605                                                 }\r
4606                                         }\r
4607                                 }\r
4608                         }\r
4609                         if ((m_cHidePaths.GetState() & 0x0003)==BST_CHECKED)\r
4610                         {\r
4611                                 // some items are hidden! So find out which item the user really clicked on\r
4612                                 INT_PTR selRealIndex = -1;\r
4613                                 for (INT_PTR hiddenindex=0; hiddenindex<pLogEntry->pArChangedPaths->GetCount(); ++hiddenindex)\r
4614                                 {\r
4615                                         if (pLogEntry->pArChangedPaths->GetAt(hiddenindex)->sPath.Left(m_sRelativeRoot.GetLength()).Compare(m_sRelativeRoot)==0)\r
4616                                                 selRealIndex++;\r
4617                                         if (selRealIndex == nItem)\r
4618                                         {\r
4619                                                 selIndex = hiddenindex;\r
4620                                                 changedlogpath = pLogEntry->pArChangedPaths->GetAt(selIndex);\r
4621                                                 break;\r
4622                                         }\r
4623                                 }\r
4624                         }\r
4625                         if (changedlogpath)\r
4626                         {\r
4627                                 changedpaths.push_back(changedlogpath->sPath);\r
4628                                 changedlogpaths.push_back(changedlogpath);\r
4629                         }\r
4630                 }\r
4631         }\r
4632 #endif\r
4633         //entry is selected, now show the popup menu\r
4634         CIconMenu popup;\r
4635         if (popup.CreatePopupMenu())\r
4636         {\r
4637                 bool bEntryAdded = false;\r
4638                 if (m_ChangedFileListCtrl.GetSelectedCount() == 1)\r
4639                 {\r
4640 //                      if ((!bOneRev)||(IsDiffPossible(changedlogpaths[0], rev1)))\r
4641                         {\r
4642                                 popup.AppendMenuIcon(ID_DIFF, IDS_LOG_POPUP_DIFF, IDI_DIFF);\r
4643                                 popup.AppendMenuIcon(ID_BLAMEDIFF, IDS_LOG_POPUP_BLAMEDIFF, IDI_BLAME);\r
4644                                 popup.SetDefaultItem(ID_DIFF, FALSE);\r
4645                                 popup.AppendMenuIcon(ID_GNUDIFF1, IDS_LOG_POPUP_GNUDIFF_CH, IDI_DIFF);\r
4646                                 bEntryAdded = true;\r
4647                         }\r
4648 //                      if (rev2 == rev1-1)\r
4649                         {\r
4650                                 if (bEntryAdded)\r
4651                                         popup.AppendMenu(MF_SEPARATOR, NULL);\r
4652                                 popup.AppendMenuIcon(ID_OPEN, IDS_LOG_POPUP_OPEN, IDI_OPEN);\r
4653                                 popup.AppendMenuIcon(ID_OPENWITH, IDS_LOG_POPUP_OPENWITH, IDI_OPEN);\r
4654                                 popup.AppendMenuIcon(ID_BLAME, IDS_LOG_POPUP_BLAME, IDI_BLAME);\r
4655                                 popup.AppendMenu(MF_SEPARATOR, NULL);\r
4656                                 if (m_hasWC)\r
4657                                         popup.AppendMenuIcon(ID_REVERTREV, IDS_LOG_POPUP_REVERTREV, IDI_REVERT);\r
4658                                 popup.AppendMenuIcon(ID_POPPROPS, IDS_REPOBROWSE_SHOWPROP, IDI_PROPERTIES);                     // "Show Properties"\r
4659                                 popup.AppendMenuIcon(ID_LOG, IDS_MENULOG, IDI_LOG);                                             // "Show Log"                           \r
4660                                 popup.AppendMenuIcon(ID_GETMERGELOGS, IDS_LOG_POPUP_GETMERGELOGS, IDI_LOG);             // "Show merge log"\r
4661                                 popup.AppendMenuIcon(ID_SAVEAS, IDS_LOG_POPUP_SAVE, IDI_SAVEAS);\r
4662                                 bEntryAdded = true;\r
4663                                 if (!m_ProjectProperties.sWebViewerPathRev.IsEmpty())\r
4664                                 {\r
4665                                         popup.AppendMenu(MF_SEPARATOR, NULL);\r
4666                                         popup.AppendMenuIcon(ID_VIEWPATHREV, IDS_LOG_POPUP_VIEWPATHREV);\r
4667                                 }\r
4668                                 if (popup.GetDefaultItem(0,FALSE)==-1)\r
4669                                         popup.SetDefaultItem(ID_OPEN, FALSE);\r
4670                         }\r
4671                 }\r
4672                 else if (changedlogpaths.size())\r
4673                 {\r
4674                         // more than one entry is selected\r
4675                         popup.AppendMenuIcon(ID_SAVEAS, IDS_LOG_POPUP_SAVE);\r
4676                         bEntryAdded = true;\r
4677                 }\r
4678 \r
4679                 if (!bEntryAdded)\r
4680                         return;\r
4681                 int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this, 0);\r
4682                 bool bOpenWith = false;\r
4683                 bool bMergeLog = false;\r
4684                 m_bCancelled = false;\r
4685                 \r
4686                 switch (cmd)\r
4687                 {\r
4688                 case ID_DIFF:\r
4689                         {\r
4690                                 DoDiffFromLog(selIndex, rev1, rev2, false, false);\r
4691                         }\r
4692                         break;\r
4693 #if 0\r
4694                 case ID_BLAMEDIFF:\r
4695                         {\r
4696                                 DoDiffFromLog(selIndex, rev1, rev2, true, false);\r
4697                         }\r
4698                         break;\r
4699                 case ID_GNUDIFF1:\r
4700                         {\r
4701                                 DoDiffFromLog(selIndex, rev1, rev2, false, true);\r
4702                         }\r
4703                         break;\r
4704                 case ID_REVERTREV:\r
4705                         {\r
4706                                 SetPromptApp(&theApp);\r
4707                                 theApp.DoWaitCursor(1);\r
4708                                 CString sUrl;\r
4709                                 if (Git::PathIsURL(m_path))\r
4710                                 {\r
4711                                         sUrl = m_path.GetGitPathString();\r
4712                                 }\r
4713                                 else\r
4714                                 {\r
4715                                         sUrl = GetURLFromPath(m_path);\r
4716                                         if (sUrl.IsEmpty())\r
4717                                         {\r
4718                                                 theApp.DoWaitCursor(-1);\r
4719                                                 CString temp;\r
4720                                                 temp.Format(IDS_ERR_NOURLOFFILE, m_path.GetWinPath());\r
4721                                                 CMessageBox::Show(this->m_hWnd, temp, _T("TortoiseGit"), MB_ICONERROR);\r
4722                                                 EnableOKButton();\r
4723                                                 theApp.DoWaitCursor(-1);\r
4724                                                 break;          //exit\r
4725                                         }\r
4726                                 }\r
4727                                 // find the working copy path of the selected item from the URL\r
4728                                 m_bCancelled = false;\r
4729                                 CString sUrlRoot = GetRepositoryRoot(CTGitPath(sUrl));\r
4730 \r
4731                                 CString fileURL = changedpaths[0];\r
4732                                 fileURL = sUrlRoot + fileURL.Trim();\r
4733                                 // firstfile = (e.g.) http://mydomain.com/repos/trunk/folder/file1\r
4734                                 // sUrl = http://mydomain.com/repos/trunk/folder\r
4735                                 CString sUnescapedUrl = CPathUtils::PathUnescape(sUrl);\r
4736                                 // find out until which char the urls are identical\r
4737                                 int i=0;\r
4738                                 while ((i<fileURL.GetLength())&&(i<sUnescapedUrl.GetLength())&&(fileURL[i]==sUnescapedUrl[i]))\r
4739                                         i++;\r
4740                                 int leftcount = m_path.GetWinPathString().GetLength()-(sUnescapedUrl.GetLength()-i);\r
4741                                 CString wcPath = m_path.GetWinPathString().Left(leftcount);\r
4742                                 wcPath += fileURL.Mid(i);\r
4743                                 wcPath.Replace('/', '\\');\r
4744                                 CGitProgressDlg dlg;\r
4745                                 if (changedlogpaths[0]->action == LOGACTIONS_DELETED)\r
4746                                 {\r
4747                                         // a deleted path! Since the path isn't there anymore, merge\r
4748                                         // won't work. So just do a copy url->wc\r
4749                                         dlg.SetCommand(CGitProgressDlg::GitProgress_Copy);\r
4750                                         dlg.SetPathList(CTGitPathList(CTGitPath(fileURL)));\r
4751                                         dlg.SetUrl(wcPath);\r
4752                                         dlg.SetRevision(rev2);\r
4753                                 }\r
4754                                 else\r
4755                                 {\r
4756                                         if (!PathFileExists(wcPath))\r
4757                                         {\r
4758                                                 // seems the path got renamed\r
4759                                                 // tell the user how to work around this.\r
4760                                                 CMessageBox::Show(this->m_hWnd, IDS_LOG_REVERTREV_ERROR, IDS_APPNAME, MB_ICONERROR);\r
4761                                                 EnableOKButton();\r
4762                                                 theApp.DoWaitCursor(-1);\r
4763                                                 break;          //exit\r
4764                                         }\r
4765                                         dlg.SetCommand(CGitProgressDlg::GitProgress_Merge);\r
4766                                         dlg.SetPathList(CTGitPathList(CTGitPath(wcPath)));\r
4767                                         dlg.SetUrl(fileURL);\r
4768                                         dlg.SetSecondUrl(fileURL);\r
4769                                         GitRevRangeArray revarray;\r
4770                                         revarray.AddRevRange(rev1, rev2);\r
4771                                         dlg.SetRevisionRanges(revarray);\r
4772                                 }\r
4773                                 CString msg;\r
4774                                 msg.Format(IDS_LOG_REVERT_CONFIRM, (LPCTSTR)wcPath);\r
4775                                 if (CMessageBox::Show(this->m_hWnd, msg, _T("TortoiseGit"), MB_YESNO | MB_ICONQUESTION) == IDYES)\r
4776                                 {\r
4777                                         dlg.DoModal();\r
4778                                 }\r
4779                                 theApp.DoWaitCursor(-1);\r
4780                         }\r
4781                         break;\r
4782                 case ID_POPPROPS:\r
4783                         {\r
4784                                 DialogEnableWindow(IDOK, FALSE);\r
4785                                 SetPromptApp(&theApp);\r
4786                                 theApp.DoWaitCursor(1);\r
4787                                 CString filepath;\r
4788                                 if (Git::PathIsURL(m_path))\r
4789                                 {\r
4790                                         filepath = m_path.GetGitPathString();\r
4791                                 }\r
4792                                 else\r
4793                                 {\r
4794                                         filepath = GetURLFromPath(m_path);\r
4795                                         if (filepath.IsEmpty())\r
4796                                         {\r
4797                                                 theApp.DoWaitCursor(-1);\r
4798                                                 CString temp;\r
4799                                                 temp.Format(IDS_ERR_NOURLOFFILE, (LPCTSTR)filepath);\r
4800                                                 CMessageBox::Show(this->m_hWnd, temp, _T("TortoiseGit"), MB_ICONERROR);\r
4801                                                 TRACE(_T("could not retrieve the URL of the file!\n"));\r
4802                                                 EnableOKButton();\r
4803                                                 break;\r
4804                                         }\r
4805                                 }\r
4806                                 filepath = GetRepositoryRoot(CTGitPath(filepath));\r
4807                                 filepath += changedpaths[0];\r
4808                                 CPropDlg dlg;\r
4809                                 dlg.m_rev = rev1;\r
4810                                 dlg.m_Path = CTGitPath(filepath);\r
4811                                 dlg.DoModal();\r
4812                                 EnableOKButton();\r
4813                                 theApp.DoWaitCursor(-1);\r
4814                         }\r
4815                         break;\r
4816                 case ID_SAVEAS:\r
4817                         {\r
4818                                 DialogEnableWindow(IDOK, FALSE);\r
4819                                 SetPromptApp(&theApp);\r
4820                                 theApp.DoWaitCursor(1);\r
4821                                 CString filepath;\r
4822                                 if (Git::PathIsURL(m_path))\r
4823                                 {\r
4824                                         filepath = m_path.GetGitPathString();\r
4825                                 }\r
4826                                 else\r
4827                                 {\r
4828                                         filepath = GetURLFromPath(m_path);\r
4829                                         if (filepath.IsEmpty())\r
4830                                         {\r
4831                                                 theApp.DoWaitCursor(-1);\r
4832                                                 CString temp;\r
4833                                                 temp.Format(IDS_ERR_NOURLOFFILE, (LPCTSTR)filepath);\r
4834                                                 CMessageBox::Show(this->m_hWnd, temp, _T("TortoiseGit"), MB_ICONERROR);\r
4835                                                 TRACE(_T("could not retrieve the URL of the file!\n"));\r
4836                                                 EnableOKButton();\r
4837                                                 break;\r
4838                                         }\r
4839                                 }\r
4840                                 m_bCancelled = false;\r
4841                                 CString sRoot = GetRepositoryRoot(CTGitPath(filepath));\r
4842                                 // if more than one entry is selected, we save them\r
4843                                 // one by one into a folder the user has selected\r
4844                                 bool bTargetSelected = false;\r
4845                                 CTGitPath TargetPath;\r
4846                                 if (m_ChangedFileListCtrl.GetSelectedCount() > 1)\r
4847                                 {\r
4848                                         CBrowseFolder browseFolder;\r
4849                                         browseFolder.SetInfo(CString(MAKEINTRESOURCE(IDS_LOG_SAVEFOLDERTOHINT)));\r
4850                                         browseFolder.m_style = BIF_EDITBOX | BIF_NEWDIALOGSTYLE | BIF_RETURNFSANCESTORS | BIF_RETURNONLYFSDIRS;\r
4851                                         CString strSaveAsDirectory;\r
4852                                         if (browseFolder.Show(GetSafeHwnd(), strSaveAsDirectory) == CBrowseFolder::OK) \r
4853                                         {\r
4854                                                 TargetPath = CTGitPath(strSaveAsDirectory);\r
4855                                                 bTargetSelected = true;\r
4856                                         }\r
4857                                 }\r
4858                                 else\r
4859                                 {\r
4860                                         // Display the Open dialog box. \r
4861                                         CString revFilename;\r
4862                                         CString temp;\r
4863                                         temp = CPathUtils::GetFileNameFromPath(changedpaths[0]);\r
4864                                         int rfind = temp.ReverseFind('.');\r
4865                                         if (rfind > 0)\r
4866                                                 revFilename.Format(_T("%s-%ld%s"), (LPCTSTR)temp.Left(rfind), rev1, (LPCTSTR)temp.Mid(rfind));\r
4867                                         else\r
4868                                                 revFilename.Format(_T("%s-%ld"), (LPCTSTR)temp, rev1);\r
4869                                         bTargetSelected = CAppUtils::FileOpenSave(revFilename, NULL, IDS_LOG_POPUP_SAVE, IDS_COMMONFILEFILTER, false, m_hWnd);\r
4870                                         TargetPath.SetFromWin(revFilename);\r
4871                                 }\r
4872                                 if (bTargetSelected)\r
4873                                 {\r
4874                                         CProgressDlg progDlg;\r
4875                                         progDlg.SetTitle(IDS_APPNAME);\r
4876                                         progDlg.SetAnimation(IDR_DOWNLOAD);\r
4877                                         for (std::vector<LogChangedPath*>::iterator it = changedlogpaths.begin(); it!= changedlogpaths.end(); ++it)\r
4878                                         {\r
4879                                                 GitRev getrev = ((*it)->action == LOGACTIONS_DELETED) ? rev2 : rev1;\r
4880 \r
4881                                                 CString sInfoLine;\r
4882                                                 sInfoLine.Format(IDS_PROGRESSGETFILEREVISION, (LPCTSTR)filepath, (LPCTSTR)getrev.ToString());\r
4883                                                 progDlg.SetLine(1, sInfoLine, true);\r
4884                                                 SetAndClearProgressInfo(&progDlg);\r
4885                                                 progDlg.ShowModeless(m_hWnd);\r
4886 \r
4887                                                 CTGitPath tempfile = TargetPath;\r
4888                                                 if (changedpaths.size() > 1)\r
4889                                                 {\r
4890                                                         // if multiple items are selected, then the TargetPath\r
4891                                                         // points to a folder and we have to append the filename\r
4892                                                         // to save to to that folder.\r
4893                                                         CString sName = (*it)->sPath;\r
4894                                                         int slashpos = sName.ReverseFind('/');\r
4895                                                         if (slashpos >= 0)\r
4896                                                                 sName = sName.Mid(slashpos);\r
4897                                                         tempfile.AppendPathString(sName);\r
4898                                                         // one problem here:\r
4899                                                         // a user could have selected multiple items which\r
4900                                                         // have the same filename but reside in different\r
4901                                                         // directories, e.g.\r
4902                                                         // /folder1/file1\r
4903                                                         // /folder2/file1\r
4904                                                         // in that case, the second 'file1' will overwrite\r
4905                                                         // the already saved 'file1'.\r
4906                                                         // \r
4907                                                         // we could maybe find the common root of all selected\r
4908                                                         // items and then create sub folders to save those files\r
4909                                                         // there.\r
4910                                                         // But I think we should just leave it that way: to check\r
4911                                                         // out multiple items at once, the better way is still to\r
4912                                                         // use the export command from the top pane of the log dialog.\r
4913                                                 }\r
4914                                                 filepath = sRoot + (*it)->sPath;\r
4915                                                 if (!Cat(CTGitPath(filepath), getrev, getrev, tempfile))\r
4916                                                 {\r
4917                                                         progDlg.Stop();\r
4918                                                         SetAndClearProgressInfo((HWND)NULL);\r
4919                                                         CMessageBox::Show(this->m_hWnd, GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);\r
4920                                                         EnableOKButton();\r
4921                                                         theApp.DoWaitCursor(-1);\r
4922                                                         break;\r
4923                                                 }\r
4924                                         }\r
4925                                         progDlg.Stop();\r
4926                                         SetAndClearProgressInfo((HWND)NULL);\r
4927                                 }\r
4928                                 EnableOKButton();\r
4929                                 theApp.DoWaitCursor(-1);\r
4930                         }\r
4931                         break;\r
4932                 case ID_OPENWITH:\r
4933                         bOpenWith = true;\r
4934                 case ID_OPEN:\r
4935                         {\r
4936                                 GitRev getrev = pLogEntry->pArChangedPaths->GetAt(selIndex)->action == LOGACTIONS_DELETED ? rev2 : rev1;\r
4937                                 Open(bOpenWith,changedpaths[0],getrev);\r
4938                         }\r
4939                         break;\r
4940                 case ID_BLAME:\r
4941                         {\r
4942                                 CString filepath;\r
4943                                 if (Git::PathIsURL(m_path))\r
4944                                 {\r
4945                                         filepath = m_path.GetGitPathString();\r
4946                                 }\r
4947                                 else\r
4948                                 {\r
4949                                         filepath = GetURLFromPath(m_path);\r
4950                                         if (filepath.IsEmpty())\r
4951                                         {\r
4952                                                 theApp.DoWaitCursor(-1);\r
4953                                                 CString temp;\r
4954                                                 temp.Format(IDS_ERR_NOURLOFFILE, (LPCTSTR)filepath);\r
4955                                                 CMessageBox::Show(this->m_hWnd, temp, _T("TortoiseGit"), MB_ICONERROR);\r
4956                                                 TRACE(_T("could not retrieve the URL of the file!\n"));\r
4957                                                 EnableOKButton();\r
4958                                                 break;\r
4959                                         }\r
4960                                 }\r
4961                                 filepath = GetRepositoryRoot(CTGitPath(filepath));\r
4962                                 filepath += changedpaths[0];\r
4963                                 CBlameDlg dlg;\r
4964                                 dlg.EndRev = rev1;\r
4965                                 if (dlg.DoModal() == IDOK)\r
4966                                 {\r
4967                                         CBlame blame;\r
4968                                         CString tempfile;\r
4969                                         CString logfile;\r
4970                                         tempfile = blame.BlameToTempFile(CTGitPath(filepath), dlg.StartRev, dlg.EndRev, dlg.EndRev, logfile, _T(""), dlg.m_bIncludeMerge, TRUE, TRUE);\r
4971                                         if (!tempfile.IsEmpty())\r
4972                                         {\r
4973                                                 if (dlg.m_bTextView)\r
4974                                                 {\r
4975                                                         //open the default text editor for the result file\r
4976                                                         CAppUtils::StartTextViewer(tempfile);\r
4977                                                 }\r
4978                                                 else\r
4979                                                 {\r
4980                                                         CString sParams = _T("/path:\"") + filepath + _T("\" ");\r
4981                                                         if(!CAppUtils::LaunchTortoiseBlame(tempfile, logfile, CPathUtils::GetFileNameFromPath(filepath),sParams))\r
4982                                                         {\r
4983                                                                 break;\r
4984                                                         }\r
4985                                                 }\r
4986                                         }\r
4987                                         else\r
4988                                         {\r
4989                                                 CMessageBox::Show(this->m_hWnd, blame.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);\r
4990                                         }\r
4991                                 }\r
4992                         }\r
4993                         break;\r
4994                 case ID_GETMERGELOGS:\r
4995                         bMergeLog = true;\r
4996                         // fall through\r
4997                 case ID_LOG:\r
4998                         {\r
4999                                 DialogEnableWindow(IDOK, FALSE);\r
5000                                 SetPromptApp(&theApp);\r
5001                                 theApp.DoWaitCursor(1);\r
5002                                 CString filepath;\r
5003                                 if (Git::PathIsURL(m_path))\r
5004                                 {\r
5005                                         filepath = m_path.GetGitPathString();\r
5006                                 }\r
5007                                 else\r
5008                                 {\r
5009                                         filepath = GetURLFromPath(m_path);\r
5010                                         if (filepath.IsEmpty())\r
5011                                         {\r
5012                                                 theApp.DoWaitCursor(-1);\r
5013                                                 CString temp;\r
5014                                                 temp.Format(IDS_ERR_NOURLOFFILE, (LPCTSTR)filepath);\r
5015                                                 CMessageBox::Show(this->m_hWnd, temp, _T("TortoiseGit"), MB_ICONERROR);\r
5016                                                 TRACE(_T("could not retrieve the URL of the file!\n"));\r
5017                                                 EnableOKButton();\r
5018                                                 break;\r
5019                                         }\r
5020                                 }\r
5021                                 m_bCancelled = false;\r
5022                                 filepath = GetRepositoryRoot(CTGitPath(filepath));\r
5023                                 filepath += changedpaths[0];\r
5024                                 git_revnum_t logrev = rev1;\r
5025                                 if (changedlogpaths[0]->action == LOGACTIONS_DELETED)\r
5026                                 {\r
5027                                         // if the item got deleted in this revision,\r
5028                                         // fetch the log from the previous revision where it\r
5029                                         // still existed.\r
5030                                         logrev--;\r
5031                                 }\r
5032                                 CString sCmd;\r
5033                                 sCmd.Format(_T("\"%s\" /command:log /path:\"%s\" /startrev:%ld"), (LPCTSTR)(CPathUtils::GetAppDirectory()+_T("TortoiseProc.exe")), (LPCTSTR)filepath, logrev);\r
5034                                 if (bMergeLog)\r
5035                                         sCmd += _T(" /merge");\r
5036                                 CAppUtils::LaunchApplication(sCmd, NULL, false);\r
5037                                 EnableOKButton();\r
5038                                 theApp.DoWaitCursor(-1);\r
5039                         }\r
5040                         break;\r
5041                 case ID_VIEWPATHREV:\r
5042                         {\r
5043                                 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.GetAt(m_LogList.GetSelectionMark()));\r
5044                                 GitRev rev = pLogEntry->Rev;\r
5045                                 CString relurl = changedpaths[0];\r
5046                                 CString url = m_ProjectProperties.sWebViewerPathRev;\r
5047                                 url.Replace(_T("%REVISION%"), rev.ToString());\r
5048                                 url.Replace(_T("%PATH%"), relurl);\r
5049                                 relurl = relurl.Mid(relurl.Find('/'));\r
5050                                 url.Replace(_T("%PATH1%"), relurl);\r
5051                                 if (!url.IsEmpty())\r
5052                                         ShellExecute(this->m_hWnd, _T("open"), url, NULL, NULL, SW_SHOWDEFAULT);                                        \r
5053                         }\r
5054                         break;\r
5055 #endif\r
5056                 default:\r
5057                         break;\r
5058                 } // switch (cmd)\r
5059 \r
5060         } // if (popup.CreatePopupMenu())\r
5061 }\r
5062 \r
5063 void CLogDlg::OnDtnDropdownDatefrom(NMHDR * /*pNMHDR*/, LRESULT *pResult)\r
5064 {\r
5065         // the date control should not show the "today" button\r
5066         CMonthCalCtrl * pCtrl = m_DateFrom.GetMonthCalCtrl();\r
5067         if (pCtrl)\r
5068                 SetWindowLongPtr(pCtrl->GetSafeHwnd(), GWL_STYLE, LONG_PTR(pCtrl->GetStyle() | MCS_NOTODAY));\r
5069         *pResult = 0;\r
5070 }\r
5071 \r
5072 void CLogDlg::OnDtnDropdownDateto(NMHDR * /*pNMHDR*/, LRESULT *pResult)\r
5073 {\r
5074         // the date control should not show the "today" button\r
5075         CMonthCalCtrl * pCtrl = m_DateTo.GetMonthCalCtrl();\r
5076         if (pCtrl)\r
5077                 SetWindowLongPtr(pCtrl->GetSafeHwnd(), GWL_STYLE, LONG_PTR(pCtrl->GetStyle() | MCS_NOTODAY));\r
5078         *pResult = 0;\r
5079 }\r
5080 \r
5081 void CLogDlg::OnSize(UINT nType, int cx, int cy)\r
5082 {\r
5083         __super::OnSize(nType, cx, cy);\r
5084         //set range\r
5085         SetSplitterRange();\r
5086 }\r
5087 \r
5088 void CLogDlg::OnRefresh()\r
5089 {\r
5090         if (GetDlgItem(IDC_GETALL)->IsWindowEnabled())\r
5091         {\r
5092                 m_limit = 0;\r
5093                 Refresh (true);\r
5094         }\r
5095 }\r
5096 \r
5097 void CLogDlg::OnFind()\r
5098 {\r
5099         if (!m_pFindDialog)\r
5100         {\r
5101                 m_pFindDialog = new CFindReplaceDialog();\r
5102                 m_pFindDialog->Create(TRUE, NULL, NULL, FR_HIDEUPDOWN | FR_HIDEWHOLEWORD, this);                                                                        \r
5103         }\r
5104 }\r
5105 \r
5106 void CLogDlg::OnFocusFilter()\r
5107 {\r
5108         GetDlgItem(IDC_SEARCHEDIT)->SetFocus(); \r
5109 }\r
5110 \r
5111 void CLogDlg::OnEditCopy()\r
5112 {\r
5113         if (GetFocus() == &m_ChangedFileListCtrl)\r
5114                 CopyChangedSelectionToClipBoard();\r
5115         else\r
5116                 CopySelectionToClipBoard();\r
5117 }\r
5118 \r
5119 CString CLogDlg::GetAbsoluteUrlFromRelativeUrl(const CString& url)\r
5120 {\r
5121         // is the URL a relative one?\r
5122         if (url.Left(2).Compare(_T("^/")) == 0)\r
5123         {\r
5124                 // URL is relative to the repository root\r
5125                 CString url1 = m_sRepositoryRoot + url.Mid(1);\r
5126                 TCHAR buf[INTERNET_MAX_URL_LENGTH];\r
5127                 DWORD len = url.GetLength();\r
5128                 if (UrlCanonicalize((LPCTSTR)url1, buf, &len, 0) == S_OK)\r
5129                         return CString(buf, len);\r
5130                 return url1;\r
5131         }\r
5132         else if (url[0] == '/')\r
5133         {\r
5134                 // URL is relative to the server's hostname\r
5135                 CString sHost;\r
5136                 // find the server's hostname\r
5137                 int schemepos = m_sRepositoryRoot.Find(_T("//"));\r
5138                 if (schemepos >= 0)\r
5139                 {\r
5140                         sHost = m_sRepositoryRoot.Left(m_sRepositoryRoot.Find('/', schemepos+3));\r
5141                         CString url1 = sHost + url;\r
5142                         TCHAR buf[INTERNET_MAX_URL_LENGTH];\r
5143                         DWORD len = url.GetLength();\r
5144                         if (UrlCanonicalize((LPCTSTR)url, buf, &len, 0) == S_OK)\r
5145                                 return CString(buf, len);\r
5146                         return url1;\r
5147                 }\r
5148         }\r
5149         return url;\r
5150 }\r
5151 \r
5152 \r
5153 int CLogDataVector::ParserFromLog()\r
5154 {\r
5155         CString log;\r
5156         GitRev rev;\r
5157         g_Git.GetLog(log);\r
5158 \r
5159         CString begin;\r
5160         begin.Format(_T("#<%c>"),LOG_REV_ITEM_BEGIN);\r
5161         \r
5162         if(log.GetLength()==0)\r
5163                 return 0;\r
5164         \r
5165         int start=4;\r
5166         int length;\r
5167         int next =1;\r
5168         while( next>0 )\r
5169         {\r
5170                 next=log.Find(begin,start);\r
5171                 if(next >0 )\r
5172                         length = next - start+4;\r
5173                 else\r
5174                         length = log.GetLength()-start+4;\r
5175 \r
5176                 CString onelog =log;\r
5177                 onelog=log.Mid(start -4,length);\r
5178                 rev.ParserFromLog(onelog);\r
5179                 this->push_back(rev);\r
5180                 start = next +4;\r
5181         }\r
5182 \r
5183         return 0;\r
5184 }\r