TortoiseProc/LogDlg.cpp

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