?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Make sure CTRL+HOME scrolls to the beginning of the first line
[TortoiseGit.git] / src / TortoiseMerge / BaseView.cpp
blobd23f1f33b6b7b414d752d27ab3c89a937997e495
1 // TortoiseGitMerge - a Diff/Patch program
2
3 // Copyright (C) 2003-2018 - TortoiseSVN
4 // Copyright (C) 2011-2012, 2017 Sven Strickroth <email@cs-ware.de>
5
6 // This program is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU General Public License
8 // as published by the Free Software Foundation; either version 2
9 // of the License, or (at your option) any later version.
10
11 // This program is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15
16 // You should have received a copy of the GNU General Public License
17 // along with this program; if not, write to the Free Software Foundation,
18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 //
20
21 #include "stdafx.h"
22 #include "registry.h"
23 #include "TortoiseMerge.h"
24 #include "MainFrm.h"
25 #include "BaseView.h"
26 #include "DiffColors.h"
27 #include "StringUtils.h"
28 #include "AppUtils.h"
29 #include "GotoLineDlg.h"
30 #include "EncodingDlg.h"
31 #include "EditorConfigWrapper.h"
32 #include "DpiScale.h"
33
34 // Note about lines:
35 // We use three different kind of lines here:
36 // 1. The real lines of the original files.
37 // These are shown in the view margin and are not used elsewhere, they're only for user information.
38 // 2. Screen lines.
39 // The lines actually shown on screen. All methods use screen lines as parameters/outputs if not explicitly specified otherwise.
40 // 3. View lines.
41 // These are the lines of the diff data. If unmodified sections are collapsed, not all of those lines are shown.
42 //
43 // Basically view lines are the line data, while screen lines are shown lines.
44
45
46 #ifdef _DEBUG
47 #define new DEBUG_NEW
48 #endif
49
50 #define HEADERHEIGHT 10
51
52 #define IDT_SCROLLTIMER 101
53
54 CBaseView* CBaseView::m_pwndLeft = nullptr;
55 CBaseView* CBaseView::m_pwndRight = nullptr;
56 CBaseView* CBaseView::m_pwndBottom = nullptr;
57 CLocatorBar* CBaseView::m_pwndLocator = nullptr;
58 CLineDiffBar* CBaseView::m_pwndLineDiffBar = nullptr;
59 CMFCStatusBar* CBaseView::m_pwndStatusBar = nullptr;
60 CMFCRibbonStatusBar* CBaseView::m_pwndRibbonStatusBar = nullptr;
61 CMainFrame* CBaseView::m_pMainFrame = nullptr;
62 CBaseView::Screen2View CBaseView::m_Screen2View;
63 const UINT CBaseView::m_FindDialogMessage = RegisterWindowMessage(FINDMSGSTRING);
64
65 allviewstate CBaseView::m_AllState;
66
67 IMPLEMENT_DYNCREATE(CBaseView, CView)
68
69 CBaseView::CBaseView()
70 : m_pCacheBitmap(nullptr)
71 , m_pViewData(nullptr)
72 , m_pOtherViewData(nullptr)
73 , m_pOtherView(nullptr)
74 , m_nLineHeight(-1)
75 , m_nCharWidth(-1)
76 , m_nScreenChars(-1)
77 , m_nLastScreenChars(-1)
78 , m_nMaxLineLength(-1)
79 , m_nScreenLines(-1)
80 , m_nTopLine(0)
81 , m_nOffsetChar(0)
82 , m_nDigits(0)
83 , m_nMouseLine(-1)
84 , m_mouseInMargin(false)
85 , m_bIsHidden(FALSE)
86 , m_lineendings(EOL_AUTOLINE)
87 , m_bReadonly(true)
88 , m_bReadonlyIsChangable(false)
89 , m_bTarget(false)
90 , m_nCaretGoalPos(0)
91 , m_nSelViewBlockStart(-1)
92 , m_nSelViewBlockEnd(-1)
93 , m_bFocused(FALSE)
94 , m_bShowSelection(true)
95 , m_texttype(CFileTextLines::AUTOTYPE)
96 , m_bModified(FALSE)
97 , m_bOtherDiffChecked(false)
98 , m_bInlineWordDiff(true)
99 , m_bWhitespaceInlineDiffs(false)
100 , m_pState(nullptr)
101 , m_pFindDialog(nullptr)
102 , m_nStatusBarID(0)
103 , m_bMatchCase(false)
104 , m_bLimitToDiff(true)
105 , m_bWholeWord(false)
106 , m_pDC(nullptr)
107 , m_pWorkingFile(nullptr)
108 , m_bInsertMode(true)
109 , m_bEditorConfigEnabled(false)
110 , m_bEditorConfigLoaded(2) // 2 = not evaluated
111 {
112 m_ptCaretViewPos.x = 0;
113 m_ptCaretViewPos.y = 0;
114 m_ptSelectionViewPosStart = m_ptCaretViewPos;
115 m_ptSelectionViewPosEnd = m_ptSelectionViewPosStart;
116 m_ptSelectionViewPosOrigin = m_ptSelectionViewPosEnd;
117 m_bViewWhitespace = CRegDWORD(L"Software\\TortoiseGitMerge\\ViewWhitespaces", 1);
118 m_bViewLinenumbers = CRegDWORD(L"Software\\TortoiseGitMerge\\ViewLinenumbers", 1);
119 m_bShowInlineDiff = CRegDWORD(L"Software\\TortoiseGitMerge\\DisplayBinDiff", TRUE);
120 m_nInlineDiffMaxLineLength = CRegDWORD(L"Software\\TortoiseGitMerge\\InlineDiffMaxLineLength", 3000);
121 m_InlineAddedBk = CRegDWORD(L"Software\\TortoiseGitMerge\\InlineAdded", INLINEADDED_COLOR);
122 m_InlineRemovedBk = CRegDWORD(L"Software\\TortoiseGitMerge\\InlineRemoved", INLINEREMOVED_COLOR);
123 m_ModifiedBk = CRegDWORD(L"Software\\TortoiseGitMerge\\Colors\\ColorModifiedB", MODIFIED_COLOR);
124 m_WhiteSpaceFg = CRegDWORD(L"Software\\TortoiseGitMerge\\Colors\\Whitespace", GetSysColor(COLOR_3DSHADOW));
125 m_sWordSeparators = CRegString(L"Software\\TortoiseGitMerge\\WordSeparators", L"[]();:.,{}!@#$%^&*-+=|/\\<>'`~\"?");
126 m_bIconLFs = CRegDWORD(L"Software\\TortoiseGitMerge\\IconLFs", 0);
127 m_nTabSize = (int)(DWORD)CRegDWORD(L"Software\\TortoiseGitMerge\\TabSize", 4);
128 m_nTabMode = (int)(DWORD)CRegDWORD(L"Software\\TortoiseGitMerge\\TabMode", TABMODE_NONE);
129 m_bEditorConfigEnabled = !!(DWORD)CRegDWORD(L"Software\\TortoiseGitMerge\\EnableEditorConfig", FALSE);
130 std::fill_n(m_apFonts, fontsCount, (CFont*)nullptr);
131
132 int cxIcon = GetSystemMetrics(SM_CXSMICON);
133 int cyIcon = GetSystemMetrics(SM_CYSMICON);
134 m_hConflictedIcon = (HCURSOR)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_CONFLICTEDLINE), IMAGE_ICON, cxIcon, cyIcon, 0);
135 m_hConflictedIgnoredIcon = (HCURSOR)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_CONFLICTEDIGNOREDLINE), IMAGE_ICON, cxIcon, cyIcon, 0);
136 m_hRemovedIcon = (HCURSOR)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_REMOVEDLINE), IMAGE_ICON, cxIcon, cyIcon, 0);
137 m_hAddedIcon = (HCURSOR)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_ADDEDLINE), IMAGE_ICON, cxIcon, cyIcon, 0);
138 m_hWhitespaceBlockIcon = (HCURSOR)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_WHITESPACELINE), IMAGE_ICON, cxIcon, cyIcon, 0);
139 m_hEqualIcon = (HCURSOR)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_EQUALLINE), IMAGE_ICON, cxIcon, cyIcon, 0);
140 m_hLineEndingCR = (HCURSOR)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_LINEENDINGCR), IMAGE_ICON, cxIcon, cyIcon, 0);
141 m_hLineEndingCRLF = (HCURSOR)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_LINEENDINGCRLF), IMAGE_ICON, cxIcon, cyIcon, 0);
142 m_hLineEndingLF = (HCURSOR)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_LINEENDINGLF), IMAGE_ICON, cxIcon, cyIcon, 0);
143 m_hEditedIcon = (HCURSOR)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_LINEEDITED), IMAGE_ICON, cxIcon, cyIcon, 0);
144 m_hMovedIcon = (HCURSOR)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_MOVEDLINE), IMAGE_ICON, cxIcon, cyIcon, 0);
145 m_hMarkedIcon = (HCURSOR)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_LINEMARKED), IMAGE_ICON, cxIcon, cyIcon, 0);
146 m_margincursor = (HCURSOR)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDC_MARGINCURSOR), IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE);
147
148 for (int i=0; i<1024; ++i)
149 m_sConflictedText += L"??";
150 m_sNoLineNr.LoadString(IDS_EMPTYLINETT);
151
152 m_szTip[0] = 0;
153 m_wszTip[0] = 0;
154 SecureZeroMemory(&m_lfBaseFont, sizeof(m_lfBaseFont));
155 EnableToolTips();
156
157 m_Eols[EOL_LF] = L"\n"; // x0a
158 m_Eols[EOL_CR] = L"\r"; // x0d
159 m_Eols[EOL_CRLF] = L"\r\n"; // x0d x0a
160 m_Eols[EOL_LFCR] = L"\n\r";
161 m_Eols[EOL_VT] = L"\v"; // x0b
162 m_Eols[EOL_FF] = L"\f"; // x0c
163 m_Eols[EOL_NEL] = L"\x85";
164 m_Eols[EOL_LS] = L"\x2028";
165 m_Eols[EOL_PS] = L"\x2029";
166 m_Eols[EOL_AUTOLINE] = m_Eols[m_lineendings==EOL_AUTOLINE
167 ? EOL_CRLF
168 : m_lineendings];
169 m_SaveParams.m_LineEndings = EOL::EOL_AUTOLINE;
170 m_SaveParams.m_UnicodeType = CFileTextLines::AUTOTYPE;
171 }
172
173 CBaseView::~CBaseView()
174 {
175 ReleaseBitmap();
176 DeleteFonts();
177 DestroyIcon(m_hAddedIcon);
178 DestroyIcon(m_hRemovedIcon);
179 DestroyIcon(m_hConflictedIcon);
180 DestroyIcon(m_hConflictedIgnoredIcon);
181 DestroyIcon(m_hWhitespaceBlockIcon);
182 DestroyIcon(m_hEqualIcon);
183 DestroyIcon(m_hLineEndingCR);
184 DestroyIcon(m_hLineEndingCRLF);
185 DestroyIcon(m_hLineEndingLF);
186 DestroyIcon(m_hEditedIcon);
187 DestroyIcon(m_hMovedIcon);
188 DestroyIcon(m_hMarkedIcon);
189 DestroyCursor(m_margincursor);
190 }
191
192 BEGIN_MESSAGE_MAP(CBaseView, CView)
193 ON_WM_VSCROLL()
194 ON_WM_HSCROLL()
195 ON_WM_ERASEBKGND()
196 ON_WM_CREATE()
197 ON_WM_DESTROY()
198 ON_WM_SIZE()
199 ON_WM_MOUSEWHEEL()
200 ON_WM_MOUSEHWHEEL()
201 ON_WM_SETCURSOR()
202 ON_WM_KILLFOCUS()
203 ON_WM_SETFOCUS()
204 ON_WM_CONTEXTMENU()
205 ON_COMMAND(ID_NAVIGATE_NEXTDIFFERENCE, OnMergeNextdifference)
206 ON_COMMAND(ID_NAVIGATE_PREVIOUSDIFFERENCE, OnMergePreviousdifference)
207 ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTW, 0, 0xFFFF, OnToolTipNotify)
208 ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTA, 0, 0xFFFF, OnToolTipNotify)
209 ON_WM_KEYDOWN()
210 ON_WM_LBUTTONDOWN()
211 ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
212 ON_WM_MOUSEMOVE()
213 ON_COMMAND(ID_NAVIGATE_PREVIOUSCONFLICT, OnMergePreviousconflict)
214 ON_COMMAND(ID_NAVIGATE_NEXTCONFLICT, OnMergeNextconflict)
215 ON_WM_CHAR()
216 ON_COMMAND(ID_CARET_DOWN, &CBaseView::OnCaretDown)
217 ON_COMMAND(ID_CARET_LEFT, &CBaseView::OnCaretLeft)
218 ON_COMMAND(ID_CARET_RIGHT, &CBaseView::OnCaretRight)
219 ON_COMMAND(ID_CARET_UP, &CBaseView::OnCaretUp)
220 ON_COMMAND(ID_CARET_WORDLEFT, &CBaseView::OnCaretWordleft)
221 ON_COMMAND(ID_CARET_WORDRIGHT, &CBaseView::OnCaretWordright)
222 ON_COMMAND(ID_EDIT_CUT, &CBaseView::OnEditCut)
223 ON_COMMAND(ID_EDIT_PASTE, &CBaseView::OnEditPaste)
224 ON_WM_TIMER()
225 ON_WM_LBUTTONDBLCLK()
226 ON_COMMAND(ID_NAVIGATE_NEXTINLINEDIFF, &CBaseView::OnNavigateNextinlinediff)
227 ON_COMMAND(ID_NAVIGATE_PREVINLINEDIFF, &CBaseView::OnNavigatePrevinlinediff)
228 ON_COMMAND(ID_EDIT_SELECTALL, &CBaseView::OnEditSelectall)
229 ON_COMMAND(ID_EDIT_FIND, OnEditFind)
230 ON_REGISTERED_MESSAGE(m_FindDialogMessage, OnFindDialogMessage)
231 ON_COMMAND(ID_EDIT_FINDNEXT, OnEditFindnext)
232 ON_COMMAND(ID_EDIT_FINDPREV, OnEditFindprev)
233 ON_COMMAND(ID_EDIT_FINDNEXTSTART, OnEditFindnextStart)
234 ON_COMMAND(ID_EDIT_FINDPREVSTART, OnEditFindprevStart)
235 ON_COMMAND(ID_EDIT_GOTOLINE, &CBaseView::OnEditGotoline)
236 ON_WM_LBUTTONUP()
237 END_MESSAGE_MAP()
238
239
240 void CBaseView::DocumentUpdated()
241 {
242 ReleaseBitmap();
243 m_nLineHeight = -1;
244 m_nCharWidth = -1;
245 m_nScreenChars = -1;
246 m_nLastScreenChars = -1;
247 m_nMaxLineLength = -1;
248 m_nScreenLines = -1;
249 m_nTopLine = 0;
250 m_bModified = FALSE;
251 m_bOtherDiffChecked = false;
252 m_nDigits = 0;
253 m_nMouseLine = -1;
254 m_nTabSize = (int)(DWORD)CRegDWORD(L"Software\\TortoiseGitMerge\\TabSize", 4);
255 m_nTabMode = (int)(DWORD)CRegDWORD(L"Software\\TortoiseGitMerge\\TabMode", TABMODE_NONE);
256 m_bViewLinenumbers = CRegDWORD(L"Software\\TortoiseGitMerge\\ViewLinenumbers", 1);
257 m_InlineAddedBk = CRegDWORD(L"Software\\TortoiseGitMerge\\InlineAdded", INLINEADDED_COLOR);
258 m_InlineRemovedBk = CRegDWORD(L"Software\\TortoiseGitMerge\\InlineRemoved", INLINEREMOVED_COLOR);
259 m_ModifiedBk = CRegDWORD(L"Software\\TortoiseGitMerge\\Colors\\ColorModifiedB", MODIFIED_COLOR);
260 m_WhiteSpaceFg = CRegDWORD(L"Software\\TortoiseGitMerge\\Colors\\Whitespace", GetSysColor(COLOR_3DSHADOW));
261 m_bIconLFs = CRegDWORD(L"Software\\TortoiseGitMerge\\IconLFs", 0);
262 m_nInlineDiffMaxLineLength = CRegDWORD(L"Software\\TortoiseGitMerge\\InlineDiffMaxLineLength", 3000);
263 m_Eols[EOL_AUTOLINE] = m_Eols[m_lineendings==EOL_AUTOLINE
264 ? EOL_CRLF
265 : m_lineendings];
266 SetEditorConfigEnabled(m_bEditorConfigEnabled);
267 DeleteFonts();
268 ClearCurrentSelection();
269 UpdateStatusBar();
270 Invalidate();
271 }
272
273 void CBaseView::SetEditorConfigEnabled(bool bEditorConfigEnabled)
274 {
275 m_bEditorConfigEnabled = bEditorConfigEnabled;
276 m_nTabSize = (int)(DWORD)CRegDWORD(L"Software\\TortoiseGitMerge\\TabSize", 4);
277 m_nTabMode = (int)(DWORD)CRegDWORD(L"Software\\TortoiseGitMerge\\TabMode", TABMODE_NONE);
278 if (m_bEditorConfigEnabled)
279 {
280 m_bEditorConfigLoaded = FALSE; // no editorconfig entries loaded
281 CEditorConfigWrapper ec;
282 if (ec.Load(m_sReflectedName.IsEmpty() ? m_sFullFilePath : m_sReflectedName))
283 {
284 m_bEditorConfigLoaded = TRUE;
285 if (ec.m_nTabWidth != nullptr)
286 m_nTabSize = ec.m_nTabWidth;
287 if (ec.m_bIndentStyle != nullptr)
288 m_nTabMode = (m_nTabMode & ~TABMODE_USESPACES) | (ec.m_bIndentStyle ? TABMODE_USESPACES : TABMODE_NONE);
289 }
290 }
291 }
292
293 static CString GetTabModeString(int nTabMode, int nTabSize, bool bEditorConfig)
294 {
295 CString text;
296 if (nTabMode & TABMODE_USESPACES)
297 text = L"Space";
298 else
299 text = L"Tab";
300 text.AppendFormat(L" %d", nTabSize);
301 if (nTabMode & TABMODE_SMARTINDENT)
302 text += L" Smart";
303 if (bEditorConfig)
304 text += L" EC";
305 return text;
306 }
307
308 void CBaseView::UpdateStatusBar()
309 {
310 int nRemovedLines = 0;
311 int nAddedLines = 0;
312 int nConflictedLines = 0;
313
314 if (m_pViewData)
315 {
316 for (int i=0; i<m_pViewData->GetCount(); i++)
317 {
318 DiffStates state = m_pViewData->GetState(i);
319 switch (state)
320 {
321 case DIFFSTATE_ADDED:
322 case DIFFSTATE_IDENTICALADDED:
323 case DIFFSTATE_THEIRSADDED:
324 case DIFFSTATE_YOURSADDED:
325 case DIFFSTATE_CONFLICTADDED:
326 nAddedLines++;
327 break;
328 case DIFFSTATE_IDENTICALREMOVED:
329 case DIFFSTATE_REMOVED:
330 case DIFFSTATE_THEIRSREMOVED:
331 case DIFFSTATE_YOURSREMOVED:
332 nRemovedLines++;
333 break;
334 case DIFFSTATE_CONFLICTED:
335 case DIFFSTATE_CONFLICTED_IGNORED:
336 nConflictedLines++;
337 break;
338 }
339 }
340 }
341
342 CString sBarText;
343 CString sTemp;
344
345 if (m_pwndStatusBar)
346 {
347 sBarText += CFileTextLines::GetEncodingName(m_texttype);
348 sBarText += sBarText.IsEmpty() ? L"" : L" ";
349 sBarText += GetEolName(m_lineendings);
350 sBarText += sBarText.IsEmpty() ? L"" : L" ";
351
352 if (sBarText.IsEmpty())
353 sBarText += L" / ";
354 }
355
356 if (nRemovedLines)
357 {
358 sTemp.Format(IDS_STATUSBAR_REMOVEDLINES, nRemovedLines);
359 if (!sBarText.IsEmpty())
360 sBarText += L" / ";
361 sBarText += sTemp;
362 }
363 if (nAddedLines)
364 {
365 sTemp.Format(IDS_STATUSBAR_ADDEDLINES, nAddedLines);
366 if (!sBarText.IsEmpty())
367 sBarText += L" / ";
368 sBarText += sTemp;
369 }
370 if (nConflictedLines)
371 {
372 sTemp.Format(IDS_STATUSBAR_CONFLICTEDLINES, nConflictedLines);
373 if (!sBarText.IsEmpty())
374 sBarText += L" / ";
375 sBarText += sTemp;
376 }
377 if (m_pwndStatusBar || m_pwndRibbonStatusBar)
378 {
379 if (m_pwndStatusBar)
380 {
381 UINT nID;
382 UINT nStyle;
383 int cxWidth;
384 if (m_nStatusBarID == ID_INDICATOR_BOTTOMVIEW)
385 {
386 sBarText.Format(IDS_STATUSBAR_CONFLICTS, nConflictedLines);
387 }
388 if (m_nStatusBarID == ID_INDICATOR_LEFTVIEW)
389 {
390 sTemp.LoadString(IDS_STATUSBAR_LEFTVIEW);
391 sBarText = sTemp+sBarText;
392 }
393 if (m_nStatusBarID == ID_INDICATOR_RIGHTVIEW)
394 {
395 sTemp.LoadString(IDS_STATUSBAR_RIGHTVIEW);
396 sBarText = sTemp+sBarText;
397 }
398 int nIndex = m_pwndStatusBar->CommandToIndex(m_nStatusBarID);
399 m_pwndStatusBar->GetPaneInfo(nIndex, nID, nStyle, cxWidth);
400 //calculate the width of the text
401 CDC * pDC = m_pwndStatusBar->GetDC();
402 if (pDC)
403 {
404 CSize size = pDC->GetTextExtent(sBarText);
405 m_pwndStatusBar->SetPaneInfo(nIndex, nID, nStyle, size.cx+2);
406 ReleaseDC(pDC);
407 }
408 m_pwndStatusBar->SetPaneText(nIndex, sBarText);
409 }
410 else if (m_pwndRibbonStatusBar)
411 {
412 if (!IsViewGood(m_pwndBottom))
413 m_pwndRibbonStatusBar->RemoveElement(ID_INDICATOR_BOTTOMVIEW);
414 if ((m_nStatusBarID == ID_INDICATOR_BOTTOMVIEW) && (IsViewGood(this)))
415 {
416 m_pwndRibbonStatusBar->RemoveElement(ID_INDICATOR_BOTTOMVIEW);
417 auto apBtnGroupBottom = std::make_unique<CMFCRibbonButtonsGroup>();
418 apBtnGroupBottom->SetID(ID_INDICATOR_BOTTOMVIEW);
419 apBtnGroupBottom->AddButton(new CMFCRibbonStatusBarPane(ID_SEPARATOR, CString(MAKEINTRESOURCE(IDS_STATUSBAR_BOTTOMVIEW)), TRUE));
420 CMFCRibbonButton * pButton = new CMFCRibbonButton(ID_INDICATOR_BOTTOMVIEWCOMBOENCODING, L"");
421 m_pMainFrame->FillEncodingButton(pButton, ID_INDICATOR_BOTTOMENCODINGSTART);
422 apBtnGroupBottom->AddButton(pButton);
423 pButton = new CMFCRibbonButton(ID_INDICATOR_BOTTOMVIEWCOMBOEOL, L"");
424 m_pMainFrame->FillEOLButton(pButton, ID_INDICATOR_BOTTOMEOLSTART);
425 apBtnGroupBottom->AddButton(pButton);
426 pButton = new CMFCRibbonButton(ID_INDICATOR_BOTTOMVIEWCOMBOTABMODE, L"");
427 m_pMainFrame->FillTabModeButton(pButton, ID_INDICATOR_BOTTOMTABMODESTART);
428 apBtnGroupBottom->AddButton(pButton);
429 apBtnGroupBottom->AddButton(new CMFCRibbonStatusBarPane(ID_INDICATOR_BOTTOMVIEW, L"", TRUE));
430 m_pwndRibbonStatusBar->AddExtendedElement(apBtnGroupBottom.release(), L"");
431 }
432
433 CMFCRibbonButtonsGroup * pGroup = DYNAMIC_DOWNCAST(CMFCRibbonButtonsGroup, m_pwndRibbonStatusBar->FindByID(m_nStatusBarID));
434 if (pGroup)
435 {
436 CMFCRibbonStatusBarPane* pPane = DYNAMIC_DOWNCAST(CMFCRibbonStatusBarPane, pGroup->GetButton(4));
437 if (pPane)
438 {
439 pPane->SetText(sBarText);
440 }
441 CMFCRibbonButton * pButton = DYNAMIC_DOWNCAST(CMFCRibbonButton, pGroup->GetButton(1));
442 if (pButton)
443 {
444 pButton->SetText(CFileTextLines::GetEncodingName(m_texttype));
445 pButton->SetDescription(CFileTextLines::GetEncodingName(m_texttype));
446 }
447 pButton = DYNAMIC_DOWNCAST(CMFCRibbonButton, pGroup->GetButton(2));
448 if (pButton)
449 {
450 pButton->SetText(GetEolName(m_lineendings));
451 pButton->SetDescription(GetEolName(m_lineendings));
452 }
453 pButton = DYNAMIC_DOWNCAST(CMFCRibbonButton, pGroup->GetButton(3));
454 if (pButton)
455 {
456 pButton->SetText(GetTabModeString(m_nTabMode, m_nTabSize, m_bEditorConfigEnabled && m_bEditorConfigLoaded));
457 pButton->SetDescription(GetTabModeString(m_nTabMode, m_nTabSize, m_bEditorConfigEnabled && m_bEditorConfigLoaded));
458 }
459 }
460 m_pwndRibbonStatusBar->RecalcLayout();
461 m_pwndRibbonStatusBar->Invalidate();
462 }
463 }
464 }
465
466 BOOL CBaseView::PreCreateWindow(CREATESTRUCT& cs)
467 {
468 if (!CView::PreCreateWindow(cs))
469 return FALSE;
470
471 cs.dwExStyle |= WS_EX_CLIENTEDGE;
472 cs.style &= ~WS_BORDER;
473 cs.lpszClass = AfxRegisterWndClass(CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS,
474 ::LoadCursor(nullptr, IDC_ARROW), reinterpret_cast<HBRUSH>(COLOR_WINDOW + 1), nullptr);
475
476 CWnd *pParentWnd = CWnd::FromHandlePermanent(cs.hwndParent);
477 if (!pParentWnd || !pParentWnd->IsKindOf(RUNTIME_CLASS(CSplitterWnd)))
478 {
479 // View must always create its own scrollbars,
480 // if only it's not used within splitter
481 cs.style |= (WS_HSCROLL | WS_VSCROLL);
482 }
483 cs.lpszClass = AfxRegisterWndClass(CS_DBLCLKS);
484 return TRUE;
485 }
486
487 CFont* CBaseView::GetFont(BOOL bItalic /*= FALSE*/, BOOL bBold /*= FALSE*/)
488 {
489 int nIndex = 0;
490 if (bBold)
491 nIndex |= 1;
492 if (bItalic)
493 nIndex |= 2;
494 if (!m_apFonts[nIndex])
495 {
496 m_apFonts[nIndex] = new CFont;
497 m_lfBaseFont.lfCharSet = DEFAULT_CHARSET;
498 m_lfBaseFont.lfWeight = bBold ? FW_BOLD : FW_NORMAL;
499 m_lfBaseFont.lfItalic = (BYTE) bItalic;
500 CDC * pDC = GetDC();
501 if (pDC)
502 {
503 m_lfBaseFont.lfHeight = -MulDiv((DWORD)CRegDWORD(L"Software\\TortoiseGitMerge\\LogFontSize", 10), GetDeviceCaps(pDC->m_hDC, LOGPIXELSY), 72);
504 ReleaseDC(pDC);
505 }
506 wcsncpy_s(m_lfBaseFont.lfFaceName, (LPCTSTR)(CString)CRegString(L"Software\\TortoiseGitMerge\\LogFontName", L"Consolas"), _countof(m_lfBaseFont.lfFaceName) - 1);
507 if (!m_apFonts[nIndex]->CreateFontIndirect(&m_lfBaseFont))
508 {
509 delete m_apFonts[nIndex];
510 m_apFonts[nIndex] = nullptr;
511 return CView::GetFont();
512 }
513 }
514 return m_apFonts[nIndex];
515 }
516
517 void CBaseView::CalcLineCharDim()
518 {
519 CDC *pDC = GetDC();
520 if (!pDC)
521 return;
522 CFont *pOldFont = pDC->SelectObject(GetFont());
523 const CSize szCharExt = pDC->GetTextExtent(L"X");
524 pDC->SelectObject(pOldFont);
525 ReleaseDC(pDC);
526
527 m_nLineHeight = szCharExt.cy;
528 if (m_nLineHeight <= 0)
529 m_nLineHeight = -1;
530 m_nCharWidth = szCharExt.cx;
531 if (m_nCharWidth <= 0)
532 m_nCharWidth = -1;
533 }
534
535 int CBaseView::GetScreenChars()
536 {
537 if (m_nScreenChars == -1)
538 {
539 CRect rect;
540 GetClientRect(&rect);
541 m_nScreenChars = (rect.Width() - GetMarginWidth() - GetSystemMetrics(SM_CXVSCROLL)) / GetCharWidth();
542 if (m_nScreenChars < 0)
543 m_nScreenChars = 0;
544 }
545 return m_nScreenChars;
546 }
547
548 int CBaseView::GetAllMinScreenChars() const
549 {
550 int nChars = INT_MAX;
551 if (IsLeftViewGood())
552 nChars = std::min<int>(nChars, m_pwndLeft->GetScreenChars());
553 if (IsRightViewGood())
554 nChars = std::min<int>(nChars, m_pwndRight->GetScreenChars());
555 if (IsBottomViewGood())
556 nChars = std::min<int>(nChars, m_pwndBottom->GetScreenChars());
557 return (nChars==INT_MAX) ? 0 : nChars;
558 }
559
560 int CBaseView::GetAllMaxLineLength() const
561 {
562 int nLength = 0;
563 if (IsLeftViewGood())
564 nLength = std::max<int>(nLength, m_pwndLeft->GetMaxLineLength());
565 if (IsRightViewGood())
566 nLength = std::max<int>(nLength, m_pwndRight->GetMaxLineLength());
567 if (IsBottomViewGood())
568 nLength = std::max<int>(nLength, m_pwndBottom->GetMaxLineLength());
569 return nLength;
570 }
571
572 int CBaseView::GetLineHeight()
573 {
574 if (m_nLineHeight == -1)
575 CalcLineCharDim();
576 if (m_nLineHeight <= 0)
577 return 1;
578 return m_nLineHeight;
579 }
580
581 int CBaseView::GetCharWidth()
582 {
583 if (m_nCharWidth == -1)
584 CalcLineCharDim();
585 if (m_nCharWidth <= 0)
586 return 1;
587 return m_nCharWidth;
588 }
589
590 int CBaseView::GetMaxLineLength()
591 {
592 if (m_nMaxLineLength == -1)
593 {
594 m_nMaxLineLength = 0;
595 int nLineCount = GetLineCount();
596 if (nLineCount == 1)
597 {
598 m_nMaxLineLength = GetLineLengthWithTabsConverted(0);
599 return m_nMaxLineLength;
600 }
601 for (int i=0; i<nLineCount; i++)
602 {
603 int nActualLength = GetLineLengthWithTabsConverted(i);
604 if (m_nMaxLineLength < nActualLength)
605 m_nMaxLineLength = nActualLength;
606 }
607 }
608 return m_nMaxLineLength;
609 }
610
611 int CBaseView::GetLineLengthWithTabsConverted(int index)
612 {
613 if (!m_pViewData)
614 return 0;
615 if (m_pViewData->GetCount() == 0)
616 return 0;
617 if ((int)m_Screen2View.size() <= index)
618 return 0;
619 CString sLine;
620 if (m_pMainFrame->m_bWrapLines)
621 sLine = GetLineChars(index);
622 else
623 {
624 int viewLine = GetViewLineForScreen(index);
625 sLine = m_pViewData->GetLine(viewLine);
626 }
627 int tabCount = 0;
628 wchar_t* pChar = (LPWSTR)(LPCWSTR)sLine;
629 auto nLineLength = sLine.GetLength();
630 for (int i = 0; i < nLineLength; ++i)
631 {
632 if (*pChar == '\t')
633 ++tabCount;
634 ++pChar;
635 }
636 // GetTabSize() - 1 because the tabs are already counted
637 nLineLength = nLineLength + (tabCount * (GetTabSize() - 1));
638 ASSERT(nLineLength >= 0);
639 return nLineLength;
640 }
641
642 int CBaseView::GetLineLength(int index)
643 {
644 if (!m_pViewData)
645 return 0;
646 if (m_pViewData->GetCount() == 0)
647 return 0;
648 if ((int)m_Screen2View.size() <= index)
649 return 0;
650 int viewLine = GetViewLineForScreen(index);
651 if (m_pMainFrame->m_bWrapLines)
652 {
653 int nLineLength = GetLineChars(index).GetLength();
654 ASSERT(nLineLength >= 0);
655 return nLineLength;
656 }
657 int nLineLength = m_pViewData->GetLine(viewLine).GetLength();
658 ASSERT(nLineLength >= 0);
659 return nLineLength;
660 }
661
662 int CBaseView::GetViewLineLength(int nViewLine) const
663 {
664 if (!m_pViewData)
665 return 0;
666 if (m_pViewData->GetCount() <= nViewLine)
667 return 0;
668 int nLineLength = m_pViewData->GetLine(nViewLine).GetLength();
669 ASSERT(nLineLength >= 0);
670 return nLineLength;
671 }
672
673 int CBaseView::GetLineCount() const
674 {
675 if (!m_pViewData)
676 return 1;
677 int nLineCount = (int)m_Screen2View.size();
678 ASSERT(nLineCount >= 0);
679 return nLineCount;
680 }
681
682 int CBaseView::GetSubLineOffset(int index)
683 {
684 return m_Screen2View.GetSubLineOffset(index);
685 }
686
687 CString CBaseView::GetViewLineChars(int nViewLine) const
688 {
689 if (!m_pViewData)
690 return 0;
691 if (m_pViewData->GetCount() <= nViewLine)
692 return 0;
693 return m_pViewData->GetLine(nViewLine);
694 }
695
696 CString CBaseView::GetLineChars(int index)
697 {
698 if (!m_pViewData)
699 return 0;
700 if (m_pViewData->GetCount() == 0)
701 return 0;
702 if ((int)m_Screen2View.size() <= index)
703 return 0;
704 int viewLine = GetViewLineForScreen(index);
705 if (m_pMainFrame->m_bWrapLines)
706 {
707 int subLine = GetSubLineOffset(index);
708 if (subLine >= 0)
709 {
710 if (subLine < CountMultiLines(viewLine))
711 {
712 return m_ScreenedViewLine[viewLine].SubLines[subLine];
713 }
714 return L"";
715 }
716 }
717 return m_pViewData->GetLine(viewLine);
718 }
719
720 void CBaseView::CheckOtherView()
721 {
722 if (m_bOtherDiffChecked)
723 return;
724 // find out what the 'other' file is
725 m_pOtherViewData = nullptr;
726 m_pOtherView = nullptr;
727 if (this == m_pwndLeft && IsRightViewGood())
728 {
729 m_pOtherViewData = m_pwndRight->m_pViewData;
730 m_pOtherView = m_pwndRight;
731 }
732
733 if (this == m_pwndRight && IsLeftViewGood())
734 {
735 m_pOtherViewData = m_pwndLeft->m_pViewData;
736 m_pOtherView = m_pwndLeft;
737 }
738
739 m_bOtherDiffChecked = true;
740 }
741
742
743 void CBaseView::GetWhitespaceBlock(CViewData *viewData, int nLineIndex, int & nStartBlock, int & nEndBlock)
744 {
745 enum { MAX_WHITESPACEBLOCK_SIZE = 8 };
746 ASSERT(viewData);
747
748 DiffStates origstate = viewData->GetState(nLineIndex);
749
750 // Go back and forward at most MAX_WHITESPACEBLOCK_SIZE lines to see where this block ends
751 nStartBlock = nLineIndex;
752 nEndBlock = nLineIndex;
753 while ((nStartBlock > 0) && (nStartBlock > (nLineIndex - MAX_WHITESPACEBLOCK_SIZE)))
754 {
755 DiffStates state = viewData->GetState(nStartBlock - 1);
756 if ((origstate == DIFFSTATE_EMPTY) && (state != DIFFSTATE_NORMAL))
757 origstate = state;
758 if ((origstate == state) || (state == DIFFSTATE_EMPTY))
759 nStartBlock--;
760 else
761 break;
762 }
763 while ((nEndBlock < (viewData->GetCount() - 1)) && (nEndBlock < (nLineIndex + MAX_WHITESPACEBLOCK_SIZE)))
764 {
765 DiffStates state = viewData->GetState(nEndBlock + 1);
766 if ((origstate == DIFFSTATE_EMPTY) && (state != DIFFSTATE_NORMAL))
767 origstate = state;
768 if ((origstate == state) || (state == DIFFSTATE_EMPTY))
769 nEndBlock++;
770 else
771 break;
772 }
773 }
774
775 CString CBaseView::GetWhitespaceString(CViewData *viewData, int nStartBlock, int nEndBlock)
776 {
777 enum { MAX_WHITESPACEBLOCK_SIZE = 8 };
778
779 int len = 0;
780 for (int i = nStartBlock; i <= nEndBlock; ++i)
781 len += viewData->GetLine(i).GetLength()+2;
782
783 CString block;
784 // do not check for whitespace blocks if the line is too long, because
785 // reserving a lot of memory here takes too much time (performance hog)
786 if (len > MAX_WHITESPACEBLOCK_SIZE*256)
787 return block;
788 block.Preallocate(len+1);
789 for (int i = nStartBlock; i <= nEndBlock; ++i)
790 {
791 block += viewData->GetLine(i);
792 block += m_Eols[viewData->GetLineEnding(i)];
793 }
794 return block;
795 }
796
797 bool CBaseView::IsBlockWhitespaceOnly(int nLineIndex, bool& bIdentical, int& blockstart, int& blockend)
798 {
799 if (!m_pViewData)
800 return false;
801 bIdentical = false;
802 CheckOtherView();
803 if (!m_pOtherViewData)
804 return false;
805 int viewLine = GetViewLineForScreen(nLineIndex);
806 if (
807 (m_pViewData->GetState(viewLine) == DIFFSTATE_NORMAL) &&
808 (m_pOtherViewData->GetLine(viewLine) == m_pViewData->GetLine(viewLine))
809 )
810 {
811 bIdentical = true;
812 return false;
813 }
814 // first check whether the line itself only has whitespace changes
815 CString mine = m_pViewData->GetLine(viewLine);
816 CString other = m_pOtherViewData->GetLine(min(viewLine, m_pOtherViewData->GetCount() - 1));
817 if (mine.IsEmpty() && other.IsEmpty())
818 {
819 bIdentical = true;
820 return false;
821 }
822
823 if (mine == other)
824 {
825 bIdentical = true;
826 return true;
827 }
828 FilterWhitespaces(mine, other);
829 if (mine == other)
830 return true;
831
832 int nStartBlock2, nEndBlock2;
833 GetWhitespaceBlock(m_pViewData, viewLine, blockstart, blockend);
834 GetWhitespaceBlock(m_pOtherViewData, min(viewLine, m_pOtherViewData->GetCount() - 1), nStartBlock2, nEndBlock2);
835 mine = GetWhitespaceString(m_pViewData, blockstart, blockend);
836 if (mine.IsEmpty())
837 bIdentical = false;
838 else
839 {
840 other = GetWhitespaceString(m_pOtherViewData, nStartBlock2, nEndBlock2);
841 bIdentical = mine == other;
842 FilterWhitespaces(mine, other);
843 }
844
845 return (!mine.IsEmpty()) && (mine == other);
846 }
847
848 bool CBaseView::IsViewLineHidden(int nViewLine)
849 {
850 return IsViewLineHidden(m_pViewData, nViewLine);
851 }
852
853 bool CBaseView::IsViewLineHidden(CViewData * pViewData, int nViewLine)
854 {
855 return m_pMainFrame->m_bCollapsed && (pViewData->GetHideState(nViewLine)!=HIDESTATE_SHOWN);
856 }
857
858 int CBaseView::GetLineNumber(int index) const
859 {
860 if (!m_pViewData)
861 return -1;
862 int viewLine = GetViewLineForScreen(index);
863 if (m_pViewData->GetLineNumber(viewLine)==DIFF_EMPTYLINENUMBER)
864 return -1;
865 return m_pViewData->GetLineNumber(viewLine);
866 }
867
868 int CBaseView::GetScreenLines()
869 {
870 if (m_nScreenLines == -1)
871 {
872 CRect rect;
873 GetClientRect(&rect);
874 SCROLLBARINFO sbi = { sizeof(sbi) };
875 if (GetScrollBarInfo(OBJID_HSCROLL, &sbi))
876 {
877 // only use the scroll bar size if the info is correct and the scrollbar is visible
878 // if anything isn't proper, assume the scrollbar has a size of zero
879 // and calculate the screen lines without it.
880 if (!(sbi.rgstate[0] & STATE_SYSTEM_INVISIBLE) && !(sbi.rgstate[0] & STATE_SYSTEM_UNAVAILABLE))
881 {
882 int scrollBarHeight = sbi.rcScrollBar.bottom - sbi.rcScrollBar.top;
883 m_nScreenLines = (rect.Height() - HEADERHEIGHT - scrollBarHeight) / GetLineHeight();
884 if (m_nScreenLines < 0)
885 m_nScreenLines = 0;
886 return m_nScreenLines;
887 }
888 }
889 // if the scroll bar is not visible, unavailable or there was an error,
890 // assume the scroll bar height is zero and return the screen lines here.
891 // Of course, that means the cache (using the member variable) won't work
892 // and we fetch the scroll bar info every time. But in this case the overhead is necessary.
893 return (rect.Height() - HEADERHEIGHT) / GetLineHeight();
894 }
895 return m_nScreenLines;
896 }
897
898 int CBaseView::GetAllMinScreenLines() const
899 {
900 int nLines = INT_MAX;
901 if (IsLeftViewGood())
902 nLines = m_pwndLeft->GetScreenLines();
903 if (IsRightViewGood())
904 nLines = std::min<int>(nLines, m_pwndRight->GetScreenLines());
905 if (IsBottomViewGood())
906 nLines = std::min<int>(nLines, m_pwndBottom->GetScreenLines());
907 return (nLines == INT_MAX) || (nLines < 0) ? 0 : nLines;
908 }
909
910 int CBaseView::GetAllLineCount() const
911 {
912 int nLines = 0;
913 if (IsLeftViewGood())
914 nLines = m_pwndLeft->GetLineCount();
915 if (IsRightViewGood())
916 nLines = std::max<int>(nLines, m_pwndRight->GetLineCount());
917 if (IsBottomViewGood())
918 nLines = std::max<int>(nLines, m_pwndBottom->GetLineCount());
919 return nLines;
920 }
921
922 void CBaseView::RecalcAllVertScrollBars(BOOL bPositionOnly /*= FALSE*/)
923 {
924 if (IsLeftViewGood())
925 m_pwndLeft->RecalcVertScrollBar(bPositionOnly);
926 if (IsRightViewGood())
927 m_pwndRight->RecalcVertScrollBar(bPositionOnly);
928 if (IsBottomViewGood())
929 m_pwndBottom->RecalcVertScrollBar(bPositionOnly);
930 }
931
932 void CBaseView::RecalcVertScrollBar(BOOL bPositionOnly /*= FALSE*/)
933 {
934 SCROLLINFO si;
935 si.cbSize = sizeof(si);
936 if (bPositionOnly)
937 {
938 si.fMask = SIF_POS;
939 si.nPos = m_nTopLine;
940 }
941 else
942 {
943 EnableScrollBarCtrl(SB_VERT, TRUE);
944 if (GetAllMinScreenLines() >= GetAllLineCount() && m_nTopLine > 0)
945 {
946 m_nTopLine = 0;
947 Invalidate();
948 }
949 si.fMask = SIF_DISABLENOSCROLL | SIF_PAGE | SIF_POS | SIF_RANGE;
950 si.nMin = 0;
951 si.nMax = GetAllLineCount();
952 si.nPage = GetAllMinScreenLines();
953 si.nPos = m_nTopLine;
954 }
955 VERIFY(SetScrollInfo(SB_VERT, &si));
956 }
957
958 void CBaseView::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
959 {
960 CView::OnVScroll(nSBCode, nPos, pScrollBar);
961 if (m_pwndLeft)
962 m_pwndLeft->OnDoVScroll(nSBCode, nPos, pScrollBar, this);
963 if (m_pwndRight)
964 m_pwndRight->OnDoVScroll(nSBCode, nPos, pScrollBar, this);
965 if (m_pwndBottom)
966 m_pwndBottom->OnDoVScroll(nSBCode, nPos, pScrollBar, this);
967 if (m_pwndLocator)
968 m_pwndLocator->Invalidate();
969 }
970
971 void CBaseView::OnDoVScroll(UINT nSBCode, UINT /*nPos*/, CScrollBar* /*pScrollBar*/, CBaseView * master)
972 {
973 // Note we cannot use nPos because of its 16-bit nature
974 SCROLLINFO si;
975 si.cbSize = sizeof(si);
976 si.fMask = SIF_ALL;
977 VERIFY(master->GetScrollInfo(SB_VERT, &si));
978
979 int nPageLines = GetScreenLines();
980 int nLineCount = GetLineCount();
981
982 int nNewTopLine;
983
984 static LONG textwidth = 0;
985 static CString sFormat(MAKEINTRESOURCE(IDS_VIEWSCROLLTIPTEXT));
986 switch (nSBCode)
987 {
988 case SB_TOP:
989 nNewTopLine = 0;
990 break;
991 case SB_BOTTOM:
992 nNewTopLine = nLineCount - nPageLines + 1;
993 break;
994 case SB_LINEUP:
995 nNewTopLine = m_nTopLine - 1;
996 break;
997 case SB_LINEDOWN:
998 nNewTopLine = m_nTopLine + 1;
999 break;
1000 case SB_PAGEUP:
1001 nNewTopLine = m_nTopLine - si.nPage + 1;
1002 break;
1003 case SB_PAGEDOWN:
1004 nNewTopLine = m_nTopLine + si.nPage - 1;
1005 break;
1006 case SB_THUMBPOSITION:
1007 m_ScrollTool.Clear();
1008 nNewTopLine = si.nTrackPos;
1009 textwidth = 0;
1010 break;
1011 case SB_THUMBTRACK:
1012 nNewTopLine = si.nTrackPos;
1013 if (GetFocus() == this)
1014 {
1015 RECT thumbrect;
1016 GetClientRect(&thumbrect);
1017 ClientToScreen(&thumbrect);
1018
1019 POINT thumbpoint;
1020 thumbpoint.x = thumbrect.right;
1021 thumbpoint.y = thumbrect.top + ((thumbrect.bottom-thumbrect.top)*si.nTrackPos)/(si.nMax-si.nMin);
1022 m_ScrollTool.Init(&thumbpoint);
1023 if (textwidth == 0)
1024 {
1025 CString sTemp = sFormat;
1026 sTemp.Format(sFormat, m_nDigits, 10*m_nDigits-1);
1027 textwidth = m_ScrollTool.GetTextWidth(sTemp);
1028 }
1029 thumbpoint.x -= textwidth;
1030 int line = GetLineNumber(nNewTopLine);
1031 if (line >= 0)
1032 m_ScrollTool.SetText(&thumbpoint, sFormat, m_nDigits, GetLineNumber(nNewTopLine)+1);
1033 else
1034 m_ScrollTool.SetText(&thumbpoint, m_sNoLineNr);
1035 }
1036 break;
1037 default:
1038 return;
1039 }
1040
1041 if (nNewTopLine < 0)
1042 nNewTopLine = 0;
1043 if (nNewTopLine >= nLineCount)
1044 nNewTopLine = nLineCount - 1;
1045 ScrollToLine(nNewTopLine);
1046 }
1047
1048 void CBaseView::RecalcAllHorzScrollBars(BOOL bPositionOnly /*= FALSE*/)
1049 {
1050 if (IsLeftViewGood())
1051 m_pwndLeft->RecalcHorzScrollBar(bPositionOnly);
1052 if (IsRightViewGood())
1053 m_pwndRight->RecalcHorzScrollBar(bPositionOnly);
1054 if (IsBottomViewGood())
1055 m_pwndBottom->RecalcHorzScrollBar(bPositionOnly);
1056 }
1057
1058 void CBaseView::RecalcHorzScrollBar(BOOL bPositionOnly /*= FALSE*/)
1059 {
1060 SCROLLINFO si;
1061 si.cbSize = sizeof(si);
1062 if (bPositionOnly)
1063 {
1064 si.fMask = SIF_POS;
1065 si.nPos = m_nOffsetChar;
1066 }
1067 else
1068 {
1069 EnableScrollBarCtrl(SB_HORZ, !m_pMainFrame->m_bWrapLines);
1070 if (!m_pMainFrame->m_bWrapLines)
1071 {
1072 int minScreenChars = GetAllMinScreenChars();
1073 int maxLineLength = GetAllMaxLineLength();
1074 if (minScreenChars >= maxLineLength && m_nOffsetChar > 0)
1075 {
1076 m_nOffsetChar = 0;
1077 Invalidate();
1078 }
1079 si.fMask = SIF_DISABLENOSCROLL | SIF_PAGE | SIF_POS | SIF_RANGE;
1080 si.nMin = 0;
1081 si.nMax = m_pMainFrame->m_bWrapLines ? minScreenChars : maxLineLength;
1082 si.nMax += GetMarginWidth()/GetCharWidth();
1083 si.nPage = GetScreenChars();
1084 si.nPos = m_nOffsetChar;
1085 }
1086 }
1087 VERIFY(SetScrollInfo(SB_HORZ, &si));
1088 }
1089
1090 void CBaseView::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
1091 {
1092 CView::OnHScroll(nSBCode, nPos, pScrollBar);
1093 if (m_pwndLeft)
1094 m_pwndLeft->OnDoHScroll(nSBCode, nPos, pScrollBar, this);
1095 if (m_pwndRight)
1096 m_pwndRight->OnDoHScroll(nSBCode, nPos, pScrollBar, this);
1097 if (m_pwndBottom)
1098 m_pwndBottom->OnDoHScroll(nSBCode, nPos, pScrollBar, this);
1099 if (m_pwndLocator)
1100 m_pwndLocator->Invalidate();
1101 }
1102
1103 void CBaseView::OnDoHScroll(UINT nSBCode, UINT /*nPos*/, CScrollBar* /*pScrollBar*/, CBaseView * master)
1104 {
1105 SCROLLINFO si;
1106 si.cbSize = sizeof(si);
1107 si.fMask = SIF_ALL;
1108 VERIFY(master->GetScrollInfo(SB_HORZ, &si));
1109
1110 int nPageChars = GetScreenChars();
1111 int nMaxLineLength = GetMaxLineLength();
1112
1113 int nNewOffset;
1114 switch (nSBCode)
1115 {
1116 case SB_LEFT:
1117 nNewOffset = 0;
1118 break;
1119 case SB_BOTTOM:
1120 nNewOffset = nMaxLineLength - nPageChars + 1;
1121 break;
1122 case SB_LINEUP:
1123 nNewOffset = m_nOffsetChar - 1;
1124 break;
1125 case SB_LINEDOWN:
1126 nNewOffset = m_nOffsetChar + 1;
1127 break;
1128 case SB_PAGEUP:
1129 nNewOffset = m_nOffsetChar - si.nPage + 1;
1130 break;
1131 case SB_PAGEDOWN:
1132 nNewOffset = m_nOffsetChar + si.nPage - 1;
1133 break;
1134 case SB_THUMBPOSITION:
1135 case SB_THUMBTRACK:
1136 nNewOffset = si.nTrackPos;
1137 break;
1138 default:
1139 return;
1140 }
1141
1142 if (nNewOffset >= nMaxLineLength)
1143 nNewOffset = nMaxLineLength - 1;
1144 if (nNewOffset < 0)
1145 nNewOffset = 0;
1146 ScrollToChar(nNewOffset, TRUE);
1147 }
1148
1149 void CBaseView::ScrollToChar(int nNewOffsetChar, BOOL bTrackScrollBar /*= TRUE*/)
1150 {
1151 if (m_nOffsetChar != nNewOffsetChar)
1152 {
1153 int nScrollChars = m_nOffsetChar - nNewOffsetChar;
1154 m_nOffsetChar = nNewOffsetChar;
1155 CRect rcScroll;
1156 GetClientRect(&rcScroll);
1157 rcScroll.left += GetMarginWidth();
1158 rcScroll.top += GetLineHeight()+HEADERHEIGHT;
1159 ScrollWindow(nScrollChars * GetCharWidth(), 0, &rcScroll, &rcScroll);
1160 // update the view header
1161 rcScroll.left = 0;
1162 rcScroll.top = 0;
1163 rcScroll.bottom = GetLineHeight()+HEADERHEIGHT;
1164 InvalidateRect(&rcScroll, FALSE);
1165 UpdateWindow();
1166 if (bTrackScrollBar)
1167 RecalcHorzScrollBar(TRUE);
1168 UpdateCaret();
1169 if (m_pwndLineDiffBar)
1170 m_pwndLineDiffBar->Invalidate();
1171 }
1172 }
1173
1174 void CBaseView::ScrollAllToChar(int nNewOffsetChar, BOOL bTrackScrollBar /* = TRUE */)
1175 {
1176 if (m_pwndLeft)
1177 m_pwndLeft->ScrollToChar(nNewOffsetChar, bTrackScrollBar);
1178 if (m_pwndRight)
1179 m_pwndRight->ScrollToChar(nNewOffsetChar, bTrackScrollBar);
1180 if (m_pwndBottom)
1181 m_pwndBottom->ScrollToChar(nNewOffsetChar, bTrackScrollBar);
1182 }
1183
1184 void CBaseView::ScrollAllSide(int delta)
1185 {
1186 int nNewOffset = m_nOffsetChar;
1187 nNewOffset += delta;
1188 int nMaxLineLength = GetMaxLineLength();
1189 if (nNewOffset >= nMaxLineLength)
1190 nNewOffset = nMaxLineLength - 1;
1191 if (nNewOffset < 0)
1192 nNewOffset = 0;
1193 ScrollAllToChar(nNewOffset, TRUE);
1194 if (m_pwndLineDiffBar)
1195 m_pwndLineDiffBar->Invalidate();
1196 UpdateCaret();
1197 }
1198
1199 void CBaseView::ScrollSide(int delta)
1200 {
1201 int nNewOffset = m_nOffsetChar;
1202 nNewOffset += delta;
1203 int nMaxLineLength = GetMaxLineLength();
1204 if (nNewOffset >= nMaxLineLength)
1205 nNewOffset = nMaxLineLength - 1;
1206 if (nNewOffset < 0)
1207 nNewOffset = 0;
1208 ScrollToChar(nNewOffset, TRUE);
1209 if (m_pwndLineDiffBar)
1210 m_pwndLineDiffBar->Invalidate();
1211 UpdateCaret();
1212 }
1213
1214 void CBaseView::ScrollVertical(short zDelta)
1215 {
1216 const int nLineCount = GetLineCount();
1217 int nTopLine = m_nTopLine;
1218 nTopLine -= (zDelta/30);
1219 if (nTopLine < 0)
1220 nTopLine = 0;
1221 if (nTopLine >= nLineCount)
1222 nTopLine = nLineCount - 1;
1223 ScrollToLine(nTopLine, TRUE);
1224 }
1225
1226 void CBaseView::ScrollToLine(int nNewTopLine, BOOL bTrackScrollBar /*= TRUE*/)
1227 {
1228 if (m_nTopLine != nNewTopLine)
1229 {
1230 if (nNewTopLine < 0)
1231 nNewTopLine = 0;
1232
1233 int nScrollLines = m_nTopLine - nNewTopLine;
1234
1235 m_nTopLine = nNewTopLine;
1236 CRect rcScroll;
1237 GetClientRect(&rcScroll);
1238 rcScroll.top += GetLineHeight()+HEADERHEIGHT;
1239 ScrollWindow(0, nScrollLines * GetLineHeight(), &rcScroll, &rcScroll);
1240 UpdateWindow();
1241 if (bTrackScrollBar)
1242 RecalcVertScrollBar(TRUE);
1243 UpdateCaret();
1244 }
1245 }
1246
1247
1248 void CBaseView::DrawMargin(CDC *pdc, const CRect &rect, int nLineIndex)
1249 {
1250 pdc->FillSolidRect(rect, ::GetSysColor(COLOR_SCROLLBAR));
1251
1252 if ((nLineIndex >= 0)&&(m_pViewData)&&(m_pViewData->GetCount()))
1253 {
1254 int nViewLine = GetViewLineForScreen(nLineIndex);
1255 HICON icon = nullptr;
1256 ASSERT(nViewLine<(int)m_ScreenedViewLine.size());
1257 TScreenedViewLine::EIcon eIcon = m_ScreenedViewLine[nViewLine].eIcon;
1258 if (eIcon==TScreenedViewLine::ICN_UNKNOWN)
1259 {
1260 DiffStates state = m_pViewData->GetState(nViewLine);
1261 switch (state)
1262 {
1263 case DIFFSTATE_ADDED:
1264 case DIFFSTATE_THEIRSADDED:
1265 case DIFFSTATE_YOURSADDED:
1266 case DIFFSTATE_IDENTICALADDED:
1267 case DIFFSTATE_CONFLICTADDED:
1268 eIcon = TScreenedViewLine::ICN_ADD;
1269 break;
1270 case DIFFSTATE_REMOVED:
1271 case DIFFSTATE_THEIRSREMOVED:
1272 case DIFFSTATE_YOURSREMOVED:
1273 case DIFFSTATE_IDENTICALREMOVED:
1274 eIcon = TScreenedViewLine::ICN_REMOVED;
1275 break;
1276 case DIFFSTATE_CONFLICTED:
1277 eIcon = TScreenedViewLine::ICN_CONFLICT;
1278 break;
1279 case DIFFSTATE_CONFLICTED_IGNORED:
1280 eIcon = TScreenedViewLine::ICN_CONFLICTIGNORED;
1281 break;
1282 case DIFFSTATE_EDITED:
1283 eIcon = TScreenedViewLine::ICN_EDIT;
1284 break;
1285 default:
1286 break;
1287 }
1288 bool bIdentical = false;
1289 int blockstart = -1;
1290 int blockend = -1;
1291 if ((state != DIFFSTATE_EDITED)&&(IsBlockWhitespaceOnly(nLineIndex, bIdentical, blockstart, blockend)))
1292 {
1293 if (bIdentical)
1294 eIcon = TScreenedViewLine::ICN_SAME;
1295 else
1296 eIcon = TScreenedViewLine::ICN_WHITESPACEDIFF;
1297 if (((blockstart >= 0) && (blockend >= 0)) && (blockstart < blockend))
1298 {
1299 if (nViewLine > blockstart)
1300 Invalidate(); // redraw the upper icons since they're now changing
1301 while (blockstart <= blockend)
1302 m_ScreenedViewLine[blockstart++].eIcon = eIcon;
1303 }
1304 }
1305 if (m_pViewData->GetMovedIndex(nViewLine) >= 0)
1306 eIcon = TScreenedViewLine::ICN_MOVED;
1307 if (m_pViewData->GetMarked(nViewLine))
1308 eIcon = TScreenedViewLine::ICN_MARKED;
1309 m_ScreenedViewLine[nViewLine].eIcon = eIcon;
1310 }
1311 switch (eIcon)
1312 {
1313 case TScreenedViewLine::ICN_UNKNOWN:
1314 case TScreenedViewLine::ICN_NONE:
1315 break;
1316 case TScreenedViewLine::ICN_SAME:
1317 icon = m_hEqualIcon;
1318 break;
1319 case TScreenedViewLine::ICN_EDIT:
1320 icon = m_hEditedIcon;
1321 break;
1322 case TScreenedViewLine::ICN_WHITESPACEDIFF:
1323 icon = m_hWhitespaceBlockIcon;
1324 break;
1325 case TScreenedViewLine::ICN_ADD:
1326 icon = m_hAddedIcon;
1327 break;
1328 case TScreenedViewLine::ICN_CONFLICT:
1329 icon = m_hConflictedIcon;
1330 break;
1331 case TScreenedViewLine::ICN_CONFLICTIGNORED:
1332 icon = m_hConflictedIgnoredIcon;
1333 break;
1334 case TScreenedViewLine::ICN_REMOVED:
1335 icon = m_hRemovedIcon;
1336 break;
1337 case TScreenedViewLine::ICN_MOVED:
1338 icon = m_hMovedIcon;
1339 break;
1340 case TScreenedViewLine::ICN_MARKED:
1341 icon = m_hMarkedIcon;
1342 break;
1343 }
1344
1345 int iconWidth = GetSystemMetrics(SM_CXSMICON);
1346 int iconHeight = GetSystemMetrics(SM_CYSMICON);
1347 if (icon)
1348 {
1349 ::DrawIconEx(pdc->m_hDC, rect.left + 2, rect.top + (rect.Height() - iconHeight) / 2, icon, iconWidth, iconHeight, 0, nullptr, DI_NORMAL);
1350 }
1351 if ((m_bViewLinenumbers)&&(m_nDigits))
1352 {
1353 int nSubLine = GetSubLineOffset(nLineIndex);
1354 bool bIsFirstSubline = (nSubLine == 0) || (nSubLine == -1);
1355 CString sLinenumber;
1356 if (bIsFirstSubline)
1357 {
1358 CString sLinenumberFormat;
1359 int nLineNumber = GetLineNumber(nLineIndex);
1360 if (IsViewLineHidden(GetViewLineForScreen(nLineIndex)))
1361 {
1362 // TODO: do not show if there is no number hidden
1363 // TODO: show number if there is only one
1364 sLinenumberFormat.Format(L"%%%ds", m_nDigits);
1365 sLinenumber.Format(sLinenumberFormat, (m_nDigits>1) ? L"↕⁞" : L"⁞"); // alternative …
1366 }
1367 else if (nLineNumber >= 0)
1368 {
1369 sLinenumberFormat.Format(L"%%%dd", m_nDigits);
1370 sLinenumber.Format(sLinenumberFormat, nLineNumber+1);
1371 }
1372 else if (m_pMainFrame->m_bWrapLines)
1373 {
1374 sLinenumberFormat.Format(L"%%%ds", m_nDigits);
1375 sLinenumber.Format(sLinenumberFormat, L"·");
1376 }
1377 if (!sLinenumber.IsEmpty())
1378 {
1379 pdc->SetBkColor(::GetSysColor(COLOR_SCROLLBAR));
1380 pdc->SetTextColor(::GetSysColor(COLOR_WINDOWTEXT));
1381
1382 pdc->SelectObject(GetFont());
1383 pdc->ExtTextOut(rect.left + iconWidth + 2, rect.top, ETO_CLIPPED, &rect, sLinenumber, nullptr);
1384 }
1385 }
1386 }
1387 }
1388 }
1389
1390 int CBaseView::GetMarginWidth()
1391 {
1392 int marginWidth = GetSystemMetrics(SM_CXSMICON) + 2 + 2;
1393
1394 if ((m_bViewLinenumbers)&&(m_pViewData)&&(m_pViewData->GetCount()))
1395 {
1396 if (m_nDigits <= 0)
1397 {
1398 int nLength = (int)m_pViewData->GetCount();
1399 // find out how many digits are needed to show the highest line number
1400 CString sMax;
1401 sMax.Format(L"%d", nLength);
1402 m_nDigits = sMax.GetLength();
1403 }
1404 int nWidth = GetCharWidth();
1405 marginWidth += (m_nDigits * nWidth) + 2;
1406 }
1407
1408 return marginWidth;
1409 }
1410
1411 void CBaseView::DrawHeader(CDC *pdc, const CRect &rect)
1412 {
1413 CRect textrect(rect.left, rect.top, rect.Width(), GetLineHeight()+HEADERHEIGHT);
1414 COLORREF crBk, crFg;
1415 if (IsBottomViewGood())
1416 {
1417 CDiffColors::GetInstance().GetColors(DIFFSTATE_NORMAL, crBk, crFg);
1418 crBk = ::GetSysColor(COLOR_SCROLLBAR);
1419 }
1420 else
1421 {
1422 DiffStates state = DIFFSTATE_REMOVED;
1423 if (this == m_pwndRight)
1424 {
1425 state = DIFFSTATE_ADDED;
1426 }
1427 CDiffColors::GetInstance().GetColors(state, crBk, crFg);
1428 }
1429 pdc->SetBkColor(crBk);
1430 pdc->FillSolidRect(textrect, crBk);
1431
1432 pdc->SetTextColor(crFg);
1433
1434 pdc->SelectObject(GetFont(FALSE, TRUE));
1435
1436 CString sViewTitle;
1437 if (IsModified())
1438 {
1439 sViewTitle = L"* " + m_sWindowName;
1440 }
1441 else
1442 {
1443 sViewTitle = m_sWindowName;
1444 }
1445 int nStringLength = (GetCharWidth()*m_sWindowName.GetLength());
1446 if (nStringLength > rect.Width())
1447 {
1448 int offset = std::min<int>(m_nOffsetChar, (nStringLength-rect.Width())/GetCharWidth()+1);
1449 sViewTitle = m_sWindowName.Mid(offset);
1450 }
1451 pdc->ExtTextOut(std::max<int>(rect.left + (rect.Width()-nStringLength)/2, 1),
1452 rect.top + (HEADERHEIGHT / 2), ETO_CLIPPED, textrect, sViewTitle, nullptr);
1453 if (this->GetFocus() == this)
1454 pdc->DrawEdge(textrect, EDGE_BUMP, BF_RECT);
1455 else
1456 pdc->DrawEdge(textrect, EDGE_ETCHED, BF_RECT);
1457 }
1458
1459 void CBaseView::OnDraw(CDC * pDC)
1460 {
1461 CRect rcClient;
1462 GetClientRect(rcClient);
1463
1464 int nLineCount = GetLineCount();
1465 int nLineHeight = GetLineHeight();
1466
1467 CDC cacheDC;
1468 VERIFY(cacheDC.CreateCompatibleDC(pDC));
1469 if (!m_pCacheBitmap)
1470 {
1471 m_pCacheBitmap = new CBitmap;
1472 VERIFY(m_pCacheBitmap->CreateCompatibleBitmap(pDC, rcClient.Width(), nLineHeight));
1473 }
1474 CBitmap *pOldBitmap = cacheDC.SelectObject(m_pCacheBitmap);
1475
1476 DrawHeader(pDC, rcClient);
1477
1478 CRect rcLine;
1479 rcLine = rcClient;
1480 rcLine.top += nLineHeight+HEADERHEIGHT;
1481 rcLine.bottom = rcLine.top + nLineHeight;
1482 CRect rcCacheMargin(0, 0, GetMarginWidth(), nLineHeight);
1483 CRect rcCacheLine(GetMarginWidth(), 0, rcLine.Width(), nLineHeight);
1484
1485 int nCurrentLine = m_nTopLine;
1486 bool bBeyondFileLineCached = false;
1487 while (rcLine.top < rcClient.bottom)
1488 {
1489 if (nCurrentLine < nLineCount)
1490 {
1491 DrawMargin(&cacheDC, rcCacheMargin, nCurrentLine);
1492 DrawSingleLine(&cacheDC, rcCacheLine, nCurrentLine);
1493 bBeyondFileLineCached = false;
1494 }
1495 else if (!bBeyondFileLineCached)
1496 {
1497 DrawMargin(&cacheDC, rcCacheMargin, -1);
1498 DrawSingleLine(&cacheDC, rcCacheLine, -1);
1499 bBeyondFileLineCached = true;
1500 }
1501
1502 VERIFY(pDC->BitBlt(rcLine.left, rcLine.top, rcLine.Width(), rcLine.Height(), &cacheDC, 0, 0, SRCCOPY));
1503
1504 nCurrentLine ++;
1505 rcLine.OffsetRect(0, nLineHeight);
1506 }
1507
1508 cacheDC.SelectObject(pOldBitmap);
1509 cacheDC.DeleteDC();
1510 }
1511
1512 bool CBaseView::IsStateConflicted(DiffStates state)
1513 {
1514 switch (state)
1515 {
1516 case DIFFSTATE_CONFLICTED:
1517 case DIFFSTATE_CONFLICTED_IGNORED:
1518 case DIFFSTATE_CONFLICTEMPTY:
1519 case DIFFSTATE_CONFLICTADDED:
1520 return true;
1521 }
1522 return false;
1523 }
1524
1525 bool CBaseView::IsStateEmpty(DiffStates state)
1526 {
1527 switch (state)
1528 {
1529 case DIFFSTATE_CONFLICTEMPTY:
1530 case DIFFSTATE_UNKNOWN:
1531 case DIFFSTATE_EMPTY:
1532 return true;
1533 }
1534 return false;
1535 }
1536
1537 bool CBaseView::IsStateRemoved(DiffStates state)
1538 {
1539 switch (state)
1540 {
1541 case DIFFSTATE_REMOVED:
1542 case DIFFSTATE_THEIRSREMOVED:
1543 case DIFFSTATE_YOURSREMOVED:
1544 case DIFFSTATE_IDENTICALREMOVED:
1545 return true;
1546 }
1547 return false;
1548 }
1549
1550 DiffStates CBaseView::ResolveState(DiffStates state)
1551 {
1552 if (IsStateConflicted(state))
1553 {
1554 if (state == DIFFSTATE_CONFLICTEMPTY)
1555 return DIFFSTATE_CONFLICTRESOLVEDEMPTY;
1556 else
1557 return DIFFSTATE_CONFLICTRESOLVED;
1558 }
1559 return state;
1560 }
1561
1562
1563 bool CBaseView::IsLineEmpty(int nLineIndex)
1564 {
1565 if (m_pViewData == 0)
1566 return FALSE;
1567 int nViewLine = GetViewLineForScreen(nLineIndex);
1568 return IsViewLineEmpty(nViewLine);
1569 }
1570
1571 bool CBaseView::IsViewLineEmpty(int nViewLine)
1572 {
1573 if (m_pViewData == 0)
1574 return FALSE;
1575 const DiffStates state = m_pViewData->GetState(nViewLine);
1576 return IsStateEmpty(state);
1577 }
1578
1579 bool CBaseView::IsLineRemoved(int nLineIndex)
1580 {
1581 if (m_pViewData == 0)
1582 return FALSE;
1583 int nViewLine = GetViewLineForScreen(nLineIndex);
1584 return IsViewLineRemoved(nViewLine);
1585 }
1586
1587 bool CBaseView::IsViewLineRemoved(int nViewLine)
1588 {
1589 if (m_pViewData == 0)
1590 return FALSE;
1591 const DiffStates state = m_pViewData->GetState(nViewLine);
1592 return IsStateRemoved(state);
1593 }
1594
1595 bool CBaseView::IsViewLineConflicted(int nLineIndex)
1596 {
1597 if (m_pViewData == 0)
1598 return false;
1599 const DiffStates state = m_pViewData->GetState(nLineIndex);
1600 return IsStateConflicted(state);
1601 }
1602
1603 COLORREF CBaseView::InlineDiffColor(int nLineIndex)
1604 {
1605 return IsLineRemoved(nLineIndex) ? m_InlineRemovedBk : m_InlineAddedBk;
1606 }
1607
1608 COLORREF CBaseView::InlineViewLineDiffColor(int nViewLine)
1609 {
1610 return IsViewLineRemoved(nViewLine) ? m_InlineRemovedBk : m_InlineAddedBk;
1611 }
1612
1613 void CBaseView::DrawLineEnding(CDC *pDC, const CRect &rc, int nLineIndex, const CPoint& origin)
1614 {
1615 if (origin.x < (rc.left - GetCharWidth() +1))
1616 return;
1617 if (!(m_bViewWhitespace && m_pViewData && (nLineIndex >= 0) && (nLineIndex < GetLineCount())))
1618 return;
1619 int viewLine = GetViewLineForScreen(nLineIndex);
1620 EOL ending = m_pViewData->GetLineEnding(viewLine);
1621 if (m_bIconLFs)
1622 {
1623 HICON hEndingIcon = nullptr;
1624 switch (ending)
1625 {
1626 case EOL_CR: hEndingIcon = m_hLineEndingCR; break;
1627 case EOL_CRLF: hEndingIcon = m_hLineEndingCRLF; break;
1628 case EOL_LF: hEndingIcon = m_hLineEndingLF; break;
1629 default: return;
1630 }
1631 // If EOL style has changed, color end-of-line markers as inline differences.
1632 if(
1633 m_bShowInlineDiff && m_pOtherViewData &&
1634 (viewLine < m_pOtherViewData->GetCount()) &&
1635 (ending != EOL_NOENDING) &&
1636 (ending != m_pOtherViewData->GetLineEnding(viewLine) &&
1637 (m_pOtherViewData->GetLineEnding(viewLine) != EOL_NOENDING))
1638 )
1639 {
1640 pDC->FillSolidRect(origin.x, origin.y, rc.Height(), rc.Height(), InlineDiffColor(nLineIndex));
1641 }
1642
1643 DrawIconEx(pDC->GetSafeHdc(), origin.x, origin.y, hEndingIcon, rc.Height(), rc.Height(), 0, nullptr, DI_NORMAL);
1644 }
1645 else
1646 {
1647 CDpiScale dpi(pDC->GetSafeHdc());
1648 CPen pen(PS_SOLID, 0, m_WhiteSpaceFg);
1649 CPen * oldpen = pDC->SelectObject(&pen);
1650 int yMiddle = origin.y + rc.Height()/2;
1651 int xMiddle = origin.x+GetCharWidth()/2;
1652 bool bMultiline = false;
1653 if (((int)m_Screen2View.size() > nLineIndex+1) && (GetViewLineForScreen(nLineIndex+1) == viewLine))
1654 {
1655 if (GetLineLength(nLineIndex+1))
1656 {
1657 // multiline
1658 bMultiline = true;
1659 pDC->MoveTo(origin.x, yMiddle-dpi.ScaleY(2));
1660 pDC->LineTo(origin.x + GetCharWidth() - dpi.ScaleX(1), yMiddle - dpi.ScaleY(2));
1661 pDC->LineTo(origin.x + GetCharWidth() - dpi.ScaleX(1), yMiddle + dpi.ScaleY(2));
1662 pDC->LineTo(origin.x, yMiddle + dpi.ScaleY(2));
1663 }
1664 else if (GetLineLength(nLineIndex) == 0)
1665 bMultiline = true;
1666 }
1667 else if ((nLineIndex > 0) && (GetViewLineForScreen(nLineIndex-1) == viewLine) && (GetLineLength(nLineIndex) == 0))
1668 bMultiline = true;
1669
1670 if (!bMultiline)
1671 {
1672 switch (ending)
1673 {
1674 case EOL_AUTOLINE:
1675 case EOL_CRLF:
1676 // arrow from top to middle+2, then left
1677 pDC->MoveTo(origin.x + GetCharWidth() - dpi.ScaleX(1), rc.top+dpi.ScaleY(1));
1678 pDC->LineTo(origin.x + GetCharWidth() - dpi.ScaleX(1), yMiddle);
1679 case EOL_CR:
1680 // arrow from right to left
1681 pDC->MoveTo(origin.x + GetCharWidth() - dpi.ScaleX(1), yMiddle);
1682 pDC->LineTo(origin.x, yMiddle);
1683 pDC->LineTo(origin.x + dpi.ScaleX(4), yMiddle + dpi.ScaleY(4));
1684 pDC->MoveTo(origin.x, yMiddle);
1685 pDC->LineTo(origin.x + dpi.ScaleX(4), yMiddle - dpi.ScaleY(4));
1686 break;
1687 case EOL_LFCR:
1688 // from right-upper to left then down
1689 pDC->MoveTo(origin.x + GetCharWidth() - dpi.ScaleX(1), yMiddle-dpi.ScaleY(2));
1690 pDC->LineTo(xMiddle, yMiddle - dpi.ScaleY(2));
1691 pDC->LineTo(xMiddle, rc.bottom - dpi.ScaleY(1));
1692 pDC->LineTo(xMiddle + dpi.ScaleX(4), rc.bottom - dpi.ScaleY(5));
1693 pDC->MoveTo(xMiddle, rc.bottom - dpi.ScaleY(1));
1694 pDC->LineTo(xMiddle - dpi.ScaleX(4), rc.bottom - dpi.ScaleY(5));
1695 break;
1696 case EOL_LF:
1697 // arrow from top to bottom
1698 pDC->MoveTo(xMiddle, rc.top);
1699 pDC->LineTo(xMiddle, rc.bottom - dpi.ScaleY(1));
1700 pDC->LineTo(xMiddle + dpi.ScaleX(4), rc.bottom - dpi.ScaleY(5));
1701 pDC->MoveTo(xMiddle, rc.bottom - dpi.ScaleY(1));
1702 pDC->LineTo(xMiddle - dpi.ScaleX(4), rc.bottom - dpi.ScaleY(5));
1703 break;
1704 case EOL_FF: // Form Feed, U+000C
1705 case EOL_NEL: // Next Line, U+0085
1706 case EOL_LS: // Line Separator, U+2028
1707 case EOL_PS: // Paragraph Separator, U+2029
1708 // draw a horizontal line at the bottom of this line
1709 pDC->FillSolidRect(rc.left, rc.bottom-1, rc.right, rc.bottom, GetSysColor(COLOR_WINDOWTEXT));
1710 pDC->MoveTo(origin.x+GetCharWidth()-1, rc.bottom-GetCharWidth()-2);
1711 pDC->LineTo(origin.x, rc.bottom-2);
1712 pDC->LineTo(origin.x+5, rc.bottom-2);
1713 pDC->MoveTo(origin.x, rc.bottom-2);
1714 pDC->LineTo(origin.x+1, rc.bottom-6);
1715 break;
1716 default: // other EOLs
1717 // arrow from top right to bottom left
1718 pDC->MoveTo(origin.x+GetCharWidth()-1, rc.bottom-GetCharWidth());
1719 pDC->LineTo(origin.x, rc.bottom-1);
1720 pDC->LineTo(origin.x+5, rc.bottom-2);
1721 pDC->MoveTo(origin.x, rc.bottom-1);
1722 pDC->LineTo(origin.x+1, rc.bottom-6);
1723 break;
1724 case EOL_NOENDING:
1725 break;
1726 }
1727 }
1728 pDC->SelectObject(oldpen);
1729 }
1730 }
1731
1732 void CBaseView::DrawBlockLine(CDC *pDC, const CRect &rc, int nLineIndex)
1733 {
1734 if (!m_bShowSelection)
1735 return;
1736
1737 int nSelBlockStart;
1738 int nSelBlockEnd;
1739 if (!GetViewSelection(nSelBlockStart, nSelBlockEnd))
1740 return;
1741
1742 const int THICKNESS = 2;
1743 COLORREF rectcol = GetSysColor(m_bFocused ? COLOR_WINDOWTEXT : COLOR_GRAYTEXT);
1744
1745 int nViewLineIndex = GetViewLineForScreen(nLineIndex);
1746 int nSubLine = GetSubLineOffset(nLineIndex);
1747 bool bFirstLineOfViewLine = (nSubLine==0 || nSubLine==-1);
1748 if ((nViewLineIndex == nSelBlockStart) && bFirstLineOfViewLine)
1749 {
1750 pDC->FillSolidRect(rc.left, rc.top, rc.Width(), THICKNESS, rectcol);
1751 }
1752
1753 bool bLastLineOfViewLine = (nLineIndex+1 == m_Screen2View.size()) || (GetViewLineForScreen(nLineIndex) != GetViewLineForScreen(nLineIndex+1));
1754 if ((nViewLineIndex == nSelBlockEnd) && bLastLineOfViewLine)
1755 {
1756 pDC->FillSolidRect(rc.left, rc.bottom - THICKNESS, rc.Width(), THICKNESS, rectcol);
1757 }
1758 }
1759
1760 void CBaseView::DrawTextLine(
1761 CDC * pDC, const CRect &rc, int nLineIndex, POINT& coords)
1762 {
1763 ASSERT(nLineIndex < GetLineCount());
1764 int nViewLine = GetViewLineForScreen(nLineIndex);
1765 ASSERT(m_pViewData && (nViewLine < m_pViewData->GetCount()));
1766
1767 LineColors lineCols = GetLineColors(nViewLine);
1768
1769 CString sViewLine = GetViewLineChars(nViewLine);
1770 // mark selection
1771 if (m_bShowSelection && HasTextSelection())
1772 {
1773 // has this line selection ?
1774 if ((m_ptSelectionViewPosStart.y <= nViewLine) && (nViewLine <= m_ptSelectionViewPosEnd.y))
1775 {
1776 int nViewLineLength = sViewLine.GetLength();
1777
1778 // first suppose the whole line is selected
1779 int selectedStart = 0;
1780 int selectedEnd = nViewLineLength;
1781
1782 // the view line is partially selected
1783 if (m_ptSelectionViewPosStart.y == nViewLine)
1784 {
1785 selectedStart = m_ptSelectionViewPosStart.x;
1786 }
1787
1788 if (m_ptSelectionViewPosEnd.y == nViewLine)
1789 {
1790 selectedEnd = m_ptSelectionViewPosEnd.x;
1791 }
1792 // apply selection coloring
1793 // First enforce start and end point
1794 lineCols.SplitBlock(selectedStart);
1795 lineCols.SplitBlock(selectedEnd);
1796 // change color of affected parts
1797 long intenseColorScale = m_bFocused ? 70 : 30;
1798 std::map<int, linecolors_t>::iterator it = lineCols.lower_bound(selectedStart);
1799 for ( ; it != lineCols.end() && it->first < selectedEnd; ++it)
1800 {
1801 auto& second = it->second;
1802 COLORREF crBk = CAppUtils::IntenseColor(intenseColorScale, second.background);
1803 if (second.shot == second.background)
1804 second.shot = crBk;
1805 second.background = crBk;
1806 second.text = CAppUtils::IntenseColor(intenseColorScale, second.text);
1807 }
1808 }
1809 }
1810
1811 // TODO: remove duplicate from selection and mark
1812 if (!m_sMarkedWord.IsEmpty())
1813 {
1814 int nMarkLength = m_sMarkedWord.GetLength();
1815 //int nViewLineLength = sViewLine.GetLength();
1816 const TCHAR * text = sViewLine;
1817 const TCHAR * findText = text;
1818 while ((findText = wcsstr(findText, (LPCTSTR)m_sMarkedWord))!=0)
1819 {
1820 int nMarkStart = static_cast<int>(findText - text);
1821 int nMarkEnd = nMarkStart + nMarkLength;
1822 findText += nMarkLength;
1823 ECharGroup eLeft = GetCharGroup(sViewLine, nMarkStart - 1);
1824 ECharGroup eStart = GetCharGroup(sViewLine, nMarkStart);
1825 if (eLeft == eStart)
1826 continue;
1827 ECharGroup eRight = GetCharGroup(sViewLine, nMarkEnd);
1828 ECharGroup eEnd = GetCharGroup(sViewLine, nMarkEnd - 1);
1829 if (eRight == eEnd)
1830 continue;
1831
1832 // First enforce start and end point
1833 lineCols.SplitBlock(nMarkStart);
1834 lineCols.SplitBlock(nMarkEnd);
1835 // change color of affected parts
1836 const long int nIntenseColorScale = 200;
1837 std::map<int, linecolors_t>::iterator it = lineCols.lower_bound(nMarkStart);
1838 for ( ; it != lineCols.end() && it->first < nMarkEnd; ++it)
1839 {
1840 auto& second = it->second;
1841 COLORREF crBk = CAppUtils::IntenseColor(nIntenseColorScale, second.background);
1842 if (second.shot == second.background)
1843 second.shot = crBk;
1844 second.background = crBk;
1845 second.text = CAppUtils::IntenseColor(nIntenseColorScale, second.text);
1846 }
1847 }
1848 }
1849 if (!m_sFindText.IsEmpty())
1850 {
1851 int nMarkStart = 0;
1852 int nMarkEnd = 0;
1853 int nStringPos = nMarkStart;
1854 CString searchLine = sViewLine;
1855 if (!m_bMatchCase)
1856 searchLine.MakeLower();
1857 while (StringFound(searchLine, SearchNext, nMarkStart, nMarkEnd)!=0)
1858 {
1859 // First enforce start and end point
1860 lineCols.SplitBlock(nMarkStart+nStringPos);
1861 lineCols.SplitBlock(nMarkEnd+nStringPos);
1862 // change color of affected parts
1863 const long int nIntenseColorScale = 30;
1864 std::map<int, linecolors_t>::iterator it = lineCols.lower_bound(nMarkStart+nStringPos);
1865 for ( ; it != lineCols.end() && it->first < nMarkEnd; ++it)
1866 {
1867 auto& second = it->second;
1868 COLORREF crBk = CAppUtils::IntenseColor(nIntenseColorScale, second.background);
1869 if (second.shot == second.background)
1870 second.shot = crBk;
1871 second.background = crBk;
1872 second.text = CAppUtils::IntenseColor(nIntenseColorScale, second.text);
1873 }
1874 searchLine = searchLine.Mid(nMarkEnd);
1875 nStringPos = nMarkEnd;
1876 nMarkStart = 0;
1877 nMarkEnd = 0;
1878 }
1879 }
1880
1881 // @ this point we may cache data for next line which may be same in wrapped mode
1882
1883 int nTextOffset = 0;
1884 int nSubline = GetSubLineOffset(nLineIndex);
1885 for (int n=0; n<nSubline; n++)
1886 {
1887 CString sLine = m_ScreenedViewLine[nViewLine].SubLines[n];
1888 nTextOffset += sLine.GetLength();
1889 }
1890
1891 CString sLine = GetLineChars(nLineIndex);
1892 int nLineLength = sLine.GetLength();
1893 CString sLineExp = ExpandChars(sLine);
1894 LPCTSTR textExp = sLineExp;
1895 //int nLineLengthExp = sLineExp.GetLength();
1896 int nStartExp = 0;
1897 int nLeft = coords.x;
1898 for (std::map<int, linecolors_t>::const_iterator itStart = lineCols.begin(); itStart != lineCols.end(); ++itStart)
1899 {
1900 std::map<int, linecolors_t>::const_iterator itEnd = itStart;
1901 ++itEnd;
1902 int nStart = std::max<int>(0, itStart->first - nTextOffset);
1903 int nEnd = nLineLength;
1904 if (itEnd != lineCols.end())
1905 {
1906 nEnd = std::min<int>(nEnd, itEnd->first - nTextOffset);
1907 }
1908 int nBlockLength = nEnd - nStart;
1909 if (nBlockLength > 0 && nEnd>=0)
1910 {
1911 auto& second = itStart->second;
1912 pDC->SetBkColor(second.background);
1913 pDC->SetTextColor(second.text);
1914 int nEndExp = CountExpandedChars(sLine, nEnd);
1915 int nTextLength = nEndExp - nStartExp;
1916 LPCTSTR p_zBlockText = textExp + nStartExp;
1917 SIZE Size;
1918 GetTextExtentPoint32(pDC->GetSafeHdc(), p_zBlockText, nTextLength, &Size); // falls time-2-tme
1919 int nRight = nLeft + Size.cx;
1920 if ((nRight > rc.left) && (nLeft < rc.right))
1921 {
1922 // note: ExtTextOut has a limit for the length of the string. That limit is supposed
1923 // to be 8192, but that's not really true: I found that the limit (at least on my machine and a few others)
1924 // is 4094 (4095 doesn't work anymore).
1925 // So we limit the length here to that 4094 chars.
1926 // In case we're scrolled to the right, there's no need to draw the string
1927 // from way outside our window, so we also offset the drawing to the start of the window.
1928 // This reduces the string length as well.
1929 int offset = 0;
1930 int leftcoord = nLeft;
1931 if (nLeft < 0)
1932 {
1933 int fit = nTextLength;
1934 auto posBuffer = std::make_unique<int[]>(fit);
1935 GetTextExtentExPoint(pDC->GetSafeHdc(), p_zBlockText, nTextLength, INT_MAX, &fit, posBuffer.get(), &Size);
1936 int lower = 0, upper = fit - 1;
1937 do
1938 {
1939 int middle = (upper + lower + 1) / 2;
1940 int width = posBuffer[middle];
1941 if (rc.left - nLeft < width)
1942 upper = middle - 1;
1943 else
1944 lower = middle;
1945 } while (lower < upper);
1946
1947 offset = lower;
1948 nTextLength -= offset;
1949 leftcoord += lower > 0 ? posBuffer[lower - 1] : 0;
1950 }
1951
1952 pDC->ExtTextOut(leftcoord, coords.y, ETO_CLIPPED, &rc, p_zBlockText + offset, min(nTextLength, 4094), nullptr);
1953 if ((second.shot != second.background) && (itStart->first == nStart + nTextOffset))
1954 pDC->FillSolidRect(nLeft - 1, rc.top, 1, rc.Height(), second.shot);
1955 }
1956 nLeft = nRight;
1957 coords.x = nRight;
1958 nStartExp = nEndExp;
1959 }
1960 }
1961 }
1962
1963 void CBaseView::DrawSingleLine(CDC *pDC, const CRect &rc, int nLineIndex)
1964 {
1965 if (nLineIndex >= GetLineCount())
1966 nLineIndex = -1;
1967 ASSERT(nLineIndex >= -1);
1968
1969 if ((nLineIndex == -1) || !m_pViewData)
1970 {
1971 // Draw line beyond the text
1972 COLORREF crBkgnd, crText;
1973 CDiffColors::GetInstance().GetColors(DIFFSTATE_UNKNOWN, crBkgnd, crText);
1974 pDC->FillSolidRect(rc, crBkgnd);
1975 return;
1976 }
1977
1978 int viewLine = GetViewLineForScreen(nLineIndex);
1979 if (m_pMainFrame->m_bCollapsed)
1980 {
1981 if (m_pViewData->GetHideState(viewLine) == HIDESTATE_MARKER)
1982 {
1983 COLORREF crBkgnd, crText;
1984 CDiffColors::GetInstance().GetColors(DIFFSTATE_UNKNOWN, crBkgnd, crText);
1985 pDC->FillSolidRect(rc, crBkgnd);
1986
1987 const int THICKNESS = 2;
1988 COLORREF rectcol = GetSysColor(COLOR_WINDOWTEXT);
1989 pDC->FillSolidRect(rc.left, rc.top + (rc.Height()/2), rc.Width(), THICKNESS, rectcol);
1990 pDC->SetTextColor(GetSysColor(COLOR_GRAYTEXT));
1991 pDC->SetBkColor(crBkgnd);
1992 CRect rect = rc;
1993 pDC->DrawText(L"{...}", &rect, DT_NOPREFIX|DT_SINGLELINE|DT_CENTER);
1994 return;
1995 }
1996 }
1997
1998 DiffStates diffState = m_pViewData->GetState(viewLine);
1999 COLORREF crBkgnd, crText;
2000 CDiffColors::GetInstance().GetColors(diffState, crBkgnd, crText);
2001
2002 if (diffState == DIFFSTATE_CONFLICTED)
2003 {
2004 // conflicted lines are shown without 'text' on them
2005 CRect rect = rc;
2006 pDC->FillSolidRect(rc, crBkgnd);
2007 // now draw some faint text patterns
2008 pDC->SetTextColor(CAppUtils::IntenseColor(130, crBkgnd));
2009 pDC->DrawText(m_sConflictedText, rect, DT_LEFT|DT_NOPREFIX|DT_SINGLELINE);
2010 DrawBlockLine(pDC, rc, nLineIndex);
2011 return;
2012 }
2013
2014 CPoint origin(rc.left - m_nOffsetChar * GetCharWidth(), rc.top);
2015 CString sLine = GetLineChars(nLineIndex);
2016 if (sLine.IsEmpty())
2017 {
2018 pDC->FillSolidRect(rc, crBkgnd);
2019 DrawBlockLine(pDC, rc, nLineIndex);
2020 DrawLineEnding(pDC, rc, nLineIndex, origin);
2021 return;
2022 }
2023
2024 CheckOtherView();
2025
2026 // Draw the line
2027
2028 pDC->SelectObject(GetFont(FALSE, FALSE));
2029
2030 DrawTextLine(pDC, rc, nLineIndex, origin);
2031
2032 // draw white space after the end of line
2033 CRect frect = rc;
2034 if (origin.x > frect.left)
2035 frect.left = origin.x;
2036 if (frect.right > frect.left)
2037 pDC->FillSolidRect(frect, crBkgnd);
2038
2039 // draw the whitespace chars
2040 LPCTSTR pszChars = (LPCWSTR)sLine;
2041 if (m_bViewWhitespace)
2042 {
2043 int xpos = 0;
2044 int nChars = 0;
2045 LPCTSTR pLastSpace = pszChars;
2046 int y = rc.top + (rc.bottom-rc.top)/2;
2047 xpos -= m_nOffsetChar * GetCharWidth();
2048
2049 CDpiScale dpi(pDC->GetSafeHdc());
2050 CPen pen(PS_SOLID, 0, m_WhiteSpaceFg);
2051 while (*pszChars)
2052 {
2053 switch (*pszChars)
2054 {
2055 case '\t':
2056 {
2057 xpos += pDC->GetTextExtent(pLastSpace, (int)(pszChars - pLastSpace)).cx;
2058 pLastSpace = pszChars + 1;
2059 // draw an arrow
2060 int nSpaces = GetTabSize() - nChars % GetTabSize();
2061 if (xpos + nSpaces * GetCharWidth() > 0)
2062 {
2063 int xposreal = max(xpos, 0);
2064 if ((xposreal > 0) || (nSpaces > 0))
2065 {
2066 CPen * oldPen = pDC->SelectObject(&pen);
2067 pDC->MoveTo(xposreal + rc.left + dpi.ScaleX(2), y);
2068 pDC->LineTo((xpos + nSpaces * GetCharWidth()) + rc.left - dpi.ScaleX(2), y);
2069 pDC->LineTo((xpos + nSpaces * GetCharWidth()) + rc.left - dpi.ScaleX(6), y - dpi.ScaleY(4));
2070 pDC->MoveTo((xpos + nSpaces * GetCharWidth()) + rc.left - dpi.ScaleX(2), y);
2071 pDC->LineTo((xpos + nSpaces * GetCharWidth()) + rc.left - dpi.ScaleX(6), y + dpi.ScaleY(4));
2072 pDC->SelectObject(oldPen);
2073 }
2074 }
2075 xpos += nSpaces * GetCharWidth();
2076 nChars += nSpaces;
2077 }
2078 break;
2079 case ' ':
2080 {
2081 xpos += pDC->GetTextExtent(pLastSpace, (int)(pszChars - pLastSpace)).cx;
2082 pLastSpace = pszChars + 1;
2083 if (xpos >= 0)
2084 {
2085 const int cxWhitespace = dpi.ScaleX(2);
2086 const int cyWhitespace = dpi.ScaleY(2);
2087 // draw 2-logical pixel rectangle, like Scintilla editor.
2088 pDC->FillSolidRect(xpos + rc.left + GetCharWidth() / 2 - cxWhitespace/2, y, cxWhitespace, cyWhitespace, m_WhiteSpaceFg);
2089 }
2090 xpos += GetCharWidth();
2091 nChars++;
2092 }
2093 break;
2094 default:
2095 nChars++;
2096 break;
2097 }
2098 pszChars++;
2099 }
2100 }
2101 DrawBlockLine(pDC, rc, nLineIndex);
2102 if (origin.x >= rc.left)
2103 DrawLineEnding(pDC, rc, nLineIndex, origin);
2104 }
2105
2106 void CBaseView::ExpandChars(const CString &sLine, int nOffset, int nCount, CString &line)
2107 {
2108 if (nCount <= 0)
2109 {
2110 line.Empty();
2111 return;
2112 }
2113
2114 int nTabSize = GetTabSize();
2115
2116 int nActualOffset = CountExpandedChars(sLine, nOffset);
2117
2118 LPCTSTR pszChars = (LPCWSTR)sLine;
2119 pszChars += nOffset;
2120 int nLength = nCount;
2121
2122 int nTabCount = 0;
2123 for (int i=0; i<nLength; i++)
2124 {
2125 if (pszChars[i] == L'\t')
2126 nTabCount ++;
2127 }
2128
2129 LPTSTR pszBuf = line.GetBuffer(nLength + nTabCount * (nTabSize - 1) + 1);
2130 int nCurPos = 0;
2131 if (nTabCount > 0 || m_bViewWhitespace)
2132 {
2133 for (int i=0; i<nLength; i++)
2134 {
2135 if (pszChars[i] == L'\t')
2136 {
2137 int nSpaces = nTabSize - (nActualOffset + nCurPos) % nTabSize;
2138 while (nSpaces > 0)
2139 {
2140 pszBuf[nCurPos ++] = L' ';
2141 nSpaces --;
2142 }
2143 }
2144 else
2145 {
2146 pszBuf[nCurPos] = pszChars[i];
2147 nCurPos ++;
2148 }
2149 }
2150 }
2151 else
2152 {
2153 memcpy(pszBuf, pszChars, sizeof(TCHAR) * nLength);
2154 nCurPos = nLength;
2155 }
2156 pszBuf[nCurPos] = 0;
2157 line.ReleaseBuffer();
2158 }
2159
2160 CString CBaseView::ExpandChars(const CString &sLine, int nOffset)
2161 {
2162 CString sRet;
2163 int nLength = sLine.GetLength();
2164 ExpandChars(sLine, nOffset, nLength, sRet);
2165 return sRet;
2166 }
2167
2168 int CBaseView::CountExpandedChars(const CString &sLine, int nLength)
2169 {
2170 int nTabSize = GetTabSize();
2171
2172 int nActualOffset = 0;
2173 for (int i=0; i<nLength; i++)
2174 {
2175 if (sLine[i] == L'\t')
2176 nActualOffset += (nTabSize - nActualOffset % nTabSize);
2177 else
2178 nActualOffset ++;
2179 }
2180 return nActualOffset;
2181 }
2182
2183 void CBaseView::ScrollAllToLine(int nNewTopLine, BOOL bTrackScrollBar)
2184 {
2185 if (m_pwndLeft)
2186 m_pwndLeft->ScrollToLine(nNewTopLine, bTrackScrollBar);
2187 if (m_pwndRight)
2188 m_pwndRight->ScrollToLine(nNewTopLine, bTrackScrollBar);
2189 if (m_pwndBottom)
2190 m_pwndBottom->ScrollToLine(nNewTopLine, bTrackScrollBar);
2191 if (m_pwndLocator)
2192 m_pwndLocator->Invalidate();
2193 }
2194
2195 void CBaseView::GoToLine(int nNewLine, BOOL bAll)
2196 {
2197 //almost the same as ScrollAllToLine, but try to put the line in the
2198 //middle of the view, not on top
2199 int nNewTopLine = nNewLine - GetScreenLines()/2;
2200 if (nNewTopLine < 0)
2201 nNewTopLine = 0;
2202 if (nNewTopLine >= (int)m_Screen2View.size())
2203 nNewTopLine = (int)m_Screen2View.size()-1;
2204 if (bAll)
2205 ScrollAllToLine(nNewTopLine);
2206 else
2207 ScrollToLine(nNewTopLine);
2208 }
2209
2210 BOOL CBaseView::OnEraseBkgnd(CDC* /*pDC*/)
2211 {
2212 return TRUE;
2213 }
2214
2215 int CBaseView::OnCreate(LPCREATESTRUCT lpCreateStruct)
2216 {
2217 if (CView::OnCreate(lpCreateStruct) == -1)
2218 return -1;
2219
2220 SecureZeroMemory(&m_lfBaseFont, sizeof(m_lfBaseFont));
2221 //lstrcpy(m_lfBaseFont.lfFaceName, L"Courier New");
2222 //lstrcpy(m_lfBaseFont.lfFaceName, L"FixedSys");
2223 m_lfBaseFont.lfHeight = 0;
2224 m_lfBaseFont.lfWeight = FW_NORMAL;
2225 m_lfBaseFont.lfItalic = FALSE;
2226 m_lfBaseFont.lfCharSet = DEFAULT_CHARSET;
2227 m_lfBaseFont.lfOutPrecision = OUT_DEFAULT_PRECIS;
2228 m_lfBaseFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
2229 m_lfBaseFont.lfQuality = DEFAULT_QUALITY;
2230 m_lfBaseFont.lfPitchAndFamily = DEFAULT_PITCH;
2231
2232 return 0;
2233 }
2234
2235 void CBaseView::OnDestroy()
2236 {
2237 if ((m_pFindDialog)&&(!m_pFindDialog->IsTerminating()))
2238 {
2239 m_pFindDialog->SendMessage(WM_CLOSE);
2240 return;
2241 }
2242 CView::OnDestroy();
2243 DeleteFonts();
2244 ReleaseBitmap();
2245 }
2246
2247 void CBaseView::OnSize(UINT nType, int cx, int cy)
2248 {
2249 CView::OnSize(nType, cx, cy);
2250 ReleaseBitmap();
2251
2252 m_nScreenLines = -1;
2253 m_nScreenChars = -1;
2254 if (m_nLastScreenChars != GetScreenChars())
2255 {
2256 BuildAllScreen2ViewVector();
2257 m_nLastScreenChars = m_nScreenChars;
2258 if (m_pMainFrame && m_pMainFrame->m_bWrapLines)
2259 {
2260 // if we're in wrap mode, the line wrapping most likely changed
2261 // and that means we have to redraw the whole window, not just the
2262 // scrolled part.
2263 Invalidate(FALSE);
2264 }
2265 else
2266 {
2267 // make sure the view header is redrawn
2268 CRect rcScroll;
2269 GetClientRect(&rcScroll);
2270 rcScroll.bottom = GetLineHeight()+HEADERHEIGHT;
2271 InvalidateRect(&rcScroll, FALSE);
2272 }
2273 }
2274 else
2275 {
2276 // make sure the view header is redrawn
2277 CRect rcScroll;
2278 GetClientRect(&rcScroll);
2279 rcScroll.bottom = GetLineHeight()+HEADERHEIGHT;
2280 InvalidateRect(&rcScroll, FALSE);
2281
2282 UpdateLocator();
2283 RecalcVertScrollBar();
2284 RecalcHorzScrollBar();
2285 }
2286 UpdateCaret();
2287 }
2288
2289 BOOL CBaseView::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt)
2290 {
2291 if (m_pwndLeft)
2292 m_pwndLeft->OnDoMouseWheel(nFlags, zDelta, pt);
2293 if (m_pwndRight)
2294 m_pwndRight->OnDoMouseWheel(nFlags, zDelta, pt);
2295 if (m_pwndBottom)
2296 m_pwndBottom->OnDoMouseWheel(nFlags, zDelta, pt);
2297 if (m_pwndLocator)
2298 m_pwndLocator->Invalidate();
2299 return CView::OnMouseWheel(nFlags, zDelta, pt);
2300 }
2301
2302 void CBaseView::OnMouseHWheel(UINT nFlags, short zDelta, CPoint pt)
2303 {
2304 if (m_pwndLeft)
2305 m_pwndLeft->OnDoMouseHWheel(nFlags, zDelta, pt);
2306 if (m_pwndRight)
2307 m_pwndRight->OnDoMouseHWheel(nFlags, zDelta, pt);
2308 if (m_pwndBottom)
2309 m_pwndBottom->OnDoMouseHWheel(nFlags, zDelta, pt);
2310 if (m_pwndLocator)
2311 m_pwndLocator->Invalidate();
2312 }
2313
2314 void CBaseView::OnDoMouseWheel(UINT /*nFlags*/, short zDelta, CPoint /*pt*/)
2315 {
2316 bool bControl = !!(GetKeyState(VK_CONTROL)&0x8000);
2317 bool bShift = !!(GetKeyState(VK_SHIFT)&0x8000);
2318
2319 if (bControl || bShift)
2320 {
2321 if (m_pMainFrame->m_bWrapLines)
2322 return;
2323 // Ctrl-Wheel scrolls sideways
2324 ScrollSide(-zDelta/30);
2325 }
2326 else
2327 {
2328 ScrollVertical(zDelta);
2329 }
2330 }
2331
2332 void CBaseView::OnDoMouseHWheel(UINT /*nFlags*/, short zDelta, CPoint /*pt*/)
2333 {
2334 bool bControl = !!(GetKeyState(VK_CONTROL)&0x8000);
2335 bool bShift = !!(GetKeyState(VK_SHIFT)&0x8000);
2336
2337 if (bControl || bShift)
2338 {
2339 // Ctrl-H-Wheel scrolls vertical
2340 ScrollVertical(zDelta);
2341 }
2342 else
2343 {
2344 if (m_pMainFrame->m_bWrapLines)
2345 return;
2346 // Ctrl-Wheel scrolls sideways
2347 ScrollSide(zDelta/30);
2348 }
2349 }
2350
2351 BOOL CBaseView::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
2352 {
2353 if (nHitTest == HTCLIENT)
2354 {
2355 if ((m_pViewData)&&(m_pMainFrame->m_bCollapsed))
2356 {
2357 if (m_nMouseLine < (int)m_Screen2View.size())
2358 {
2359 if (m_nMouseLine >= 0)
2360 {
2361 int viewLine = GetViewLineForScreen(m_nMouseLine);
2362 if (viewLine < m_pViewData->GetCount())
2363 {
2364 if (m_pViewData->GetHideState(viewLine) == HIDESTATE_MARKER)
2365 {
2366 ::SetCursor(::LoadCursor(nullptr, IDC_HAND));
2367 return TRUE;
2368 }
2369 }
2370 }
2371 }
2372 }
2373 if (m_mouseInMargin)
2374 {
2375 ::SetCursor(m_margincursor);
2376 return TRUE;
2377 }
2378 if (m_nMouseLine >= 0)
2379 {
2380 ::SetCursor(::LoadCursor(nullptr, IDC_IBEAM)); // Set To Edit Cursor
2381 return TRUE;
2382 }
2383
2384 ::SetCursor(::LoadCursor(nullptr, IDC_ARROW)); // Set To Arrow Cursor
2385 return TRUE;
2386 }
2387 return CView::OnSetCursor(pWnd, nHitTest, message);
2388 }
2389
2390 void CBaseView::OnKillFocus(CWnd* pNewWnd)
2391 {
2392 CView::OnKillFocus(pNewWnd);
2393 m_bFocused = FALSE;
2394 UpdateCaret();
2395 Invalidate();
2396 }
2397
2398 void CBaseView::OnSetFocus(CWnd* pOldWnd)
2399 {
2400 CView::OnSetFocus(pOldWnd);
2401 m_bFocused = TRUE;
2402 UpdateCaret();
2403 Invalidate();
2404 }
2405
2406 int CBaseView::GetLineFromPoint(CPoint point)
2407 {
2408 ScreenToClient(&point);
2409 return (((point.y - HEADERHEIGHT) / GetLineHeight()) + m_nTopLine);
2410 }
2411
2412 void CBaseView::OnContextMenu(CPoint point, DiffStates state)
2413 {
2414 CRect rcClient;
2415 GetClientRect(rcClient);
2416 CRect textrect(rcClient.left, rcClient.top, rcClient.Width(), m_nLineHeight + HEADERHEIGHT);
2417
2418 CRect borderrect(rcClient.left, rcClient.top + m_nLineHeight + HEADERHEIGHT, 0, rcClient.bottom);
2419
2420 CPoint ptLocal = point;
2421 ScreenToClient(&ptLocal);
2422
2423 if (textrect.PtInRect(ptLocal) || borderrect.PtInRect(ptLocal))
2424 {
2425 // inside the header part of the view (showing the filename)
2426 if (IsViewGood(m_pwndBottom))
2427 {
2428 CString temp;
2429 if (this == m_pwndLeft)
2430 {
2431 CIconMenu popup;
2432 if (!popup.CreatePopupMenu())
2433 return;
2434
2435 temp.LoadString(IDS_HEADER_DIFFLEFTTOBASE);
2436 popup.AppendMenu(MF_STRING | MF_ENABLED, 10, temp);
2437 int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY | TPM_RIGHTBUTTON, point.x, point.y, this);
2438 if (cmd == 10)
2439 m_pMainFrame->DiffLeftToBase();
2440 }
2441 if (this == m_pwndRight)
2442 {
2443 CIconMenu popup;
2444 if (!popup.CreatePopupMenu())
2445 return;
2446
2447 temp.LoadString(IDS_HEADER_DIFFRIGHTTOBASE);
2448 popup.AppendMenu(MF_STRING | MF_ENABLED, 10, temp);
2449 int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY | TPM_RIGHTBUTTON, point.x, point.y, this);
2450 if (cmd == 10)
2451 m_pMainFrame->DiffRightToBase();
2452 }
2453 }
2454 return;
2455 }
2456
2457 if (!this->IsWindowVisible())
2458 return;
2459
2460 CIconMenu popup;
2461 if (!popup.CreatePopupMenu())
2462 return;
2463
2464 AddContextItems(popup, state);
2465
2466 CMenu popupEols;
2467 CMenu popupUnicode;
2468 int nEncodingCommandBase = POPUPCOMMAND__LAST;
2469 int nEolCommandBase = nEncodingCommandBase+_countof(uctArray);
2470 if (IsWritable())
2471 {
2472 CString temp;
2473 TWhitecharsProperties oWhites = GetWhitecharsProperties();
2474 temp.LoadString(IDS_EDIT_TAB2SPACE);
2475 popup.AppendMenu(MF_STRING | (oWhites.HasTabsToConvert ? MF_ENABLED : (MF_DISABLED|MF_GRAYED)), POPUPCOMMAND_TABTOSPACES, temp);
2476 temp.LoadString(IDS_EDIT_SPACE2TAB);
2477 popup.AppendMenu(MF_STRING | (oWhites.HasSpacesToConvert ? MF_ENABLED : (MF_DISABLED|MF_GRAYED)), POPUPCOMMAND_SPACESTOTABS, temp);
2478 temp.LoadString(IDS_EDIT_TRIM);
2479 popup.AppendMenu(MF_STRING | (oWhites.HasTrailWhiteChars ? MF_ENABLED : (MF_DISABLED|MF_GRAYED)), POPUPCOMMAND_REMOVETRAILWHITES, temp);
2480
2481 // add eol submenu
2482 if (!popupEols.CreatePopupMenu())
2483 return;
2484
2485 EOL eEolType = GetLineEndings(oWhites.HasMixedEols);
2486 for (int i = 1; i < _countof(eolArray); i++)
2487 {
2488 temp = GetEolName(eolArray[i]);
2489 bool bChecked = (eEolType == eolArray[i]);
2490 popupEols.AppendMenu(MF_STRING | MF_ENABLED | (bChecked ? MF_CHECKED : 0), nEolCommandBase+i, temp);
2491 }
2492
2493 temp.LoadString(IDS_VIEWCONTEXTMENU_EOL);
2494 popup.AppendMenuW(MF_POPUP | MF_ENABLED, (UINT_PTR)popupEols.GetSafeHmenu(), temp);
2495
2496 // add encoding submenu
2497 if (!popupUnicode.CreatePopupMenu())
2498 return;
2499 for (int i = 0; i < _countof(uctArray); i++)
2500 {
2501 temp = CFileTextLines::GetEncodingName(uctArray[i]);
2502 bool bChecked = (m_texttype == uctArray[i]);
2503 popupUnicode.AppendMenu(MF_STRING | MF_ENABLED | (bChecked ? MF_CHECKED : 0), nEncodingCommandBase+i, temp);
2504 }
2505 temp.LoadString(IDS_VIEWCONTEXTMENU_ENCODING);
2506 popup.AppendMenuW(MF_POPUP | MF_ENABLED, (UINT_PTR)popupUnicode.GetSafeHmenu(), temp);
2507
2508 }
2509
2510 CompensateForKeyboard(point);
2511
2512 int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY | TPM_RIGHTBUTTON, point.x, point.y, this);
2513 ResetUndoStep();
2514 if ((cmd>=nEncodingCommandBase) && (cmd<nEncodingCommandBase+(int)_countof(uctArray)))
2515 {
2516 SetTextType(uctArray[cmd-nEncodingCommandBase]);
2517 }
2518 if ((cmd>=nEolCommandBase) && (cmd<nEolCommandBase+(int)_countof(eolArray)))
2519 {
2520 ReplaceLineEndings(eolArray[cmd-nEolCommandBase]);
2521 SaveUndoStep();
2522 }
2523 switch (cmd)
2524 {
2525 // 2-pane view commands; target is right view
2526 case POPUPCOMMAND_USELEFTBLOCK:
2527 m_pwndRight->UseLeftBlock();
2528 break;
2529 case POPUPCOMMAND_USELEFTFILE:
2530 m_pwndRight->UseLeftFile();
2531 break;
2532 case POPUPCOMMAND_USEBOTHLEFTFIRST:
2533 m_pwndRight->UseBothLeftFirst();
2534 break;
2535 case POPUPCOMMAND_USEBOTHRIGHTFIRST:
2536 m_pwndRight->UseBothRightFirst();
2537 break;
2538 case POPUPCOMMAND_MARKBLOCK:
2539 m_pwndRight->MarkBlock(true);
2540 break;
2541 case POPUPCOMMAND_UNMARKBLOCK:
2542 m_pwndRight->MarkBlock(false);
2543 break;
2544 case POPUPCOMMAND_LEAVEONLYMARKEDBLOCKS:
2545 m_pwndRight->LeaveOnlyMarkedBlocks();
2546 break;
2547 // 2-pane view multiedit commands; target is left view
2548 case POPUPCOMMAND_PREPENDFROMRIGHT:
2549 if (!m_pwndLeft->IsReadonly())
2550 m_pwndLeft->UseBothRightFirst();
2551 break;
2552 case POPUPCOMMAND_REPLACEBYRIGHT:
2553 if (!m_pwndLeft->IsReadonly())
2554 m_pwndLeft->UseRightBlock();
2555 break;
2556 case POPUPCOMMAND_APPENDFROMRIGHT:
2557 if (!m_pwndLeft->IsReadonly())
2558 m_pwndLeft->UseBothLeftFirst();
2559 break;
2560 case POPUPCOMMAND_USERIGHTFILE:
2561 m_pwndLeft->UseRightFile();
2562 break;
2563 // 3-pane view commands; target is bottom view
2564 case POPUPCOMMAND_USEYOURANDTHEIRBLOCK:
2565 m_pwndBottom->UseBothRightFirst();
2566 break;
2567 case POPUPCOMMAND_USETHEIRANDYOURBLOCK:
2568 m_pwndBottom->UseBothLeftFirst();
2569 break;
2570 case POPUPCOMMAND_USEYOURBLOCK:
2571 m_pwndBottom->UseRightBlock();
2572 break;
2573 case POPUPCOMMAND_USEYOURFILE:
2574 m_pwndBottom->UseRightFile();
2575 break;
2576 case POPUPCOMMAND_USETHEIRBLOCK:
2577 m_pwndBottom->UseLeftBlock();
2578 break;
2579 case POPUPCOMMAND_USETHEIRFILE:
2580 m_pwndBottom->UseLeftFile();
2581 break;
2582 // copy, cut and paste commands
2583 case ID_EDIT_COPY:
2584 OnEditCopy();
2585 break;
2586 case ID_EDIT_CUT:
2587 OnEditCut();
2588 break;
2589 case ID_EDIT_PASTE:
2590 OnEditPaste();
2591 break;
2592 // white chars manipulations
2593 case POPUPCOMMAND_TABTOSPACES:
2594 ConvertTabToSpaces();
2595 break;
2596 case POPUPCOMMAND_SPACESTOTABS:
2597 Tabularize();
2598 break;
2599 case POPUPCOMMAND_REMOVETRAILWHITES:
2600 RemoveTrailWhiteChars();
2601 break;
2602 default:
2603 return;
2604 } // switch (cmd)
2605 SaveUndoStep(); // all except copy, cut paste save undo step, but this should not be harmful as step is empty already and thus not saved
2606 return;
2607 }
2608
2609 void CBaseView::OnContextMenu(CWnd* /*pWnd*/, CPoint point)
2610 {
2611 if (!m_pViewData)
2612 return;
2613
2614 int nViewBlockStart = -1;
2615 int nViewBlockEnd = -1;
2616 GetViewSelection(nViewBlockStart, nViewBlockEnd);
2617 if ((point.x >= 0) && (point.y >= 0))
2618 {
2619 int nLine = GetLineFromPoint(point)-1;
2620 if ((nLine >= 0) && (nLine < m_Screen2View.size()))
2621 {
2622 int nViewLine = GetViewLineForScreen(nLine);
2623 if (((nViewLine < nViewBlockStart) || (nViewBlockEnd < nViewLine)))
2624 {
2625 ClearSelection(); // Clear text-copy selection
2626
2627 nViewBlockStart = nViewLine;
2628 nViewBlockEnd = nViewLine;
2629 DiffStates state = m_pViewData->GetState(nViewLine);
2630 while (nViewBlockStart > 0)
2631 {
2632 const DiffStates lineState = m_pViewData->GetState(nViewBlockStart-1);
2633 if (!LinesInOneChange(-1, state, lineState))
2634 break;
2635 nViewBlockStart--;
2636 }
2637
2638 while (nViewBlockEnd < (m_pViewData->GetCount()-1))
2639 {
2640 const DiffStates lineState = m_pViewData->GetState(nViewBlockEnd+1);
2641 if (!LinesInOneChange(1, state, lineState))
2642 break;
2643 nViewBlockEnd++;
2644 }
2645
2646 SetupAllViewSelection(nViewBlockStart, nViewBlockEnd);
2647 UpdateCaretPosition(SetupPoint(0, nViewLine));
2648 }
2649 }
2650 }
2651
2652 // FixSelection(); fix selection range
2653 /*if (m_nSelBlockEnd >= m_pViewData->GetCount())
2654 m_nSelBlockEnd = m_pViewData->GetCount()-1;//*/
2655
2656 DiffStates state = DIFFSTATE_UNKNOWN;
2657 if (GetViewSelection(nViewBlockStart, nViewBlockEnd))
2658 {
2659 // find a more 'relevant' state in the selection
2660 for (int i=nViewBlockStart; i<=nViewBlockEnd; ++i)
2661 {
2662 state = m_pViewData->GetState(i);
2663 if ((state != DIFFSTATE_NORMAL) && (state != DIFFSTATE_UNKNOWN))
2664 break;
2665 }
2666 }
2667 OnContextMenu(point, state);
2668 }
2669
2670 void CBaseView::RefreshViews()
2671 {
2672 if (m_pwndLeft)
2673 {
2674 m_pwndLeft->UpdateStatusBar();
2675 m_pwndLeft->Invalidate();
2676 }
2677 if (m_pwndRight)
2678 {
2679 m_pwndRight->UpdateStatusBar();
2680 m_pwndRight->Invalidate();
2681 }
2682 if (m_pwndBottom)
2683 {
2684 m_pwndBottom->UpdateStatusBar();
2685 m_pwndBottom->Invalidate();
2686 }
2687 if (m_pwndLocator)
2688 m_pwndLocator->Invalidate();
2689 }
2690
2691 void CBaseView::GoToFirstDifference()
2692 {
2693 SetCaretToFirstViewLine();
2694 SelectNextBlock(1, false, false);
2695 }
2696
2697 void CBaseView::GoToFirstConflict()
2698 {
2699 SetCaretToFirstViewLine();
2700 SelectNextBlock(1, true, false);
2701 }
2702
2703 void CBaseView::HighlightLines(int nStart, int nEnd /* = -1 */)
2704 {
2705 ClearSelection();
2706 SetupAllSelection(nStart, max(nStart, nEnd));
2707
2708 UpdateCaretPosition(SetupPoint(0, nStart));
2709 Invalidate();
2710 }
2711
2712 void CBaseView::HighlightViewLines(int nStart, int nEnd /* = -1 */)
2713 {
2714 ClearSelection();
2715 SetupAllViewSelection(nStart, max(nStart, nEnd));
2716
2717 UpdateCaretViewPosition(SetupPoint(0, nStart));
2718 Invalidate();
2719 }
2720
2721 void CBaseView::SetupAllViewSelection(int start, int end)
2722 {
2723 SetupViewSelection(m_pwndBottom, start, end);
2724 SetupViewSelection(m_pwndLeft, start, end);
2725 SetupViewSelection(m_pwndRight, start, end);
2726 }
2727
2728 void CBaseView::SetupAllSelection(int start, int end)
2729 {
2730 SetupAllViewSelection(GetViewLineForScreen(start), GetViewLineForScreen(end));
2731 }
2732
2733 //void CBaseView::SetupSelection(CBaseView* view, int start, int end) { }
2734
2735 void CBaseView::SetupSelection(int start, int end)
2736 {
2737 SetupViewSelection(GetViewLineForScreen(start), GetViewLineForScreen(end));
2738 }
2739
2740 void CBaseView::SetupViewSelection(CBaseView* view, int start, int end)
2741 {
2742 if (!IsViewGood(view))
2743 return;
2744 view->SetupViewSelection(start, end);
2745 }
2746
2747 void CBaseView::SetupViewSelection(int start, int end)
2748 {
2749 // clear text selection before setting line selection ?
2750 m_nSelViewBlockStart = start;
2751 m_nSelViewBlockEnd = end;
2752 Invalidate();
2753 }
2754
2755
2756 void CBaseView::OnMergePreviousconflict()
2757 {
2758 SelectNextBlock(-1, true);
2759 }
2760
2761 void CBaseView::OnMergeNextconflict()
2762 {
2763 SelectNextBlock(1, true);
2764 }
2765
2766 void CBaseView::OnMergeNextdifference()
2767 {
2768 SelectNextBlock(1, false);
2769 }
2770
2771 void CBaseView::OnMergePreviousdifference()
2772 {
2773 SelectNextBlock(-1, false);
2774 }
2775
2776 bool CBaseView::HasNextConflict()
2777 {
2778 return SelectNextBlock(1, true, true, true);
2779 }
2780
2781 bool CBaseView::HasPrevConflict()
2782 {
2783 return SelectNextBlock(-1, true, true, true);
2784 }
2785
2786 bool CBaseView::HasNextDiff()
2787 {
2788 return SelectNextBlock(1, false, true, true);
2789 }
2790
2791 bool CBaseView::HasPrevDiff()
2792 {
2793 return SelectNextBlock(-1, false, true, true);
2794 }
2795
2796 bool CBaseView::LinesInOneChange(int direction,
2797 DiffStates initialLineState, DiffStates currentLineState)
2798 {
2799 // Checks whether all the adjacent lines starting from the initial line
2800 // and up to the current line form the single change
2801
2802 // First of all, if the two lines have identical states, they surely
2803 // belong to one change.
2804 if (initialLineState == currentLineState)
2805 return true;
2806
2807 // Either we move down and initial line state is "added" or "removed" and
2808 // current line state is "empty"...
2809 if (direction > 0)
2810 {
2811 if (currentLineState == DIFFSTATE_EMPTY)
2812 {
2813 if (initialLineState == DIFFSTATE_ADDED || initialLineState == DIFFSTATE_REMOVED)
2814 return true;
2815 }
2816 if (initialLineState == DIFFSTATE_CONFLICTADDED && currentLineState == DIFFSTATE_CONFLICTEMPTY)
2817 return true;
2818 }
2819 // ...or we move up and initial line state is "empty" and current line
2820 // state is "added" or "removed".
2821 if (direction < 0)
2822 {
2823 if (initialLineState == DIFFSTATE_EMPTY)
2824 {
2825 if (currentLineState == DIFFSTATE_ADDED || currentLineState == DIFFSTATE_REMOVED)
2826 return true;
2827 }
2828 if (initialLineState == DIFFSTATE_CONFLICTEMPTY && currentLineState == DIFFSTATE_CONFLICTADDED)
2829 return true;
2830 }
2831 return false;
2832 }
2833
2834 bool CBaseView::SelectNextBlock(int nDirection, bool bConflict, bool bSkipEndOfCurrentBlock /* = true */, bool dryrun /* = false */)
2835 {
2836 if (! m_pViewData)
2837 return false;
2838
2839 const int linesCount = (int)m_Screen2View.size();
2840 if(linesCount == 0)
2841 return false;
2842
2843 int nCenterPos = GetCaretPosition().y;
2844 int nLimit = -1;
2845 if (nDirection > 0)
2846 nLimit = linesCount;
2847
2848 if (nCenterPos >= linesCount)
2849 nCenterPos = linesCount-1;
2850
2851 if (bSkipEndOfCurrentBlock)
2852 {
2853 // Find end of current block
2854 const DiffStates state = m_pViewData->GetState(GetViewLineForScreen(nCenterPos));
2855 while (nCenterPos != nLimit)
2856 {
2857 const DiffStates lineState = m_pViewData->GetState(GetViewLineForScreen(nCenterPos));
2858 if (!LinesInOneChange(nDirection, state, lineState))
2859 break;
2860 nCenterPos += nDirection;
2861 }
2862 }
2863
2864 // Find next diff/conflict block
2865 while (nCenterPos != nLimit)
2866 {
2867 DiffStates linestate = m_pViewData->GetState(GetViewLineForScreen(nCenterPos));
2868 if (!bConflict &&
2869 (linestate != DIFFSTATE_NORMAL) &&
2870 (linestate != DIFFSTATE_UNKNOWN) &&
2871 (linestate != DIFFSTATE_FILTEREDDIFF))
2872 {
2873 break;
2874 }
2875 if (bConflict &&
2876 ((linestate == DIFFSTATE_CONFLICTADDED) ||
2877 (linestate == DIFFSTATE_CONFLICTED_IGNORED) ||
2878 (linestate == DIFFSTATE_CONFLICTED) ||
2879 (linestate == DIFFSTATE_CONFLICTEMPTY)))
2880 {
2881 break;
2882 }
2883
2884 nCenterPos += nDirection;
2885 }
2886 if (nCenterPos == nLimit)
2887 return false;
2888 if (dryrun)
2889 return (nCenterPos != nLimit);
2890
2891 // Find end of new block
2892 DiffStates state = m_pViewData->GetState(GetViewLineForScreen(nCenterPos));
2893 int nBlockEnd = nCenterPos;
2894 const int maxAllowedLine = nLimit-nDirection;
2895 while (nBlockEnd != maxAllowedLine)
2896 {
2897 const int lineIndex = nBlockEnd + nDirection;
2898 if (lineIndex >= linesCount)
2899 break;
2900 DiffStates lineState = m_pViewData->GetState(GetViewLineForScreen(lineIndex));
2901 if (!LinesInOneChange(nDirection, state, lineState))
2902 break;
2903 nBlockEnd += nDirection;
2904 }
2905
2906 int nTopPos = nCenterPos - (GetScreenLines()/2);
2907 if (nTopPos < 0)
2908 nTopPos = 0;
2909
2910 POINT ptCaretPos = {0, nCenterPos};
2911 SetCaretPosition(ptCaretPos);
2912 ClearSelection();
2913 if (nDirection > 0)
2914 SetupAllSelection(nCenterPos, nBlockEnd);
2915 else
2916 SetupAllSelection(nBlockEnd, nCenterPos);
2917
2918 ScrollAllToLine(nTopPos, FALSE);
2919 RecalcAllVertScrollBars(TRUE);
2920 SetCaretToLineStart();
2921 EnsureCaretVisible();
2922 OnNavigateNextinlinediff();
2923
2924 UpdateViewsCaretPosition();
2925 UpdateCaret();
2926 ShowDiffLines(nCenterPos);
2927 return true;
2928 }
2929
2930 BOOL CBaseView::OnToolTipNotify(UINT /*id*/, NMHDR *pNMHDR, LRESULT *pResult)
2931 {
2932 if (pNMHDR->idFrom != (UINT_PTR)m_hWnd)
2933 return FALSE;
2934
2935 CString strTipText;
2936 strTipText = m_sWindowName + L"\r\n" + m_sFullFilePath;
2937
2938 DWORD pos = GetMessagePos();
2939 CPoint point(GET_X_LPARAM(pos), GET_Y_LPARAM(pos));
2940 ScreenToClient(&point);
2941 const int nLine = GetButtonEventLineIndex(point);
2942
2943 if (nLine >= 0)
2944 {
2945 int nViewLine = GetViewLineForScreen(nLine);
2946 if((m_pViewData)&&(nViewLine < m_pViewData->GetCount()))
2947 {
2948 auto movedIndex = m_pViewData->GetMovedIndex(nViewLine);
2949 if (movedIndex >= 0)
2950 {
2951 if (m_pViewData->IsMovedFrom(nViewLine))
2952 {
2953 strTipText.Format(IDS_MOVED_TO_TT, movedIndex+1);
2954 }
2955 else
2956 {
2957 strTipText.Format(IDS_MOVED_FROM_TT, movedIndex+1);
2958 }
2959 }
2960 }
2961 }
2962
2963
2964 *pResult = 0;
2965 if (strTipText.IsEmpty())
2966 return TRUE;
2967
2968 // need to handle both ANSI and UNICODE versions of the message
2969 if (pNMHDR->code == TTN_NEEDTEXTA)
2970 {
2971 TOOLTIPTEXTA* pTTTA = (TOOLTIPTEXTA*)pNMHDR;
2972 pTTTA->lpszText = m_szTip;
2973 WideCharToMultiByte(CP_ACP, 0, strTipText, -1, m_szTip, strTipText.GetLength()+1, 0, 0);
2974 }
2975 else
2976 {
2977 TOOLTIPTEXTW* pTTTW = (TOOLTIPTEXTW*)pNMHDR;
2978 lstrcpyn(m_wszTip, strTipText, min(strTipText.GetLength() + 1, _countof(m_wszTip) - 1));
2979 pTTTW->lpszText = m_wszTip;
2980 }
2981
2982 return TRUE; // message was handled
2983 }
2984
2985 INT_PTR CBaseView::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
2986 {
2987 CRect rcClient;
2988 GetClientRect(rcClient);
2989 CRect textrect(rcClient.left, rcClient.top, rcClient.Width(), m_nLineHeight+HEADERHEIGHT);
2990
2991 int marginwidth = GetSystemMetrics(SM_CXSMICON) + 2 + 2;
2992 if ((m_bViewLinenumbers)&&(m_pViewData)&&(m_pViewData->GetCount())&&(m_nDigits > 0))
2993 {
2994 marginwidth += (m_nDigits * m_nCharWidth) + 2;
2995 }
2996 CRect borderrect(rcClient.left, rcClient.top+m_nLineHeight+HEADERHEIGHT, marginwidth, rcClient.bottom);
2997
2998 if (textrect.PtInRect(point) || borderrect.PtInRect(point))
2999 {
3000 // inside the header part of the view (showing the filename)
3001 pTI->hwnd = this->m_hWnd;
3002 this->GetClientRect(&pTI->rect);
3003 pTI->uFlags |= TTF_ALWAYSTIP | TTF_IDISHWND;
3004 pTI->uId = (UINT_PTR)m_hWnd;
3005 pTI->lpszText = LPSTR_TEXTCALLBACK;
3006
3007 // we want multi line tooltips
3008 CToolTipCtrl* pToolTip = AfxGetModuleThreadState()->m_pToolTip;
3009 if (pToolTip->GetSafeHwnd())
3010 pToolTip->SetMaxTipWidth(SHRT_MAX);
3011
3012 return (textrect.PtInRect(point) ? 1 : 2);
3013 }
3014
3015 return -1;
3016 }
3017
3018 void CBaseView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
3019 {
3020 bool bControl = !!(GetKeyState(VK_CONTROL)&0x8000);
3021 bool bShift = !!(GetKeyState(VK_SHIFT)&0x8000);
3022
3023 switch (nChar)
3024 {
3025 case VK_TAB:
3026 if (bControl)
3027 {
3028 if (this==m_pwndLeft)
3029 {
3030 if (IsViewGood(m_pwndRight))
3031 {
3032 m_pwndRight->SetFocus();
3033 }
3034 else if (IsViewGood(m_pwndBottom))
3035 {
3036 m_pwndBottom->SetFocus();
3037 }
3038 }
3039 else if (this==m_pwndRight)
3040 {
3041 if (IsViewGood(m_pwndBottom))
3042 {
3043 m_pwndBottom->SetFocus();
3044 }
3045 else if (IsViewGood(m_pwndLeft))
3046 {
3047 m_pwndLeft->SetFocus();
3048 }
3049 }
3050 else if (this==m_pwndBottom)
3051 {
3052 if (IsViewGood(m_pwndLeft))
3053 {
3054 m_pwndLeft->SetFocus();
3055 }
3056 else if (IsViewGood(m_pwndRight))
3057 {
3058 m_pwndRight->SetFocus();
3059 }
3060 }
3061 }
3062 break;
3063 case VK_PRIOR:
3064 {
3065 POINT ptCaretPos = GetCaretPosition();
3066 ptCaretPos.y -= GetScreenLines();
3067 ptCaretPos.y = max(ptCaretPos.y, 0);
3068 ptCaretPos.x = CalculateCharIndex(ptCaretPos.y, m_nCaretGoalPos);
3069 SetCaretPosition(ptCaretPos);
3070 OnCaretMove(MOVELEFT, bShift);
3071 ShowDiffLines(ptCaretPos.y);
3072 }
3073 break;
3074 case VK_NEXT:
3075 {
3076 POINT ptCaretPos = GetCaretPosition();
3077 ptCaretPos.y += GetScreenLines();
3078 if (ptCaretPos.y >= GetLineCount())
3079 ptCaretPos.y = GetLineCount()-1;
3080 ptCaretPos.x = CalculateCharIndex(ptCaretPos.y, m_nCaretGoalPos);
3081 SetCaretPosition(ptCaretPos);
3082 OnCaretMove(MOVERIGHT, bShift);
3083 ShowDiffLines(ptCaretPos.y);
3084 }
3085 break;
3086 case VK_HOME:
3087 {
3088 if (bControl)
3089 {
3090 ScrollAllToLine(0);
3091 ScrollAllToChar(0);
3092 SetCaretToViewStart();
3093 m_nCaretGoalPos = 0;
3094 if (bShift)
3095 AdjustSelection(MOVELEFT);
3096 else
3097 ClearSelection();
3098 UpdateCaret();
3099 }
3100 else
3101 {
3102 POINT ptCaretPos = GetCaretPosition();
3103 CString sLine = GetLineChars(ptCaretPos.y);
3104 int pos = 0;
3105 while (pos < sLine.GetLength())
3106 {
3107 if (sLine[pos] != ' ' && sLine[pos] != '\t')
3108 break;
3109 ++pos;
3110 }
3111 if (ptCaretPos.x == pos)
3112 {
3113 SetCaretToLineStart();
3114 m_nCaretGoalPos = 0;
3115 OnCaretMove(MOVERIGHT, bShift);
3116 ScrollAllToChar(0);
3117 }
3118 else
3119 {
3120 ptCaretPos.x = pos;
3121 SetCaretAndGoalPosition(ptCaretPos);
3122 OnCaretMove(MOVELEFT, bShift);
3123 }
3124 }
3125 }
3126 break;
3127 case VK_END:
3128 {
3129 if (bControl)
3130 {
3131 ScrollAllToLine(GetLineCount()-GetAllMinScreenLines());
3132 POINT ptCaretPos;
3133 ptCaretPos.y = GetLineCount()-1;
3134 ptCaretPos.x = GetLineLength(ptCaretPos.y);
3135 SetCaretAndGoalPosition(ptCaretPos);
3136 if (bShift)
3137 AdjustSelection(MOVERIGHT);
3138 else
3139 ClearSelection();
3140 }
3141 else
3142 {
3143 POINT ptCaretPos = GetCaretPosition();
3144 ptCaretPos.x = GetLineLength(ptCaretPos.y);
3145 if ((GetSubLineOffset(ptCaretPos.y) != -1) && (GetSubLineOffset(ptCaretPos.y) != CountMultiLines(GetViewLineForScreen(ptCaretPos.y))-1)) // not last screen line of view line
3146 {
3147 ptCaretPos.x--;
3148 }
3149 SetCaretAndGoalPosition(ptCaretPos);
3150 OnCaretMove(MOVERIGHT, bShift);
3151 }
3152 }
3153 break;
3154 case VK_BACK:
3155 if (IsWritable())
3156 {
3157 if (! HasTextSelection())
3158 {
3159 POINT ptCaretPos = GetCaretPosition();
3160 if (ptCaretPos.y == 0 && ptCaretPos.x == 0)
3161 break;
3162 m_ptSelectionViewPosEnd = GetCaretViewPosition();
3163 if (bControl)
3164 MoveCaretWordLeft();
3165 else
3166 {
3167 while (MoveCaretLeft() && IsViewLineEmpty(GetCaretViewPosition().y))
3168 {
3169 }
3170 }
3171 m_ptSelectionViewPosStart = GetCaretViewPosition();
3172 }
3173 RemoveSelectedText();
3174 }
3175 break;
3176 case VK_DELETE:
3177 if (IsWritable())
3178 {
3179 if (! HasTextSelection())
3180 {
3181 if (bControl)
3182 {
3183 m_ptSelectionViewPosStart = GetCaretViewPosition();
3184 MoveCaretWordRight();
3185 m_ptSelectionViewPosEnd = GetCaretViewPosition();
3186 }
3187 else
3188 {
3189 if (! MoveCaretRight())
3190 break;
3191 m_ptSelectionViewPosEnd = GetCaretViewPosition();
3192 MoveCaretLeft();
3193 m_ptSelectionViewPosStart = GetCaretViewPosition();
3194 }
3195 }
3196 RemoveSelectedText();
3197 }
3198 break;
3199 case VK_INSERT:
3200 m_bInsertMode = !m_bInsertMode;
3201 UpdateCaret();
3202 break;
3203 }
3204 CView::OnKeyDown(nChar, nRepCnt, nFlags);
3205 }
3206
3207 void CBaseView::OnLButtonDown(UINT nFlags, CPoint point)
3208 {
3209 const int nClickedLine = GetButtonEventLineIndex(point);
3210 if ((nClickedLine >= m_nTopLine)&&(nClickedLine < GetLineCount()))
3211 {
3212 POINT ptCaretPos;
3213 ptCaretPos.y = nClickedLine;
3214 int xpos2 = CalcColFromPoint(point.x, nClickedLine);
3215 ptCaretPos.x = CalculateCharIndex(ptCaretPos.y, xpos2);
3216 SetCaretAndGoalPosition(ptCaretPos);
3217
3218 if (nFlags & MK_SHIFT)
3219 AdjustSelection(MOVERIGHT);
3220 else
3221 {
3222 ClearSelection();
3223 SetupAllSelection(ptCaretPos.y, ptCaretPos.y);
3224 if (point.x < GetMarginWidth())
3225 {
3226 // select the whole line
3227 m_ptSelectionViewPosStart = m_ptSelectionViewPosEnd = GetCaretViewPosition();
3228 m_ptSelectionViewPosStart.x = 0;
3229 m_ptSelectionViewPosEnd.x = GetViewLineLength(m_ptSelectionViewPosEnd.y);
3230 }
3231 }
3232
3233 UpdateViewsCaretPosition();
3234 Invalidate();
3235 }
3236
3237 CView::OnLButtonDown(nFlags, point);
3238 }
3239
3240 CBaseView::ECharGroup CBaseView::GetCharGroup(wchar_t zChar) const
3241 {
3242 if (zChar == ' ' || zChar == '\t' )
3243 {
3244 return CHG_WHITESPACE;
3245 }
3246 if (zChar < 0x20)
3247 {
3248 return CHG_CONTROL;
3249 }
3250 if (m_sWordSeparators.Find(zChar) >= 0)
3251 {
3252 return CHG_WORDSEPARATOR;
3253 }
3254 return CHG_WORDLETTER;
3255 }
3256
3257 void CBaseView::OnLButtonDblClk(UINT nFlags, CPoint point)
3258 {
3259 if (m_pViewData == 0) {
3260 CView::OnLButtonDblClk(nFlags, point);
3261 return;
3262 }
3263
3264 const int nClickedLine = GetButtonEventLineIndex(point);
3265 if ( nClickedLine < 0)
3266 return;
3267 int nViewLine = GetViewLineForScreen(nClickedLine);
3268 if (point.x < GetMarginWidth()) // only if double clicked on the margin
3269 {
3270 if((nViewLine < m_pViewData->GetCount())) // a double click on moved line scrolls to corresponding line
3271 {
3272 if (m_pViewData->GetMovedIndex(nViewLine)>=0)
3273 {
3274 int movedindex = m_pViewData->GetMovedIndex(nViewLine);
3275 int screenLine = FindViewLineNumber(movedindex);
3276 int nTop = screenLine - GetScreenLines()/2;
3277 if (nTop < 0)
3278 nTop = 0;
3279 ScrollAllToLine(nTop);
3280 // find and select the whole moved block
3281 int startSel = movedindex;
3282 int endSel = movedindex;
3283 while ((startSel > 0) && (m_pOtherViewData->GetMovedIndex(startSel) >= 0))
3284 startSel--;
3285 startSel++;
3286 while ((endSel < GetLineCount()) && (m_pOtherViewData->GetMovedIndex(endSel) >= 0))
3287 endSel++;
3288 endSel--;
3289 m_pOtherView->SetupSelection(startSel, endSel);
3290 return CView::OnLButtonDblClk(nFlags, point);
3291 }
3292 }
3293 }
3294 if ((m_pMainFrame->m_bCollapsed)&&(m_pViewData->GetHideState(nViewLine) == HIDESTATE_MARKER))
3295 {
3296 // a double click on a marker expands the hidden text
3297 int i = nViewLine;
3298 while ((i < m_pViewData->GetCount())&&(m_pViewData->GetHideState(i) != HIDESTATE_SHOWN))
3299 {
3300 if ((m_pwndLeft)&&(m_pwndLeft->m_pViewData))
3301 m_pwndLeft->m_pViewData->SetLineHideState(i, HIDESTATE_SHOWN);
3302 if ((m_pwndRight)&&(m_pwndRight->m_pViewData))
3303 m_pwndRight->m_pViewData->SetLineHideState(i, HIDESTATE_SHOWN);
3304 if ((m_pwndBottom)&&(m_pwndBottom->m_pViewData))
3305 m_pwndBottom->m_pViewData->SetLineHideState(i, HIDESTATE_SHOWN);
3306 i++;
3307 }
3308 BuildAllScreen2ViewVector();
3309 if (m_pwndLeft)
3310 m_pwndLeft->Invalidate();
3311 if (m_pwndRight)
3312 m_pwndRight->Invalidate();
3313 if (m_pwndBottom)
3314 m_pwndBottom->Invalidate();
3315 }
3316 else
3317 {
3318 POINT ptCaretPos;
3319 ptCaretPos.y = nClickedLine;
3320 ptCaretPos.x = CalculateCharIndex(ptCaretPos.y, m_nOffsetChar + (point.x - GetMarginWidth()) / GetCharWidth());
3321 SetCaretPosition(ptCaretPos);
3322 ClearSelection();
3323
3324 POINT ptViewCarret = GetCaretViewPosition();
3325 nViewLine = ptViewCarret.y;
3326 if (nViewLine >= GetViewCount())
3327 return;
3328 const CString &sLine = GetViewLine(nViewLine);
3329 int nLineLength = sLine.GetLength();
3330 int nBasePos = ptViewCarret.x;
3331 // get target char group
3332 ECharGroup eLeft = CHG_UNKNOWN;
3333 if (nBasePos > 0)
3334 {
3335 eLeft = GetCharGroup(sLine[nBasePos-1]);
3336 }
3337 ECharGroup eRight = CHG_UNKNOWN;
3338 if (nBasePos < nLineLength)
3339 {
3340 eRight = GetCharGroup(sLine[nBasePos]);
3341 }
3342 ECharGroup eTarget = max(eRight, eLeft);
3343 // find left margin
3344 int nLeft = nBasePos;
3345 while (nLeft > 0 && GetCharGroup(sLine[nLeft-1]) == eTarget)
3346 {
3347 nLeft--;
3348 }
3349 // get right margin
3350 int nRight = nBasePos;
3351 while (nRight < nLineLength && GetCharGroup(sLine[nRight]) == eTarget)
3352 {
3353 nRight++;
3354 }
3355 // set selection
3356 m_ptSelectionViewPosStart.x = nLeft;
3357 m_ptSelectionViewPosStart.y = nViewLine;
3358 m_ptSelectionViewPosEnd.x = nRight;
3359 m_ptSelectionViewPosEnd.y = nViewLine;
3360 m_ptSelectionViewPosOrigin = m_ptSelectionViewPosStart;
3361 SetupAllViewSelection(nViewLine, nViewLine);
3362 // set caret
3363 ptCaretPos = ConvertViewPosToScreen(m_ptSelectionViewPosEnd);
3364 UpdateViewsCaretPosition();
3365 UpdateGoalPos();
3366
3367 // set mark word
3368 m_sPreviousMarkedWord = m_sMarkedWord; // store marked word to recall in case of triple click
3369 int nMarkWidth = max(nRight - nLeft, 0);
3370 m_sMarkedWord = sLine.Mid(m_ptSelectionViewPosStart.x, nMarkWidth).Trim();
3371 if (m_sMarkedWord.Compare(m_sPreviousMarkedWord) == 0)
3372 {
3373 m_sMarkedWord.Empty();
3374 }
3375
3376 if (m_pwndLeft)
3377 m_pwndLeft->SetMarkedWord(m_sMarkedWord);
3378 if (m_pwndRight)
3379 m_pwndRight->SetMarkedWord(m_sMarkedWord);
3380 if (m_pwndBottom)
3381 m_pwndBottom->SetMarkedWord(m_sMarkedWord);
3382
3383 Invalidate();
3384 if (m_pwndLocator)
3385 m_pwndLocator->Invalidate();
3386 }
3387
3388 CView::OnLButtonDblClk(nFlags, point);
3389 }
3390
3391 void CBaseView::OnLButtonTrippleClick( UINT /*nFlags*/, CPoint point )
3392 {
3393 const int nClickedLine = GetButtonEventLineIndex(point);
3394 if (((point.y - HEADERHEIGHT) / GetLineHeight()) <= 0)
3395 {
3396 if (!m_sConvertedFilePath.IsEmpty() && (GetKeyState(VK_CONTROL)&0x8000))
3397 {
3398 PCIDLIST_ABSOLUTE __unaligned pidl = ILCreateFromPath((LPCTSTR)m_sConvertedFilePath);
3399 if (pidl)
3400 {
3401 SHOpenFolderAndSelectItems(pidl,0,0,0);
3402 CoTaskMemFree((LPVOID)pidl);
3403 }
3404 }
3405 return;
3406 }
3407 POINT ptCaretPos;
3408 ptCaretPos.y = nClickedLine;
3409 ptCaretPos.x = CalculateCharIndex(ptCaretPos.y, m_nOffsetChar + (point.x - GetMarginWidth()) / GetCharWidth());
3410 SetCaretAndGoalPosition(ptCaretPos);
3411 m_sMarkedWord = m_sPreviousMarkedWord; // recall previous Marked word
3412 if (m_pwndLeft)
3413 m_pwndLeft->SetMarkedWord(m_sMarkedWord);
3414 if (m_pwndRight)
3415 m_pwndRight->SetMarkedWord(m_sMarkedWord);
3416 if (m_pwndBottom)
3417 m_pwndBottom->SetMarkedWord(m_sMarkedWord);
3418 ClearSelection();
3419 m_ptSelectionViewPosStart.x = 0;
3420 m_ptSelectionViewPosStart.y = nClickedLine;
3421 m_ptSelectionViewPosEnd.x = GetLineLength(nClickedLine);
3422 m_ptSelectionViewPosEnd.y = nClickedLine;
3423 SetupSelection(m_ptSelectionViewPosStart.y, m_ptSelectionViewPosEnd.y);
3424 UpdateViewsCaretPosition();
3425 Invalidate();
3426 if (m_pwndLocator)
3427 m_pwndLocator->Invalidate();
3428 }
3429
3430 void CBaseView::OnEditCopy()
3431 {
3432 CString sCopyData = GetSelectedText();
3433
3434 if (!sCopyData.IsEmpty())
3435 {
3436 CStringUtils::WriteAsciiStringToClipboard(sCopyData, m_hWnd);
3437 }
3438 }
3439
3440 void CBaseView::OnMouseMove(UINT nFlags, CPoint point)
3441 {
3442 if (m_pMainFrame->m_nMoveMovesToIgnore > 0)
3443 {
3444 --m_pMainFrame->m_nMoveMovesToIgnore;
3445 CView::OnMouseMove(nFlags, point);
3446 return;
3447 }
3448 int nMouseLine = GetButtonEventLineIndex(point);
3449 if (nMouseLine < -1)
3450 nMouseLine = -1;
3451 m_mouseInMargin = point.x < GetMarginWidth();
3452
3453 ShowDiffLines(nMouseLine);
3454
3455 KillTimer(IDT_SCROLLTIMER);
3456 if (nFlags & MK_LBUTTON)
3457 {
3458 int saveMouseLine = nMouseLine >= 0 ? nMouseLine : 0;
3459 saveMouseLine = saveMouseLine < GetLineCount() ? saveMouseLine : GetLineCount() - 1;
3460 if (saveMouseLine < 0)
3461 return;
3462 int col = CalcColFromPoint(point.x, saveMouseLine);
3463 int charIndex = CalculateCharIndex(saveMouseLine, col);
3464 if (HasSelection() &&
3465 ((nMouseLine >= m_nTopLine)&&(nMouseLine < GetLineCount())))
3466 {
3467 POINT ptCaretPos = {charIndex, nMouseLine};
3468 SetCaretAndGoalPosition(ptCaretPos);
3469 AdjustSelection(MOVERIGHT);
3470 Invalidate();
3471 UpdateWindow();
3472 }
3473 if (nMouseLine < m_nTopLine)
3474 {
3475 ScrollAllToLine(m_nTopLine-1, TRUE);
3476 SetTimer(IDT_SCROLLTIMER, 20, nullptr);
3477 }
3478 if (nMouseLine >= m_nTopLine + GetScreenLines() - 2)
3479 {
3480 ScrollAllToLine(m_nTopLine+1, TRUE);
3481 SetTimer(IDT_SCROLLTIMER, 20, nullptr);
3482 }
3483 if (!m_pMainFrame->m_bWrapLines && ((m_nOffsetChar + (point.x - GetMarginWidth()) / GetCharWidth()) <= m_nOffsetChar))
3484 {
3485 ScrollAllSide(-1);
3486 SetTimer(IDT_SCROLLTIMER, 20, nullptr);
3487 }
3488 if (!m_pMainFrame->m_bWrapLines && (charIndex >= (GetScreenChars()+m_nOffsetChar-4)))
3489 {
3490 ScrollAllSide(1);
3491 SetTimer(IDT_SCROLLTIMER, 20, nullptr);
3492 }
3493 SetCapture();
3494 }
3495
3496
3497 CView::OnMouseMove(nFlags, point);
3498 }
3499
3500 void CBaseView::OnLButtonUp(UINT nFlags, CPoint point)
3501 {
3502 ShowDiffLines(-1);
3503 ReleaseCapture();
3504 KillTimer(IDT_SCROLLTIMER);
3505
3506 __super::OnLButtonUp(nFlags, point);
3507 }
3508
3509 void CBaseView::OnTimer(UINT_PTR nIDEvent)
3510 {
3511 if (nIDEvent == IDT_SCROLLTIMER)
3512 {
3513 POINT point;
3514 GetCursorPos(&point);
3515 ScreenToClient(&point);
3516 int nMouseLine = GetButtonEventLineIndex(point);
3517 if (nMouseLine < -1)
3518 {
3519 nMouseLine = -1;
3520 }
3521 if (GetKeyState(VK_LBUTTON)&0x8000)
3522 {
3523 int saveMouseLine = nMouseLine >= 0 ? nMouseLine : 0;
3524 saveMouseLine = saveMouseLine < GetLineCount() ? saveMouseLine : GetLineCount() - 1;
3525 int charIndex = CalculateCharIndex(saveMouseLine, m_nOffsetChar + (point.x - GetMarginWidth()) / GetCharWidth());
3526 if (nMouseLine < m_nTopLine)
3527 {
3528 ScrollAllToLine(m_nTopLine-1, TRUE);
3529 SetTimer(IDT_SCROLLTIMER, 20, nullptr);
3530 }
3531 if (nMouseLine >= m_nTopLine + GetScreenLines() - 2)
3532 {
3533 ScrollAllToLine(m_nTopLine+1, TRUE);
3534 SetTimer(IDT_SCROLLTIMER, 20, nullptr);
3535 }
3536 if (!m_pMainFrame->m_bWrapLines && ((m_nOffsetChar + (point.x - GetMarginWidth()) / GetCharWidth()) <= m_nOffsetChar))
3537 {
3538 ScrollAllSide(-1);
3539 SetTimer(IDT_SCROLLTIMER, 20, nullptr);
3540 }
3541 if (!m_pMainFrame->m_bWrapLines && (charIndex >= (GetScreenChars()+m_nOffsetChar-4)))
3542 {
3543 ScrollAllSide(1);
3544 SetTimer(IDT_SCROLLTIMER, 20, nullptr);
3545 }
3546 }
3547
3548 }
3549
3550 CView::OnTimer(nIDEvent);
3551 }
3552
3553 void CBaseView::ShowDiffLines(int nLine)
3554 {
3555 if ((nLine < m_nTopLine)||(nLine >= GetLineCount()))
3556 {
3557 m_pwndLineDiffBar->ShowLines(nLine);
3558 nLine = -1;
3559 m_nMouseLine = nLine;
3560 return;
3561 }
3562
3563 if ((!m_pwndRight)||(!m_pwndLeft))
3564 return;
3565 if(m_pMainFrame->m_bOneWay)
3566 return;
3567
3568 nLine = (nLine > (int)m_pwndRight->m_Screen2View.size() ? -1 : nLine);
3569 nLine = (nLine > (int)m_pwndLeft->m_Screen2View.size() ? -1 : nLine);
3570
3571 if (nLine < 0)
3572 return;
3573
3574 if (nLine != m_nMouseLine)
3575 {
3576 if (nLine >= GetLineCount())
3577 nLine = -1;
3578 m_nMouseLine = nLine;
3579 m_pwndLineDiffBar->ShowLines(nLine);
3580 }
3581 m_pMainFrame->m_nMoveMovesToIgnore = MOVESTOIGNORE;
3582 }
3583
3584 const viewdata& CBaseView::GetEmptyLineData()
3585 {
3586 static const viewdata emptyLine(L"", DIFFSTATE_EMPTY, -1, EOL_NOENDING, HIDESTATE_SHOWN);
3587 return emptyLine;
3588 }
3589
3590 void CBaseView::InsertViewEmptyLines(int nFirstView, int nCount)
3591 {
3592 for (int i = 0; i < nCount; i++)
3593 {
3594 InsertViewData(nFirstView, GetEmptyLineData());
3595 }
3596 }
3597
3598
3599 void CBaseView::UpdateCaret()
3600 {
3601 POINT ptCaretPos = GetCaretPosition();
3602 ptCaretPos.y = std::max<int>(std::min<int>(ptCaretPos.y, GetLineCount()-1), 0);
3603 ptCaretPos.x = std::max<int>(std::min<int>(ptCaretPos.x, GetLineLength(ptCaretPos.y)), 0);
3604 SetCaretPosition(ptCaretPos);
3605
3606 int nCaretOffset = CalculateActualOffset(ptCaretPos);
3607
3608 if (m_bFocused &&
3609 ptCaretPos.y >= m_nTopLine &&
3610 ptCaretPos.y < (m_nTopLine+GetScreenLines()) &&
3611 nCaretOffset >= m_nOffsetChar &&
3612 nCaretOffset < (m_nOffsetChar+GetScreenChars()))
3613 {
3614 POINT pt1 = TextToClient(ptCaretPos);
3615 if (m_bInsertMode)
3616 CreateSolidCaret(2, GetLineHeight());
3617 else
3618 {
3619 POINT pt = { ptCaretPos.x + 1, ptCaretPos.y };
3620 POINT pt2 = TextToClient(pt);
3621 int width = max(GetCharWidth(), pt2.x - pt1.x);
3622 CreateSolidCaret(width, GetLineHeight());
3623 }
3624 SetCaretPos(pt1);
3625 ShowCaret();
3626 }
3627 else
3628 {
3629 HideCaret();
3630 }
3631 }
3632
3633 POINT CBaseView::ConvertScreenPosToView(const POINT& pt)
3634 {
3635 POINT ptViewPos;
3636 ptViewPos.x = pt.x;
3637
3638 int nSubLine = GetSubLineOffset(pt.y);
3639 if (nSubLine > 0)
3640 {
3641 for (int nScreenLine = pt.y-1; nScreenLine >= pt.y-nSubLine; nScreenLine--)
3642 {
3643 ptViewPos.x += GetLineChars(nScreenLine).GetLength();
3644 }
3645 }
3646
3647 ptViewPos.y = GetViewLineForScreen(pt.y);
3648 return ptViewPos;
3649 }
3650
3651 POINT CBaseView::ConvertViewPosToScreen(const POINT& pt)
3652 {
3653 POINT ptPos;
3654 int nViewLineLenLeft = GetViewLineLength(pt.y);
3655 ptPos.x = min(nViewLineLenLeft, pt.x);
3656 ptPos.y = FindScreenLineForViewLine(pt.y);
3657 if (GetViewLineForScreen(ptPos.y) != pt.y )
3658 {
3659 ptPos.x = 0;
3660 }
3661 else if (GetSubLineOffset(ptPos.y) >= 0) // sublined
3662 {
3663 int nSubLineLength = GetLineChars(ptPos.y).GetLength();
3664 while (nSubLineLength < ptPos.x)
3665 {
3666 ptPos.x -= nSubLineLength;
3667 nViewLineLenLeft -= nSubLineLength;
3668 ptPos.y++;
3669 nSubLineLength = GetLineChars(ptPos.y).GetLength();
3670 }
3671 // last pos of non last sub-line go to start of next screen line
3672 // Note: while this works correctly, it's not what a user might expect:
3673 // cursor-right when the caret is before the last char of a wrapped line
3674 // now moves the caret to the next line. But users expect the caret to
3675 // move to the right of the last char instead, and with another cursor-right
3676 // keystroke to move the caret to the next line.
3677 // Basically, this would require to handle two caret positions for the same
3678 // logical position in the line string (one on the last position of the first line,
3679 // one on the first position of the new line. For non-wrapped lines this works
3680 // because there's an 'invisible' newline char at the end of the first line.
3681 if (nSubLineLength == ptPos.x && nViewLineLenLeft > nSubLineLength)
3682 {
3683 ptPos.x = 0;
3684 ptPos.y++;
3685 }
3686 }
3687
3688 return ptPos;
3689 }
3690
3691
3692 void CBaseView::EnsureCaretVisible()
3693 {
3694 POINT ptCaretPos = GetCaretPosition();
3695 int nCaretOffset = CalculateActualOffset(ptCaretPos);
3696
3697 if (ptCaretPos.y < m_nTopLine)
3698 ScrollAllToLine(ptCaretPos.y);
3699 int screnLines = GetScreenLines();
3700 if (screnLines)
3701 {
3702 if (ptCaretPos.y >= (m_nTopLine+screnLines)-1)
3703 ScrollAllToLine(ptCaretPos.y-screnLines+2);
3704 if (nCaretOffset < m_nOffsetChar)
3705 ScrollAllToChar(nCaretOffset);
3706 if (nCaretOffset > (m_nOffsetChar+GetScreenChars()-1))
3707 ScrollAllToChar(nCaretOffset-GetScreenChars()+1);
3708 }
3709 }
3710
3711 int CBaseView::CalculateActualOffset(const POINT& point)
3712 {
3713 int nLineIndex = point.y;
3714 int nCharIndex = point.x;
3715 ASSERT(nCharIndex >= 0);
3716 CString sLine = GetLineChars(nLineIndex);
3717 int nLineLength = sLine.GetLength();
3718 return CountExpandedChars(sLine, min(nCharIndex, nLineLength));
3719 }
3720
3721 int CBaseView::CalculateCharIndex(int nLineIndex, int nActualOffset)
3722 {
3723 int nLength = GetLineLength(nLineIndex);
3724 int nSubLine = GetSubLineOffset(nLineIndex);
3725 if (nSubLine>=0)
3726 {
3727 int nViewLine = GetViewLineForScreen(nLineIndex);
3728 if ((nViewLine>=0)&&(nViewLine < (int)m_ScreenedViewLine.size()))
3729 {
3730 int nMultilineCount = CountMultiLines(nViewLine);
3731 if ((nMultilineCount>0) && (nSubLine<nMultilineCount-1))
3732 {
3733 nLength--;
3734 }
3735 }
3736 }
3737 CString Line = GetLineChars(nLineIndex);
3738 int nIndex = 0;
3739 int nOffset = 0;
3740 int nTabSize = GetTabSize();
3741 while (nOffset < nActualOffset && nIndex < nLength)
3742 {
3743 if (Line.GetAt(nIndex) == L'\t')
3744 nOffset += (nTabSize - nOffset % nTabSize);
3745 else
3746 ++nOffset;
3747 ++nIndex;
3748 }
3749 return nIndex;
3750 }
3751
3752 /**
3753 * @param xpos X coordinate in CBaseView
3754 * @param lineIndex logical line index (e.g. wrap/collapse)
3755 */
3756 int CBaseView::CalcColFromPoint(int xpos, int lineIndex)
3757 {
3758 int xpos2;
3759 CDC *pDC = GetDC();
3760 if (pDC)
3761 {
3762 CString text = ExpandChars(GetLineChars(lineIndex), 0);
3763 int fit = text.GetLength();
3764 auto posBuffer = std::make_unique<int[]>(fit);
3765 pDC->SelectObject(GetFont()); // is this right font ?
3766 SIZE size;
3767 GetTextExtentExPoint(pDC->GetSafeHdc(), text, fit, INT_MAX, &fit, posBuffer.get(), &size);
3768 ReleaseDC(pDC);
3769 int lower = -1, upper = fit - 1;
3770 int xcheck = xpos - GetMarginWidth() + m_nOffsetChar * GetCharWidth();
3771 do
3772 {
3773 int middle = (upper + lower + 1) / 2;
3774 int width = posBuffer[middle];
3775 if (xcheck < width)
3776 upper = middle - 1;
3777 else
3778 lower = middle;
3779 } while (lower < upper);
3780 lower++;
3781 xpos2 = lower;
3782 if (lower < fit - 1)
3783 {
3784 int charWidth = posBuffer[lower] - (lower > 0 ? posBuffer[lower - 1] : 0);
3785 if (posBuffer[lower] - xcheck <= charWidth / 2)
3786 xpos2++;
3787 }
3788 }
3789 else
3790 {
3791 xpos2 = (xpos - GetMarginWidth()) / GetCharWidth() + m_nOffsetChar;
3792 if ((xpos % GetCharWidth()) >= (GetCharWidth()/2))
3793 xpos2++;
3794 }
3795 return xpos2;
3796 }
3797
3798 POINT CBaseView::TextToClient(const POINT& point)
3799 {
3800 POINT pt;
3801 int nOffsetScreenLine = max(0, (point.y - m_nTopLine));
3802 pt.y = nOffsetScreenLine * GetLineHeight();
3803 pt.x = CalculateActualOffset(point);
3804
3805 int nLeft = GetMarginWidth() - m_nOffsetChar * GetCharWidth();
3806 CDC * pDC = GetDC();
3807 if (pDC)
3808 {
3809 pDC->SelectObject(GetFont()); // is this right font ?
3810 int nScreenLine = nOffsetScreenLine + m_nTopLine;
3811 CString sLine = GetLineChars(nScreenLine);
3812 ExpandChars(sLine, 0, std::min<int>(pt.x, sLine.GetLength()), sLine);
3813 nLeft += pDC->GetTextExtent(sLine, pt.x).cx;
3814 ReleaseDC(pDC);
3815 } else {
3816 nLeft += pt.x * GetCharWidth();
3817 }
3818
3819 pt.x = nLeft;
3820 pt.y = (pt.y + GetLineHeight() + HEADERHEIGHT);
3821 return pt;
3822 }
3823
3824 void CBaseView::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
3825 {
3826 CView::OnChar(nChar, nRepCnt, nFlags);
3827
3828 bool bShift = !!(GetKeyState(VK_SHIFT)&0x8000);
3829 bool bSkipSelectionClear = false;
3830
3831 if (IsReadonly())
3832 return;
3833
3834 if ((::GetKeyState(VK_LBUTTON) & 0x8000) != 0 ||
3835 (::GetKeyState(VK_RBUTTON) & 0x8000) != 0)
3836 {
3837 return;
3838 }
3839
3840 if (!m_pViewData) // no data - nothing to do
3841 return;
3842
3843 if (nChar == VK_F16)
3844 {
3845 // generated by a ctrl+backspace - ignore.
3846 }
3847 else if (nChar==VK_TAB && HasTextLineSelection())
3848 {
3849 // change indentation for selected lines
3850 if (bShift)
3851 {
3852 RemoveIndentationForSelectedBlock();
3853 }
3854 else
3855 {
3856 AddIndentationForSelectedBlock();
3857 }
3858 bSkipSelectionClear = true;
3859 }
3860 else if ((nChar > 31)||(nChar == VK_TAB))
3861 {
3862 ResetUndoStep();
3863 RemoveSelectedText();
3864 POINT ptCaretViewPos = GetCaretViewPosition();
3865 int nViewLine = ptCaretViewPos.y;
3866 if ((nViewLine==0)&&(GetViewCount()==0))
3867 OnChar(VK_RETURN, 0, 0);
3868 int charCount = 1;
3869 viewdata lineData = GetViewData(nViewLine);
3870 if (nChar == VK_TAB)
3871 {
3872 int indentChars = GetIndentCharsForLine(ptCaretViewPos.x, nViewLine);
3873 if (indentChars > 0)
3874 {
3875 lineData.sLine.Insert(ptCaretViewPos.x, CString(L' ', indentChars));
3876 charCount = indentChars;
3877 }
3878 else
3879 lineData.sLine.Insert(ptCaretViewPos.x, L'\t');
3880 }
3881 else
3882 {
3883 if (m_bInsertMode)
3884 lineData.sLine.Insert(ptCaretViewPos.x, (wchar_t)nChar);
3885 else
3886 {
3887 if (lineData.sLine.GetLength() > ptCaretViewPos.x)
3888 lineData.sLine.SetAt(ptCaretViewPos.x, (wchar_t)nChar);
3889 else
3890 lineData.sLine.Insert(ptCaretViewPos.x, (wchar_t)nChar);
3891 }
3892 }
3893 if (IsStateEmpty(lineData.state))
3894 {
3895 // if not last line set EOL
3896 for (int nCheckViewLine = nViewLine+1; nCheckViewLine < GetViewCount(); nCheckViewLine++)
3897 {
3898 if (!IsViewLineEmpty(nCheckViewLine))
3899 {
3900 lineData.ending = m_lineendings;
3901 break;
3902 }
3903 }
3904 // make sure previous (non empty) line have EOL set
3905 for (int nCheckViewLine = nViewLine-1; nCheckViewLine > 0; nCheckViewLine--)
3906 {
3907 if (!IsViewLineEmpty(nCheckViewLine))
3908 {
3909 if (GetViewLineEnding(nCheckViewLine) == EOL_NOENDING)
3910 {
3911 SetViewLineEnding(nCheckViewLine, m_lineendings);
3912 }
3913 break;
3914 }
3915 }
3916 }
3917 lineData.state = DIFFSTATE_EDITED;
3918 bool bNeedRenumber = false;
3919 if (lineData.linenumber == -1)
3920 {
3921 lineData.linenumber = 0;
3922 bNeedRenumber = true;
3923 }
3924 SetViewData(nViewLine, lineData);
3925 SetModified();
3926 SaveUndoStep();
3927 BuildAllScreen2ViewVector(nViewLine);
3928 if (bNeedRenumber)
3929 {
3930 UpdateViewLineNumbers();
3931 }
3932 for (int i = 0; i < charCount; ++i)
3933 MoveCaretRight();
3934 UpdateGoalPos();
3935 }
3936 else if (nChar == 10)
3937 {
3938 int nViewLine = GetViewLineForScreen(GetCaretPosition().y);
3939 EOL eol = m_pViewData->GetLineEnding(nViewLine);
3940 EOL newEOL = EOL_CRLF;
3941 switch (eol)
3942 {
3943 case EOL_CRLF:
3944 newEOL = EOL_CR;
3945 break;
3946 case EOL_CR:
3947 newEOL = EOL_LF;
3948 break;
3949 case EOL_LF:
3950 newEOL = EOL_CRLF;
3951 break;
3952 }
3953 if (eol==EOL_NOENDING || eol==newEOL)
3954 // don't allow to change enter on empty line, or last text line (lines with EOL_NOENDING)
3955 // to add EOL on newly edited empty line hit enter
3956 // don't store into UNDO if no change happened
3957 // and don't mark file as modified
3958 return;
3959 AddUndoViewLine(nViewLine);
3960 m_pViewData->SetLineEnding(nViewLine, newEOL);
3961 m_pViewData->SetState(nViewLine, DIFFSTATE_EDITED);
3962 UpdateGoalPos();
3963 }
3964 else if (nChar == VK_RETURN)
3965 {
3966 // insert a new, fresh and empty line below the cursor
3967 RemoveSelectedText();
3968
3969 CUndo::GetInstance().BeginGrouping();
3970
3971 POINT ptCaretViewPos = GetCaretViewPosition();
3972 int nViewLine = ptCaretViewPos.y;
3973 int nLeft = ptCaretViewPos.x;
3974 CString sLine = GetViewLineChars(nViewLine);
3975 CString sLineLeft = sLine.Left(nLeft);
3976 CString sLineRight = sLine.Right(sLine.GetLength() - nLeft);
3977 EOL eOriginalEnding = EOL_AUTOLINE;
3978 if (m_pViewData->GetCount() > nViewLine)
3979 eOriginalEnding = GetViewLineEnding(nViewLine);
3980
3981 if (!sLineRight.IsEmpty() || (eOriginalEnding!=m_lineendings))
3982 {
3983 viewdata newFirstLine(sLineLeft, DIFFSTATE_EDITED, 1, m_lineendings, HIDESTATE_SHOWN);
3984 SetViewData(nViewLine, newFirstLine);
3985 }
3986
3987 int nInsertLine = (m_pViewData->GetCount()==0) ? 0 : nViewLine + 1;
3988 viewdata newLastLine(sLineRight, DIFFSTATE_EDITED, 1, eOriginalEnding, HIDESTATE_SHOWN);
3989 InsertViewData(nInsertLine, newLastLine);
3990 SetModified();
3991 SaveUndoStep();
3992
3993 // adds new line everywhere except me
3994 if (IsViewGood(m_pwndLeft) && m_pwndLeft!=this)
3995 {
3996 m_pwndLeft->InsertViewEmptyLines(nInsertLine, 1);
3997 }
3998 if (IsViewGood(m_pwndRight) && m_pwndRight!=this)
3999 {
4000 m_pwndRight->InsertViewEmptyLines(nInsertLine, 1);
4001 }
4002 if (IsViewGood(m_pwndBottom) && m_pwndBottom!=this)
4003 {
4004 m_pwndBottom->InsertViewEmptyLines(nInsertLine, 1);
4005 }
4006 SaveUndoStep();
4007
4008 UpdateViewLineNumbers();
4009 SaveUndoStep();
4010 CUndo::GetInstance().EndGrouping();
4011
4012 BuildAllScreen2ViewVector();
4013 // move the cursor to the new line
4014 ptCaretViewPos = SetupPoint(0, nViewLine+1);
4015 SetCaretAndGoalViewPosition(ptCaretViewPos);
4016 }
4017 else
4018 return; // Unknown control character -- ignore it.
4019 if (!bSkipSelectionClear)
4020 ClearSelection();
4021 EnsureCaretVisible();
4022 UpdateCaret();
4023 Invalidate(FALSE);
4024 }
4025
4026 void CBaseView::AddUndoViewLine(int nViewLine, bool bAddEmptyLine)
4027 {
4028 ResetUndoStep();
4029 m_AllState.left.AddViewLineFromView(m_pwndLeft, nViewLine, bAddEmptyLine);
4030 m_AllState.right.AddViewLineFromView(m_pwndRight, nViewLine, bAddEmptyLine);
4031 m_AllState.bottom.AddViewLineFromView(m_pwndBottom, nViewLine, bAddEmptyLine);
4032 SetModified();
4033 SaveUndoStep();
4034 RecalcAllVertScrollBars();
4035 Invalidate(FALSE);
4036 }
4037
4038 void CBaseView::AddEmptyViewLine(int nViewLineIndex)
4039 {
4040 if (!m_pViewData)
4041 return;
4042 int viewLine = nViewLineIndex;
4043 EOL ending = m_pViewData->GetLineEnding(viewLine);
4044 if (ending == EOL_NOENDING)
4045 {
4046 ending = m_lineendings;
4047 }
4048 viewdata newLine(L"", DIFFSTATE_EDITED, -1, ending, HIDESTATE_SHOWN);
4049 if (IsTarget()) // TODO: once more wievs will writable this is not correct anymore
4050 {
4051 CString sPartLine = GetViewLineChars(nViewLineIndex);
4052 int nPosx = GetCaretPosition().x; // should be view pos ?
4053 m_pViewData->SetLine(viewLine, sPartLine.Left(nPosx));
4054 sPartLine = sPartLine.Mid(nPosx);
4055 newLine.sLine = sPartLine;
4056 }
4057 m_pViewData->InsertData(viewLine+1, newLine);
4058 BuildAllScreen2ViewVector();
4059 }
4060
4061 void CBaseView::RemoveSelectedText()
4062 {
4063 if (!m_pViewData)
4064 return;
4065 if (!HasTextSelection())
4066 return;
4067
4068 // fix selection if starts or ends on empty line
4069 SetCaretViewPosition(m_ptSelectionViewPosEnd);
4070 while (IsViewLineEmpty(GetCaretViewPosition().y) && MoveCaretRight())
4071 {
4072 }
4073 m_ptSelectionViewPosEnd = GetCaretViewPosition();
4074 SetCaretViewPosition(m_ptSelectionViewPosStart);
4075 while (IsViewLineEmpty(GetCaretViewPosition().y) && MoveCaretRight())
4076 {
4077 }
4078 m_ptSelectionViewPosStart = GetCaretViewPosition();
4079 if (!HasTextSelection())
4080 {
4081 ClearSelection();
4082 return;
4083 }
4084
4085 // We want to undo the insertion in a single step.
4086 ResetUndoStep();
4087 CUndo::GetInstance().BeginGrouping();
4088
4089 // combine first and last line
4090 viewdata oFirstLine = GetViewData(m_ptSelectionViewPosStart.y);
4091 viewdata oLastLine = GetViewData(m_ptSelectionViewPosEnd.y);
4092 oFirstLine.sLine = oFirstLine.sLine.Left(m_ptSelectionViewPosStart.x) + oLastLine.sLine.Mid(m_ptSelectionViewPosEnd.x);
4093 oFirstLine.ending = oLastLine.ending;
4094 oFirstLine.state = DIFFSTATE_EDITED;
4095 SetViewData(m_ptSelectionViewPosStart.y, oFirstLine);
4096
4097 // clean up middle lines if any
4098 if (m_ptSelectionViewPosStart.y != m_ptSelectionViewPosEnd.y)
4099 {
4100 viewdata oEmptyLine = GetEmptyLineData();
4101 for (int nViewLine = m_ptSelectionViewPosStart.y+1; nViewLine <= m_ptSelectionViewPosEnd.y; nViewLine++)
4102 {
4103 SetViewData(nViewLine, oEmptyLine);
4104 }
4105 SaveUndoStep();
4106
4107 if (CleanEmptyLines())
4108 {
4109 BuildAllScreen2ViewVector(); // schedule full rebuild
4110 }
4111 SaveUndoStep();
4112 UpdateViewLineNumbers();
4113 }
4114
4115 SetModified(); //TODO set modified only if real data was changed
4116 SaveUndoStep();
4117 CUndo::GetInstance().EndGrouping();
4118
4119 BuildAllScreen2ViewVector(m_ptSelectionViewPosStart.y, m_ptSelectionViewPosEnd.y);
4120 SetCaretViewPosition(m_ptSelectionViewPosStart);
4121 UpdateGoalPos();
4122 ClearSelection();
4123 UpdateCaret();
4124 EnsureCaretVisible();
4125 Invalidate(FALSE);
4126 }
4127
4128 void CBaseView::PasteText()
4129 {
4130 if (!OpenClipboard())
4131 return;
4132
4133 CString sClipboardText;
4134 HGLOBAL hglb = GetClipboardData(CF_TEXT);
4135 if (hglb)
4136 {
4137 LPCSTR lpstr = (LPCSTR)GlobalLock(hglb);
4138 sClipboardText = CString(lpstr);
4139 GlobalUnlock(hglb);
4140 }
4141 hglb = GetClipboardData(CF_UNICODETEXT);
4142 if (hglb)
4143 {
4144 LPCTSTR lpstr = (LPCTSTR)GlobalLock(hglb);
4145 sClipboardText = lpstr;
4146 GlobalUnlock(hglb);
4147 }
4148 CloseClipboard();
4149
4150 if (sClipboardText.IsEmpty())
4151 return;
4152
4153 sClipboardText.Replace(L"\r\n", L"\r");
4154 sClipboardText.Replace('\n', '\r');
4155
4156 InsertText(sClipboardText);
4157 }
4158
4159 void CBaseView::OnCaretDown()
4160 {
4161 POINT ptCaretPos = GetCaretPosition();
4162 int nLine = ptCaretPos.y;
4163 int nNextLine = nLine + 1;
4164 if (nNextLine >= GetLineCount()) // already at last line
4165 {
4166 return;
4167 }
4168
4169 POINT ptCaretViewPos = GetCaretViewPosition();
4170 int nViewLine = ptCaretViewPos.y;
4171 int nNextViewLine = GetViewLineForScreen(nNextLine);
4172 if (!((nNextViewLine == nViewLine) && (GetSubLineOffset(nNextLine)<CountMultiLines(nNextViewLine)))) // not on same view line
4173 {
4174 // find next suitable screen line
4175 while ((nNextViewLine == nViewLine) || IsViewLineHidden(nNextViewLine))
4176 {
4177 nNextLine++;
4178 if (nNextLine >= GetLineCount())
4179 {
4180 return;
4181 }
4182 nNextViewLine = GetViewLineForScreen(nNextLine);
4183 }
4184 }
4185 ptCaretPos.y = nNextLine;
4186 ptCaretPos.x = CalculateCharIndex(ptCaretPos.y, m_nCaretGoalPos);
4187 SetCaretPosition(ptCaretPos);
4188 OnCaretMove(MOVELEFT);
4189 ShowDiffLines(ptCaretPos.y);
4190 }
4191
4192 bool CBaseView::MoveCaretLeft()
4193 {
4194 POINT ptCaretViewPos = GetCaretViewPosition();
4195
4196 //int nViewLine = ptCaretViewPos.y;
4197 if (ptCaretViewPos.x == 0)
4198 {
4199 int nPrevLine = GetCaretPosition().y;
4200 int nPrevViewLine;
4201 do {
4202 nPrevLine--;
4203 if (nPrevLine < 0)
4204 {
4205 return false;
4206 }
4207 nPrevViewLine = GetViewLineForScreen(nPrevLine);
4208 } while ((GetSubLineOffset(nPrevLine) >= CountMultiLines(nPrevViewLine)) || IsViewLineHidden(nPrevViewLine));
4209 ptCaretViewPos = ConvertScreenPosToView(SetupPoint(GetLineLength(nPrevLine), nPrevLine));
4210 ShowDiffLines(nPrevLine);
4211 }
4212 else
4213 --ptCaretViewPos.x;
4214
4215 SetCaretAndGoalViewPosition(ptCaretViewPos);
4216 return true;
4217 }
4218
4219 bool CBaseView::MoveCaretRight()
4220 {
4221 POINT ptCaretViewPos = GetCaretViewPosition();
4222
4223 int nViewLine = ptCaretViewPos.y;
4224 int nViewLineLen = GetViewLineLength(nViewLine);
4225 if (ptCaretViewPos.x >= nViewLineLen)
4226 {
4227 int nNextLine = GetCaretPosition().y;
4228 int nNextViewLine;
4229 do {
4230 nNextLine++;
4231 if (nNextLine >= GetLineCount())
4232 {
4233 return false;
4234 }
4235 nNextViewLine = GetViewLineForScreen(nNextLine);
4236 } while (nNextViewLine == nViewLine || IsViewLineHidden(nNextViewLine));
4237 ptCaretViewPos.y = nNextViewLine;
4238 ptCaretViewPos.x = 0;
4239 ShowDiffLines(nNextLine);
4240 }
4241 else
4242 ++ptCaretViewPos.x;
4243
4244 SetCaretAndGoalViewPosition(ptCaretViewPos);
4245 return true;
4246 }
4247
4248 void CBaseView::UpdateGoalPos()
4249 {
4250 m_nCaretGoalPos = CalculateActualOffset(GetCaretPosition());
4251 }
4252
4253 void CBaseView::OnCaretLeft()
4254 {
4255 MoveCaretLeft();
4256 OnCaretMove(MOVELEFT);
4257 }
4258
4259 void CBaseView::OnCaretRight()
4260 {
4261 MoveCaretRight();
4262 OnCaretMove(MOVERIGHT);
4263 }
4264
4265 void CBaseView::OnCaretUp()
4266 {
4267 POINT ptCaretPos = GetCaretPosition();
4268 int nLine = ptCaretPos.y;
4269 if (nLine <= 0) // already at first line
4270 {
4271 return;
4272 }
4273 int nPrevLine = nLine - 1;
4274
4275 POINT ptCaretViewPos = GetCaretViewPosition();
4276 int nViewLine = ptCaretViewPos.y;
4277 int nPrevViewLine = GetViewLineForScreen(nPrevLine);
4278 if (nPrevViewLine != nViewLine) // not on same view line
4279 {
4280 // find previous suitable screen line
4281 while ((GetSubLineOffset(nPrevLine) >= CountMultiLines(nPrevViewLine)) || IsViewLineHidden(nPrevViewLine))
4282 {
4283 if (nPrevLine <= 0)
4284 {
4285 return;
4286 }
4287 nPrevLine--;
4288 nPrevViewLine = GetViewLineForScreen(nPrevLine);
4289 }
4290 }
4291 ptCaretPos.y = nPrevLine;
4292 ptCaretPos.x = CalculateCharIndex(ptCaretPos.y, m_nCaretGoalPos);
4293 SetCaretPosition(ptCaretPos);
4294 OnCaretMove(MOVELEFT);
4295 ShowDiffLines(ptCaretPos.y);
4296 }
4297
4298 bool CBaseView::IsWordSeparator(const wchar_t ch) const
4299 {
4300 switch (GetCharGroup(ch))
4301 {
4302 case CHG_CONTROL:
4303 case CHG_WHITESPACE:
4304 case CHG_WORDSEPARATOR:
4305 return true;
4306 }
4307 return false;
4308 }
4309
4310 bool CBaseView::IsCaretAtWordBoundary()
4311 {
4312 POINT ptViewCaret = GetCaretViewPosition();
4313 CString line = GetViewLineChars(ptViewCaret.y);
4314 if (line.IsEmpty())
4315 return false; // no boundary at the empty lines
4316 if (ptViewCaret.x == 0)
4317 return !IsWordSeparator(line.GetAt(ptViewCaret.x));
4318 if (ptViewCaret.x >= GetViewLineLength(ptViewCaret.y))
4319 return !IsWordSeparator(line.GetAt(ptViewCaret.x - 1));
4320 return
4321 IsWordSeparator(line.GetAt(ptViewCaret.x)) !=
4322 IsWordSeparator(line.GetAt(ptViewCaret.x - 1));
4323 }
4324
4325 void CBaseView::UpdateViewsCaretPosition()
4326 {
4327 POINT ptCaretPos = GetCaretPosition();
4328 if (m_pwndBottom && m_pwndBottom!=this)
4329 m_pwndBottom->UpdateCaretPosition(ptCaretPos);
4330 if (m_pwndLeft && m_pwndLeft!=this)
4331 m_pwndLeft->UpdateCaretPosition(ptCaretPos);
4332 if (m_pwndRight && m_pwndRight!=this)
4333 m_pwndRight->UpdateCaretPosition(ptCaretPos);
4334 }
4335
4336 void CBaseView::OnCaretWordleft()
4337 {
4338 MoveCaretWordLeft();
4339 OnCaretMove(MOVELEFT);
4340 }
4341
4342 void CBaseView::OnCaretWordright()
4343 {
4344 MoveCaretWordRight();
4345 OnCaretMove(MOVERIGHT);
4346 }
4347
4348 void CBaseView::MoveCaretWordLeft()
4349 {
4350 while (MoveCaretLeft() && !IsCaretAtWordBoundary())
4351 {
4352 }
4353 }
4354
4355 void CBaseView::MoveCaretWordRight()
4356 {
4357 while (MoveCaretRight() && !IsCaretAtWordBoundary())
4358 {
4359 }
4360 }
4361
4362 void CBaseView::ClearCurrentSelection()
4363 {
4364 m_ptSelectionViewPosStart = GetCaretViewPosition();
4365 m_ptSelectionViewPosEnd = m_ptSelectionViewPosStart;
4366 m_ptSelectionViewPosOrigin = m_ptSelectionViewPosStart;
4367 m_nSelViewBlockStart = -1;
4368 m_nSelViewBlockEnd = -1;
4369 Invalidate(FALSE);
4370 }
4371
4372 void CBaseView::ClearSelection()
4373 {
4374 if (m_pwndLeft)
4375 m_pwndLeft->ClearCurrentSelection();
4376 if (m_pwndRight)
4377 m_pwndRight->ClearCurrentSelection();
4378 if (m_pwndBottom)
4379 m_pwndBottom->ClearCurrentSelection();
4380 }
4381
4382 void CBaseView::AdjustSelection(bool bMoveLeft)
4383 {
4384 POINT ptCaretViewPos = GetCaretViewPosition();
4385 if (ArePointsSame(m_ptSelectionViewPosOrigin, SetupPoint(-1, -1)))
4386 {
4387 // select all have been used recently update origin
4388 m_ptSelectionViewPosOrigin = bMoveLeft ? m_ptSelectionViewPosEnd : m_ptSelectionViewPosStart;
4389 }
4390 if ((ptCaretViewPos.y < m_ptSelectionViewPosOrigin.y) ||
4391 (ptCaretViewPos.y == m_ptSelectionViewPosOrigin.y && ptCaretViewPos.x <= m_ptSelectionViewPosOrigin.x))
4392 {
4393 m_ptSelectionViewPosStart = ptCaretViewPos;
4394 m_ptSelectionViewPosEnd = m_ptSelectionViewPosOrigin;
4395 }
4396 else
4397 {
4398 m_ptSelectionViewPosStart = m_ptSelectionViewPosOrigin;
4399 m_ptSelectionViewPosEnd = ptCaretViewPos;
4400 }
4401
4402 SetupAllViewSelection(m_ptSelectionViewPosStart.y, m_ptSelectionViewPosEnd.y);
4403
4404 Invalidate(FALSE);
4405 }
4406
4407 void CBaseView::OnEditCut()
4408 {
4409 if (IsWritable())
4410 {
4411 OnEditCopy();
4412 RemoveSelectedText();
4413 }
4414 }
4415
4416 void CBaseView::OnEditPaste()
4417 {
4418 if (IsWritable())
4419 {
4420 CUndo::GetInstance().BeginGrouping();
4421 RemoveSelectedText();
4422 PasteText();
4423 CUndo::GetInstance().EndGrouping();
4424 }
4425 }
4426
4427 void CBaseView::DeleteFonts()
4428 {
4429 for (int i=0; i<fontsCount; i++)
4430 {
4431 if (m_apFonts[i])
4432 {
4433 m_apFonts[i]->DeleteObject();
4434 delete m_apFonts[i];
4435 m_apFonts[i] = nullptr;
4436 }
4437 }
4438 }
4439
4440 void CBaseView::OnCaretMove(bool bMoveLeft)
4441 {
4442 bool bShift = !!(GetKeyState(VK_SHIFT)&0x8000);
4443 OnCaretMove(bMoveLeft, bShift);
4444 }
4445
4446 void CBaseView::OnCaretMove(bool bMoveLeft, bool isShiftPressed)
4447 {
4448 if(isShiftPressed)
4449 AdjustSelection(bMoveLeft);
4450 else
4451 ClearSelection();
4452 EnsureCaretVisible();
4453 UpdateCaret();
4454 }
4455
4456 void CBaseView::AddContextItems(CIconMenu& popup, DiffStates /*state*/)
4457 {
4458 AddCutCopyAndPaste(popup);
4459 }
4460
4461 void CBaseView::AddCutCopyAndPaste(CIconMenu& popup)
4462 {
4463 popup.AppendMenu(MF_SEPARATOR, NULL);
4464 CString temp;
4465 temp.LoadString(IDS_EDIT_COPY);
4466 popup.AppendMenu(MF_STRING | (HasTextSelection() ? MF_ENABLED : MF_DISABLED|MF_GRAYED), ID_EDIT_COPY, temp);
4467 if (IsWritable())
4468 {
4469 temp.LoadString(IDS_EDIT_CUT);
4470 popup.AppendMenu(MF_STRING | (HasTextSelection() ? MF_ENABLED : MF_DISABLED|MF_GRAYED), ID_EDIT_CUT, temp);
4471 temp.LoadString(IDS_EDIT_PASTE);
4472 popup.AppendMenu(MF_STRING | (CAppUtils::HasClipboardFormat(CF_UNICODETEXT)||CAppUtils::HasClipboardFormat(CF_TEXT) ? MF_ENABLED : MF_DISABLED|MF_GRAYED), ID_EDIT_PASTE, temp);
4473 popup.AppendMenu(MF_SEPARATOR, NULL);
4474 }
4475 }
4476
4477 void CBaseView::CompensateForKeyboard(CPoint& point)
4478 {
4479 // if the context menu is invoked through the keyboard, we have to use
4480 // a calculated position on where to anchor the menu on
4481 if (ArePointsSame(point, SetupPoint(-1, -1)))
4482 {
4483 CRect rect;
4484 GetWindowRect(&rect);
4485 point = rect.CenterPoint();
4486 }
4487 }
4488
4489 HICON CBaseView::LoadIcon(WORD iconId)
4490 {
4491 int iconWidth = GetSystemMetrics(SM_CXSMICON);
4492 int iconHeight = GetSystemMetrics(SM_CYSMICON);
4493 HANDLE icon = ::LoadImage( AfxGetResourceHandle(), MAKEINTRESOURCE(iconId),
4494 IMAGE_ICON, iconWidth, iconHeight, LR_DEFAULTCOLOR);
4495 return (HICON)icon;
4496 }
4497
4498 void CBaseView::ReleaseBitmap()
4499 {
4500 if (m_pCacheBitmap)
4501 {
4502 m_pCacheBitmap->DeleteObject();
4503 delete m_pCacheBitmap;
4504 m_pCacheBitmap = nullptr;
4505 }
4506 }
4507
4508 void CBaseView::BuildMarkedWordArray()
4509 {
4510 int lineCount = GetLineCount();
4511 m_arMarkedWordLines.clear();
4512 m_arMarkedWordLines.reserve(lineCount);
4513 bool bDoit = !m_sMarkedWord.IsEmpty();
4514 for (int i = 0; i < lineCount; ++i)
4515 {
4516 if (bDoit)
4517 {
4518 CString line = GetLineChars(i);
4519
4520 if (!line.IsEmpty())
4521 {
4522 int found = 0;
4523 int nMarkStart = -1;
4524 while ((nMarkStart = line.Find(m_sMarkedWord, ++nMarkStart)) >= 0)
4525 {
4526 int nMarkEnd = nMarkStart + m_sMarkedWord.GetLength();
4527 ECharGroup eLeft = GetCharGroup(line, nMarkStart - 1);
4528 ECharGroup eStart = GetCharGroup(line, nMarkStart);
4529 if (eLeft != eStart)
4530 {
4531 ECharGroup eRight = GetCharGroup(line, nMarkEnd);
4532 ECharGroup eEnd = GetCharGroup(line, nMarkEnd - 1);
4533 if (eRight != eEnd)
4534 {
4535 found = 1;
4536 break;
4537 }
4538 }
4539 }
4540 m_arMarkedWordLines.push_back(found);
4541 }
4542 else
4543 m_arMarkedWordLines.push_back(0);
4544 }
4545 else
4546 m_arMarkedWordLines.push_back(0);
4547 }
4548 }
4549
4550 void CBaseView::BuildFindStringArray()
4551 {
4552 int lineCount = GetLineCount();
4553 m_arFindStringLines.clear();
4554 m_arFindStringLines.reserve(lineCount);
4555 bool bDoit = !m_sFindText.IsEmpty();
4556 int s = 0;
4557 int e = 0;
4558 for (int i = 0; i < lineCount; ++i)
4559 {
4560 if (bDoit)
4561 {
4562 CString line = GetLineChars(i);
4563
4564 if (!line.IsEmpty())
4565 {
4566 switch (m_pViewData->GetState(GetViewLineForScreen(i)))
4567 {
4568 case DIFFSTATE_EMPTY:
4569 m_arFindStringLines.push_back(0);
4570 break;
4571 case DIFFSTATE_UNKNOWN:
4572 case DIFFSTATE_NORMAL:
4573 case DIFFSTATE_FILTEREDDIFF:
4574 if (m_bLimitToDiff)
4575 {
4576 m_arFindStringLines.push_back(0);
4577 break;
4578 }
4579 case DIFFSTATE_REMOVED:
4580 case DIFFSTATE_REMOVEDWHITESPACE:
4581 case DIFFSTATE_ADDED:
4582 case DIFFSTATE_ADDEDWHITESPACE:
4583 case DIFFSTATE_WHITESPACE:
4584 case DIFFSTATE_WHITESPACE_DIFF:
4585 case DIFFSTATE_CONFLICTED:
4586 case DIFFSTATE_CONFLICTED_IGNORED:
4587 case DIFFSTATE_CONFLICTADDED:
4588 case DIFFSTATE_CONFLICTEMPTY:
4589 case DIFFSTATE_CONFLICTRESOLVED:
4590 case DIFFSTATE_IDENTICALREMOVED:
4591 case DIFFSTATE_IDENTICALADDED:
4592 case DIFFSTATE_THEIRSREMOVED:
4593 case DIFFSTATE_THEIRSADDED:
4594 case DIFFSTATE_YOURSREMOVED:
4595 case DIFFSTATE_YOURSADDED:
4596 case DIFFSTATE_EDITED:
4597 {
4598 if (!m_bMatchCase)
4599 line = line.MakeLower();
4600 s = 0;
4601 e = 0;
4602 int match = 0;
4603 while (StringFound(line, SearchNext, s, e))
4604 {
4605 match++;
4606 s = e;
4607 e = 0;
4608 }
4609 m_arFindStringLines.push_back(match);
4610 break;
4611 }
4612 default:
4613 m_arFindStringLines.push_back(0);
4614 }
4615 }
4616 else
4617 m_arFindStringLines.push_back(0);
4618 }
4619 else
4620 m_arFindStringLines.push_back(0);
4621 }
4622 UpdateLocator();
4623 }
4624
4625 bool CBaseView::GetInlineDiffPositions(int nViewLine, std::vector<inlineDiffPos>& positions)
4626 {
4627 if (!m_bShowInlineDiff)
4628 return false;
4629 if (m_pwndBottom && !(m_pwndBottom->IsHidden()))
4630 return false;
4631
4632 if (!m_pViewData || m_pViewData->GetCount() <= nViewLine)
4633 return false;
4634 const CString &sLine = m_pViewData->GetLine(nViewLine);
4635 if (sLine.IsEmpty())
4636 return false;
4637
4638 CheckOtherView();
4639 if (!m_pOtherViewData)
4640 return false;
4641
4642 const CString &sDiffLine = m_pOtherViewData->GetLine(nViewLine);
4643 if (sDiffLine.IsEmpty())
4644 return false;
4645
4646 svn_diff_t* diff = nullptr;
4647 auto pLine1 = (this == m_pwndLeft) ? &sLine : &sDiffLine;
4648 auto pLine2 = (this == m_pwndLeft) ? &sDiffLine : &sLine;
4649 m_svnlinediff.Diff(&diff, *pLine1, pLine1->GetLength(), *pLine2, pLine2->GetLength(), m_bInlineWordDiff);
4650 if (!diff || !SVNLineDiff::ShowInlineDiff(diff))
4651 return false;
4652
4653 size_t lineoffset = 0;
4654 size_t position = 0;
4655 while (diff)
4656 {
4657 if (this == m_pwndRight)
4658 {
4659 apr_off_t nTmp = diff->modified_length;
4660 diff->modified_length = diff->original_length;
4661 diff->original_length = nTmp;
4662
4663 nTmp = diff->modified_start;
4664 diff->modified_start = diff->original_start;
4665 diff->original_start = nTmp;
4666 }
4667 apr_off_t len = diff->original_length;
4668 size_t oldpos = position;
4669
4670 for (apr_off_t i = 0; i < len; ++i)
4671 {
4672 position += (this == m_pwndRight) ? m_svnlinediff.m_line2tokens[lineoffset].size() : m_svnlinediff.m_line1tokens[lineoffset].size();
4673 lineoffset++;
4674 }
4675
4676 if (diff->type == svn_diff__type_diff_modified)
4677 {
4678 inlineDiffPos p;
4679 p.start = oldpos;
4680 p.end = position;
4681 positions.push_back(p);
4682 }
4683
4684 diff = diff->next;
4685 }
4686
4687 return !positions.empty();
4688 }
4689
4690 void CBaseView::OnNavigateNextinlinediff()
4691 {
4692 int nX;
4693 if (GetNextInlineDiff(nX))
4694 {
4695 POINT ptCaretViewPos = GetCaretViewPosition();
4696 ptCaretViewPos.x = nX;
4697 SetCaretAndGoalViewPosition(ptCaretViewPos);
4698 m_ptSelectionViewPosOrigin = ptCaretViewPos;
4699 EnsureCaretVisible();
4700 }
4701 }
4702
4703 void CBaseView::OnNavigatePrevinlinediff()
4704 {
4705 int nX;
4706 if (GetPrevInlineDiff(nX))
4707 {
4708 POINT ptCaretViewPos = GetCaretViewPosition();
4709 ptCaretViewPos.x = nX;
4710 SetCaretAndGoalViewPosition(ptCaretViewPos);
4711 m_ptSelectionViewPosOrigin = ptCaretViewPos;
4712 EnsureCaretVisible();
4713 }
4714 }
4715
4716 bool CBaseView::HasNextInlineDiff()
4717 {
4718 int nPos;
4719 return GetNextInlineDiff(nPos);
4720 }
4721
4722 bool CBaseView::GetNextInlineDiff(int & nPos)
4723 {
4724 POINT ptCaretViewPos = GetCaretViewPosition();
4725 std::vector<inlineDiffPos> positions;
4726 if (GetInlineDiffPositions(ptCaretViewPos.y, positions))
4727 {
4728 for (auto it = positions.cbegin(); it != positions.cend(); ++it)
4729 {
4730 if (it->start > ptCaretViewPos.x)
4731 {
4732 nPos = (LONG)it->start;
4733 return true;
4734 }
4735 if (it->end > ptCaretViewPos.x)
4736 {
4737 nPos = (LONG)it->end;
4738 return true;
4739 }
4740 }
4741 }
4742 return false;
4743 }
4744
4745 bool CBaseView::HasPrevInlineDiff()
4746 {
4747 int nPos;
4748 return GetPrevInlineDiff(nPos);
4749 }
4750
4751 bool CBaseView::GetPrevInlineDiff(int & nPos)
4752 {
4753 POINT ptCaretViewPos = GetCaretViewPosition();
4754 std::vector<inlineDiffPos> positions;
4755 if (GetInlineDiffPositions(ptCaretViewPos.y, positions))
4756 {
4757 for (auto it = positions.crbegin(); it != positions.crend(); ++it)
4758 {
4759 if ( it->end < ptCaretViewPos.x)
4760 {
4761 nPos = (LONG)it->end;
4762 return true;
4763 }
4764 if ( it->start < ptCaretViewPos.x)
4765 {
4766 nPos = (LONG)it->start;
4767 return true;
4768 }
4769 }
4770 }
4771 return false;
4772 }
4773
4774 CBaseView * CBaseView::GetFirstGoodView()
4775 {
4776 if (IsViewGood(m_pwndLeft))
4777 return m_pwndLeft;
4778 if (IsViewGood(m_pwndRight))
4779 return m_pwndRight;
4780 if (IsViewGood(m_pwndBottom))
4781 return m_pwndBottom;
4782 return nullptr;
4783 }
4784
4785 void CBaseView::BuildAllScreen2ViewVector()
4786 {
4787 CBaseView * p_pwndView = GetFirstGoodView();
4788 if (p_pwndView)
4789 {
4790 m_Screen2View.ScheduleFullRebuild(p_pwndView->m_pViewData);
4791 }
4792 }
4793
4794 void CBaseView::BuildAllScreen2ViewVector(int nViewLine)
4795 {
4796 BuildAllScreen2ViewVector(nViewLine, nViewLine);
4797 }
4798
4799 void CBaseView::BuildAllScreen2ViewVector(int nFirstViewLine, int nLastViewLine)
4800 {
4801 CBaseView * p_pwndView = GetFirstGoodView();
4802 if (p_pwndView)
4803 {
4804 m_Screen2View.ScheduleRangeRebuild(p_pwndView->m_pViewData, nFirstViewLine, nLastViewLine);
4805 }
4806 }
4807
4808 void CBaseView::UpdateViewLineNumbers()
4809 {
4810 int nLineNumber = 0;
4811 int nViewLineCount = GetViewCount();
4812 for (int nViewLine = 0; nViewLine < nViewLineCount; nViewLine++)
4813 {
4814 int oldLine = (int)GetViewLineNumber(nViewLine);
4815 if (oldLine >= 0)
4816 SetViewLineNumber(nViewLine, nLineNumber++);
4817 }
4818 m_nDigits = 0;
4819 }
4820
4821 int CBaseView::CleanEmptyLines()
4822 {
4823 int nRemovedCount = 0;
4824 int nViewLineCount = GetViewCount();
4825 bool bCheckLeft = IsViewGood(m_pwndLeft);
4826 bool bCheckRight = IsViewGood(m_pwndRight);
4827 bool bCheckBottom = IsViewGood(m_pwndBottom);
4828 for (int nViewLine = 0; nViewLine < nViewLineCount; )
4829 {
4830 bool bAllEmpty = true;
4831 bAllEmpty &= !bCheckLeft || IsStateEmpty(m_pwndLeft->GetViewState(nViewLine));
4832 bAllEmpty &= !bCheckRight || IsStateEmpty(m_pwndRight->GetViewState(nViewLine));
4833 bAllEmpty &= !bCheckBottom || IsStateEmpty(m_pwndBottom->GetViewState(nViewLine));
4834 if (bAllEmpty)
4835 {
4836 if (bCheckLeft)
4837 {
4838 m_pwndLeft->RemoveViewData(nViewLine);
4839 }
4840 if (bCheckRight)
4841 {
4842 m_pwndRight->RemoveViewData(nViewLine);
4843 }
4844 if (bCheckBottom)
4845 {
4846 m_pwndBottom->RemoveViewData(nViewLine);
4847 }
4848 if (CUndo::GetInstance().IsGrouping()) // if use group undo -> ensure back adding goes in right (reversed) order
4849 {
4850 SaveUndoStep();
4851 }
4852 nViewLineCount--;
4853 nRemovedCount++;
4854 continue;
4855 }
4856 nViewLine++;
4857 }
4858 return nRemovedCount;
4859 }
4860
4861 int CBaseView::FindScreenLineForViewLine( int viewLine )
4862 {
4863 return m_Screen2View.FindScreenLineForViewLine(viewLine);
4864 }
4865
4866 int CBaseView::CountMultiLines( int nViewLine )
4867 {
4868 if (m_ScreenedViewLine.empty())
4869 return 0; // in case the view is completely empty
4870
4871 ASSERT(nViewLine < (int)m_ScreenedViewLine.size());
4872
4873 if (m_ScreenedViewLine[nViewLine].bSublinesSet)
4874 {
4875 return (int)m_ScreenedViewLine[nViewLine].SubLines.size();
4876 }
4877
4878 CString multiline = CStringUtils::WordWrap(m_pViewData->GetLine(nViewLine), GetScreenChars()-1, false, true, GetTabSize()); // GetMultiLine(nLine);
4879
4880 TScreenedViewLine oScreenedLine;
4881 // tokenize string
4882 int prevpos = 0;
4883 int pos = 0;
4884 while ((pos = multiline.Find('\n', pos)) >= 0)
4885 {
4886 oScreenedLine.SubLines.push_back(multiline.Mid(prevpos, pos-prevpos)); // WordWrap could return vector/list of lines instead of string
4887 pos++;
4888 prevpos = pos;
4889 }
4890 oScreenedLine.SubLines.push_back(multiline.Mid(prevpos));
4891 oScreenedLine.bSublinesSet = true;
4892 m_ScreenedViewLine[nViewLine] = oScreenedLine;
4893
4894 return CountMultiLines(nViewLine);
4895 }
4896
4897 /// prepare inline diff cache
4898 LineColors & CBaseView::GetLineColors(int nViewLine)
4899 {
4900 ASSERT(nViewLine < (int)m_ScreenedViewLine.size());
4901
4902 if (m_bWhitespaceInlineDiffs)
4903 {
4904 if (m_ScreenedViewLine[nViewLine].bLineColorsSetWhiteSpace)
4905 return m_ScreenedViewLine[nViewLine].lineColorsWhiteSpace;
4906 }
4907 else
4908 {
4909 if (m_ScreenedViewLine[nViewLine].bLineColorsSet)
4910 return m_ScreenedViewLine[nViewLine].lineColors;
4911 }
4912
4913 LineColors oLineColors;
4914 // set main line color
4915 COLORREF crBkgnd, crText;
4916 DiffStates diffState = m_pViewData->GetState(nViewLine);
4917 CDiffColors::GetInstance().GetColors(diffState, crBkgnd, crText);
4918 oLineColors.SetColor(0, crText, crBkgnd);
4919
4920 do {
4921 if (!m_bShowInlineDiff)
4922 break;
4923
4924 if (((diffState == DIFFSTATE_NORMAL) || (diffState == DIFFSTATE_FILTEREDDIFF)) && (!m_bWhitespaceInlineDiffs))
4925 break;
4926
4927 CString sLine = GetViewLineChars(nViewLine);
4928 if (sLine.IsEmpty())
4929 break;
4930 CString sDiffLine;
4931 if (!m_pOtherView)
4932 {
4933 switch (diffState)
4934 {
4935 case DIFFSTATE_ADDED:
4936 {
4937 if ((nViewLine > 0) && (m_pViewData->GetState(nViewLine - 1) == DIFFSTATE_REMOVED))
4938 sDiffLine = GetViewLineChars(nViewLine - 1);
4939 }
4940 break;
4941 case DIFFSTATE_REMOVED:
4942 {
4943 if (((nViewLine + 1) < m_pViewData->GetCount()) && (m_pViewData->GetState(nViewLine + 1) == DIFFSTATE_ADDED))
4944 sDiffLine = GetViewLineChars(nViewLine + 1);
4945 }
4946 break;
4947 }
4948 }
4949 else
4950 sDiffLine = m_pOtherView->GetViewLineChars(nViewLine);
4951 if (sDiffLine.IsEmpty())
4952 break;
4953
4954 svn_diff_t* diff = nullptr;
4955 if (sLine.GetLength() > (int)m_nInlineDiffMaxLineLength)
4956 break;
4957 auto pLine1 = (this == m_pwndLeft) ? &sLine : &sDiffLine;
4958 auto pLine2 = (this == m_pwndLeft) ? &sDiffLine : &sLine;
4959 m_svnlinediff.Diff(&diff, *pLine1, pLine1->GetLength(), *pLine2, pLine2->GetLength(), m_bInlineWordDiff);
4960 if (!diff || !SVNLineDiff::ShowInlineDiff(diff) || !diff->next)
4961 break;
4962
4963 int lineoffset = 0;
4964 int nTextStartOffset = 0;
4965 std::map<int, COLORREF> removedPositions;
4966 while (diff)
4967 {
4968 if (this == m_pwndRight)
4969 {
4970 apr_off_t nTmp = diff->modified_length;
4971 diff->modified_length = diff->original_length;
4972 diff->original_length = nTmp;
4973
4974 nTmp = diff->modified_start;
4975 diff->modified_start = diff->original_start;
4976 diff->original_start = nTmp;
4977 }
4978 apr_off_t len = diff->original_length;
4979
4980 size_t nTextLength = 0;
4981 for (int i = 0; i < len; ++i)
4982 {
4983 nTextLength += (this == m_pwndRight) ? m_svnlinediff.m_line2tokens[lineoffset].size() : m_svnlinediff.m_line1tokens[lineoffset].size();
4984 lineoffset++;
4985 }
4986 bool bInlineDiff = (diff->type == svn_diff__type_diff_modified);
4987
4988 CDiffColors::GetInstance().GetColors(diffState, crBkgnd, crText);
4989 if ((m_bShowInlineDiff)&&(bInlineDiff))
4990 {
4991 crBkgnd = InlineViewLineDiffColor(nViewLine);
4992 }
4993 else if (m_pOtherView)
4994 {
4995 crBkgnd = m_ModifiedBk;
4996 }
4997
4998 if (len < diff->modified_length)
4999 {
5000 removedPositions[nTextStartOffset] = m_InlineRemovedBk;
5001 }
5002 oLineColors.SetColor(nTextStartOffset, crText, crBkgnd);
5003
5004 nTextStartOffset += (int)nTextLength;
5005 diff = diff->next;
5006 }
5007 for (std::map<int, COLORREF>::const_iterator it = removedPositions.begin(); it != removedPositions.end(); ++it)
5008 {
5009 oLineColors.AddShotColor(it->first, it->second);
5010 }
5011 } while (false); // error catch
5012
5013 if (!m_bWhitespaceInlineDiffs)
5014 {
5015 m_ScreenedViewLine[nViewLine].lineColors = oLineColors;
5016 m_ScreenedViewLine[nViewLine].bLineColorsSet = true;
5017 }
5018 else
5019 {
5020 m_ScreenedViewLine[nViewLine].lineColorsWhiteSpace = oLineColors;
5021 m_ScreenedViewLine[nViewLine].bLineColorsSetWhiteSpace = true;
5022 }
5023
5024 return GetLineColors(nViewLine);
5025 }
5026
5027 void CBaseView::OnEditSelectall()
5028 {
5029 if (!m_pViewData)
5030 return;
5031 int nLastViewLine = m_pViewData->GetCount()-1;
5032 if (nLastViewLine < 0)
5033 return;
5034 SetupAllViewSelection(0, nLastViewLine);
5035
5036 CString sLine = GetViewLineChars(nLastViewLine);
5037 m_ptSelectionViewPosStart = SetupPoint(0, 0);
5038 m_ptSelectionViewPosEnd = SetupPoint(sLine.GetLength(), nLastViewLine);
5039 m_ptSelectionViewPosOrigin = SetupPoint(-1, -1);
5040
5041 UpdateWindow();
5042 }
5043
5044 void CBaseView::FilterWhitespaces(CString& first, CString& second)
5045 {
5046 FilterWhitespaces(first);
5047 FilterWhitespaces(second);
5048 }
5049
5050 void CBaseView::FilterWhitespaces(CString& line)
5051 {
5052 line.Remove(' ');
5053 line.Remove('\t');
5054 line.Remove('\r');
5055 line.Remove('\n');
5056 }
5057
5058 int CBaseView::GetButtonEventLineIndex(const POINT& point)
5059 {
5060 const int nLineFromTop = (point.y - HEADERHEIGHT) / GetLineHeight();
5061 int nEventLine = nLineFromTop + m_nTopLine;
5062 nEventLine--; //we need the index
5063 return nEventLine;
5064 }
5065
5066
5067 BOOL CBaseView::PreTranslateMessage(MSG* pMsg)
5068 {
5069 if (RelayTrippleClick(pMsg))
5070 return TRUE;
5071 return CView::PreTranslateMessage(pMsg);
5072 }
5073
5074
5075 void CBaseView::ResetUndoStep()
5076 {
5077 m_AllState.Clear();
5078 }
5079
5080 void CBaseView::SaveUndoStep()
5081 {
5082 if (!m_AllState.IsEmpty())
5083 {
5084 CUndo::GetInstance().AddState(m_AllState, GetCaretViewPosition());
5085 }
5086 ResetUndoStep();
5087 }
5088
5089 void CBaseView::InsertViewData( int index, const CString& sLine, DiffStates state, int linenumber, EOL ending, HIDESTATE hide, int movedline )
5090 {
5091 m_pState->addedlines.push_back(index);
5092 m_pViewData->InsertData(index, sLine, state, linenumber, ending, hide, movedline);
5093 }
5094
5095 void CBaseView::InsertViewData( int index, const viewdata& data )
5096 {
5097 m_pState->addedlines.push_back(index);
5098 m_pViewData->InsertData(index, data);
5099 }
5100
5101 void CBaseView::RemoveViewData( int index )
5102 {
5103 m_pState->removedlines[index] = m_pViewData->GetData(index);
5104 m_pViewData->RemoveData(index);
5105 }
5106
5107 void CBaseView::SetViewData( int index, const viewdata& data )
5108 {
5109 m_pState->replacedlines[index] = m_pViewData->GetData(index);
5110 m_pViewData->SetData(index, data);
5111 }
5112
5113 void CBaseView::SetViewState( int index, DiffStates state )
5114 {
5115 m_pState->linestates[index] = m_pViewData->GetState(index);
5116 m_pViewData->SetState(index, state);
5117 }
5118
5119 void CBaseView::SetViewLine( int index, const CString& sLine )
5120 {
5121 m_pState->difflines[index] = m_pViewData->GetLine(index);
5122 m_pViewData->SetLine(index, sLine);
5123 }
5124
5125 void CBaseView::SetViewLineNumber( int index, int linenumber )
5126 {
5127 int oldLineNumber = m_pViewData->GetLineNumber(index);
5128 if (oldLineNumber != linenumber) {
5129 m_pState->linelines[index] = oldLineNumber;
5130 m_pViewData->SetLineNumber(index, linenumber);
5131 }
5132 }
5133
5134 void CBaseView::SetViewLineEnding( int index, EOL ending )
5135 {
5136 m_pState->linesEOL[index] = m_pViewData->GetLineEnding(index);
5137 m_pViewData->SetLineEnding(index, ending);
5138 }
5139
5140 void CBaseView::SetViewMarked( int index, bool marked )
5141 {
5142 m_pState->markedlines[index] = m_pViewData->GetMarked(index);
5143 m_pViewData->SetMarked(index, marked);
5144 }
5145
5146
5147 BOOL CBaseView::GetViewSelection( int& start, int& end ) const
5148 {
5149 if (HasSelection())
5150 {
5151 start = m_nSelViewBlockStart;
5152 end = m_nSelViewBlockEnd;
5153 return true;
5154 }
5155 return false;
5156 }
5157
5158 int CBaseView::Screen2View::GetViewLineForScreen( int screenLine )
5159 {
5160 RebuildIfNecessary();
5161 if ((size() <= screenLine) || (screenLine < 0))
5162 return 0;
5163 return m_Screen2View[screenLine].nViewLine;
5164 }
5165
5166 int CBaseView::Screen2View::size()
5167 {
5168 RebuildIfNecessary();
5169 return (int)m_Screen2View.size();
5170 }
5171
5172 int CBaseView::Screen2View::GetSubLineOffset( int screenLine )
5173 {
5174 RebuildIfNecessary();
5175 if (size() <= screenLine)
5176 return 0;
5177 return m_Screen2View[screenLine].nViewSubLine;
5178 }
5179
5180 CBaseView::TScreenLineInfo CBaseView::Screen2View::GetScreenLineInfo( int screenLine )
5181 {
5182 RebuildIfNecessary();
5183 return m_Screen2View[screenLine];
5184 }
5185
5186 /**
5187 doing partial rebuild, whole screen2view vector is built, but uses ScreenedViewLine cache to do it faster
5188 */
5189 void CBaseView::Screen2View::RebuildIfNecessary()
5190 {
5191 if (!m_pViewData)
5192 return; // rebuild not necessary
5193
5194 FixScreenedCacheSize(m_pwndLeft);
5195 FixScreenedCacheSize(m_pwndRight);
5196 FixScreenedCacheSize(m_pwndBottom);
5197 if (!m_bFull)
5198 {
5199 for (auto it = m_RebuildRanges.cbegin(); it != m_RebuildRanges.cend(); ++it)
5200 {
5201 ResetScreenedViewLineCache(m_pwndLeft, *it);
5202 ResetScreenedViewLineCache(m_pwndRight, *it);
5203 ResetScreenedViewLineCache(m_pwndBottom, *it);
5204 }
5205 }
5206 else
5207 {
5208 ResetScreenedViewLineCache(m_pwndLeft);
5209 ResetScreenedViewLineCache(m_pwndRight);
5210 ResetScreenedViewLineCache(m_pwndBottom);
5211 }
5212 m_RebuildRanges.clear();
5213 m_bFull = false;
5214
5215 size_t OldSize = m_Screen2View.size();
5216 m_Screen2View.clear();
5217 m_Screen2View.reserve(OldSize); // guess same size
5218 for (int i = 0; i < m_pViewData->GetCount(); ++i)
5219 {
5220 if (m_pMainFrame->m_bCollapsed)
5221 {
5222 while ((i < m_pViewData->GetCount())&&(m_pViewData->GetHideState(i) == HIDESTATE_HIDDEN))
5223 ++i;
5224 if (!(i < m_pViewData->GetCount()))
5225 break;
5226 }
5227 TScreenLineInfo oLineInfo;
5228 oLineInfo.nViewLine = i;
5229 oLineInfo.nViewSubLine = -1; // no wrap
5230 if (m_pMainFrame->m_bWrapLines && !IsViewLineHidden(m_pViewData, i))
5231 {
5232 int nMaxLines = 0;
5233 if (IsLeftViewGood())
5234 nMaxLines = std::max<int>(nMaxLines, m_pwndLeft->CountMultiLines(i));
5235 if (IsRightViewGood())
5236 nMaxLines = std::max<int>(nMaxLines, m_pwndRight->CountMultiLines(i));
5237 if (IsBottomViewGood())
5238 nMaxLines = std::max<int>(nMaxLines, m_pwndBottom->CountMultiLines(i));
5239 for (int l = 0; l < (nMaxLines-1); ++l)
5240 {
5241 oLineInfo.nViewSubLine++;
5242 m_Screen2View.push_back(oLineInfo);
5243 }
5244 oLineInfo.nViewSubLine++;
5245 }
5246 m_Screen2View.push_back(oLineInfo);
5247 }
5248 m_pViewData = nullptr;
5249
5250 if (IsLeftViewGood())
5251 m_pwndLeft->BuildMarkedWordArray();
5252 if (IsRightViewGood())
5253 m_pwndRight->BuildMarkedWordArray();
5254 if (IsBottomViewGood())
5255 m_pwndBottom->BuildMarkedWordArray();
5256 UpdateLocator();
5257 RecalcAllVertScrollBars();
5258 RecalcAllHorzScrollBars();
5259 }
5260
5261 int CBaseView::Screen2View::FindScreenLineForViewLine( int viewLine )
5262 {
5263 RebuildIfNecessary();
5264
5265 int nScreenLineCount = (int)m_Screen2View.size();
5266
5267 int nPos = 0;
5268 if (nScreenLineCount>16)
5269 {
5270 // for enough long data search for last screen
5271 // with viewline less than one we are looking for
5272 // use approximate method (based on) binary search using asymmetric start point
5273 // in form 2**n (determined as MSB of length) to go around division and rounding;
5274 // this effectively looks for bit values from MSB to LSB
5275
5276 int nTestBit;
5277 //GetMostSignificantBitValue
5278 // note _BitScanReverse(&nTestBit, nScreenLineCount); can be used instead
5279 nTestBit = nScreenLineCount;
5280 nTestBit |= nTestBit>>1;
5281 nTestBit |= nTestBit>>2;
5282 nTestBit |= nTestBit>>4;
5283 nTestBit |= nTestBit>>8;
5284 nTestBit |= nTestBit>>16;
5285 nTestBit ^= (nTestBit>>1);
5286
5287 while (nTestBit)
5288 {
5289 int nTestPos = nPos | nTestBit;
5290 if (nTestPos < nScreenLineCount && m_Screen2View[nTestPos].nViewLine < viewLine)
5291 {
5292 nPos = nTestPos;
5293 }
5294 nTestBit >>= 1;
5295 }
5296 }
5297 while (nPos < nScreenLineCount && m_Screen2View[nPos].nViewLine < viewLine)
5298 {
5299 nPos++;
5300 }
5301
5302 return nPos;
5303 }
5304
5305 void CBaseView::Screen2View::ScheduleFullRebuild(CViewData * pViewData) {
5306 m_bFull = true;
5307
5308 m_pViewData = pViewData;
5309 }
5310
5311 void CBaseView::Screen2View::ScheduleRangeRebuild(CViewData * pViewData, int nFirstViewLine, int nLastViewLine)
5312 {
5313 if (m_bFull)
5314 return;
5315
5316 m_pViewData = pViewData;
5317
5318 TRebuildRange Range;
5319 Range.FirstViewLine=nFirstViewLine;
5320 Range.LastViewLine=nLastViewLine;
5321 m_RebuildRanges.push_back(Range);
5322 }
5323
5324 bool CBaseView::Screen2View::FixScreenedCacheSize(CBaseView* pwndView)
5325 {
5326 if (!IsViewGood(pwndView))
5327 {
5328 return false;
5329 }
5330 const int nOldSize = (int)pwndView->m_ScreenedViewLine.size();
5331 const int nViewCount = std::max<int>(pwndView->GetViewCount(), 0);
5332 if (nOldSize == nViewCount)
5333 {
5334 return false;
5335 }
5336 pwndView->m_ScreenedViewLine.resize(nViewCount);
5337 return true;
5338 }
5339
5340 bool CBaseView::Screen2View::ResetScreenedViewLineCache(CBaseView* pwndView) const
5341 {
5342 if (!IsViewGood(pwndView))
5343 {
5344 return false;
5345 }
5346 TRebuildRange Range={0, pwndView->GetViewCount()-1};
5347 ResetScreenedViewLineCache(pwndView, Range);
5348 return true;
5349 }
5350
5351 bool CBaseView::Screen2View::ResetScreenedViewLineCache(CBaseView* pwndView, const TRebuildRange& Range) const
5352 {
5353 if (!IsViewGood(pwndView))
5354 {
5355 return false;
5356 }
5357 if (Range.LastViewLine == -1)
5358 {
5359 return false;
5360 }
5361 ASSERT(Range.FirstViewLine >= 0);
5362 ASSERT(Range.LastViewLine < pwndView->GetViewCount());
5363 for (int i = Range.FirstViewLine; i <= Range.LastViewLine; i++)
5364 {
5365 pwndView->m_ScreenedViewLine[i].Clear();
5366 }
5367 return false;
5368 }
5369
5370 void CBaseView::WrapChanged()
5371 {
5372 m_nMaxLineLength = -1;
5373 m_nOffsetChar = 0;
5374 RecalcHorzScrollBar();
5375 }
5376
5377 void CBaseView::OnEditFind()
5378 {
5379 if (m_pFindDialog)
5380 return;
5381
5382 int id = 0;
5383 if (this == m_pwndLeft)
5384 id = 1;
5385 if (this == m_pwndRight)
5386 id = 2;
5387 if (this == m_pwndBottom)
5388 id = 3;
5389
5390 m_pFindDialog = new CFindDlg(this);
5391 m_pFindDialog->Create(this, id);
5392
5393 m_pFindDialog->SetFindString(HasTextSelection() ? GetSelectedText() : L"");
5394 m_pFindDialog->SetReadonly(m_bReadonly);
5395 }
5396
5397 LRESULT CBaseView::OnFindDialogMessage(WPARAM wParam, LPARAM /*lParam*/)
5398 {
5399 ASSERT(m_pFindDialog != nullptr);
5400
5401 if (m_pFindDialog->IsTerminating())
5402 {
5403 // invalidate the handle identifying the dialog box.
5404 m_pFindDialog = nullptr;
5405 return 0;
5406 }
5407
5408 if(m_pFindDialog->FindNext())
5409 {
5410 //read data from dialog
5411 m_sFindText = m_pFindDialog->GetFindString();
5412 m_bMatchCase = (m_pFindDialog->MatchCase() == TRUE);
5413 m_bLimitToDiff = m_pFindDialog->LimitToDiffs();
5414 m_bWholeWord = m_pFindDialog->WholeWord();
5415
5416 if (!m_bMatchCase)
5417 m_sFindText = m_sFindText.MakeLower();
5418
5419 BuildFindStringArray();
5420 if ((CFindDlg::FindType)wParam == CFindDlg::FindType::Find)
5421 {
5422 if (m_pFindDialog->SearchUp())
5423 OnEditFindprev();
5424 else
5425 OnEditFindnext();
5426 }
5427 else if ((CFindDlg::FindType)wParam == CFindDlg::FindType::Count)
5428 {
5429 size_t count = 0;
5430 for (size_t i = 0; i < m_arFindStringLines.size(); ++i)
5431 count += m_arFindStringLines[i];
5432 CString matches;
5433 matches.Format(IDS_FIND_COUNT, count);
5434 m_pFindDialog->SetStatusText(matches);
5435 }
5436 else if ((CFindDlg::FindType)wParam == CFindDlg::FindType::Replace)
5437 {
5438 if (!IsWritable())
5439 return 0;
5440 bool bFound = false;
5441 if (m_pFindDialog->SearchUp())
5442 bFound = Search(SearchPrevious, true, true, false);
5443 else
5444 bFound = Search(SearchNext, true, true, false);
5445 if (bFound)
5446 {
5447 CString sReplaceText = m_pFindDialog->GetReplaceString();
5448 CUndo::GetInstance().BeginGrouping();
5449 RemoveSelectedText();
5450 InsertText(sReplaceText);
5451 CUndo::GetInstance().EndGrouping();
5452 }
5453
5454 }
5455 else if ((CFindDlg::FindType)wParam == CFindDlg::FindType::ReplaceAll)
5456 {
5457 if (!IsWritable())
5458 return 0;
5459 bool bFound = false;
5460 int replaceCount = 0;
5461 POINT lastPoint = m_ptSelectionViewPosStart;
5462 m_ptSelectionViewPosStart.x = m_ptSelectionViewPosStart.y = 0;
5463 CUndo::GetInstance().BeginGrouping();
5464 do
5465 {
5466 bFound = Search(SearchNext, true, false, true);
5467 if (bFound)
5468 {
5469 CString sReplaceText = m_pFindDialog->GetReplaceString();
5470 RemoveSelectedText();
5471 InsertText(sReplaceText);
5472 ++replaceCount;
5473 }
5474 } while (bFound);
5475 CUndo::GetInstance().EndGrouping();
5476 if (replaceCount == 0)
5477 m_ptSelectionViewPosStart = lastPoint;
5478 CString message;
5479 message.Format(IDS_FIND_REPLACED, replaceCount);
5480 m_pFindDialog->SetStatusText(message, RGB(0, 0, 0));
5481 }
5482 }
5483
5484 return 0;
5485 }
5486
5487 void CBaseView::OnEditFindnextStart()
5488 {
5489 if (!m_pViewData)
5490 return;
5491 if (HasTextSelection())
5492 {
5493 m_sFindText = GetSelectedText();
5494 m_bMatchCase = false;
5495 m_bLimitToDiff = false;
5496 m_bWholeWord = false;
5497 m_sFindText = m_sFindText.MakeLower();
5498
5499 BuildFindStringArray();
5500 OnEditFindnext();
5501 }
5502 else
5503 {
5504 m_sFindText.Empty();
5505 BuildFindStringArray();
5506 }
5507 }
5508
5509 void CBaseView::OnEditFindprevStart()
5510 {
5511 if (!m_pViewData)
5512 return;
5513 if (HasTextSelection())
5514 {
5515 m_sFindText = GetSelectedText();
5516 m_bMatchCase = false;
5517 m_bLimitToDiff = false;
5518 m_bWholeWord = false;
5519 m_sFindText = m_sFindText.MakeLower();
5520
5521 BuildFindStringArray();
5522 OnEditFindprev();
5523 }
5524 else
5525 {
5526 m_sFindText.Empty();
5527 BuildFindStringArray();
5528 }
5529 }
5530
5531 bool CBaseView::StringFound(const CString& str, SearchDirection srchDir, int& start, int& end) const
5532 {
5533 if (srchDir == SearchPrevious)
5534 {
5535 int laststart = -1;
5536 int laststart2 = -1;
5537 do
5538 {
5539 laststart2 = laststart;
5540 laststart = str.Find(m_sFindText, laststart + 1);
5541 } while (laststart >= 0 && laststart < start);
5542 start = laststart2;
5543 }
5544 else
5545 start = str.Find(m_sFindText, start);
5546 end = start + m_sFindText.GetLength();
5547 bool bStringFound = (start >= 0);
5548 if (bStringFound && m_bWholeWord)
5549 {
5550 if (start)
5551 bStringFound = IsWordSeparator(str.Mid(start-1,1).GetAt(0));
5552
5553 if (bStringFound)
5554 {
5555 if (str.GetLength() > end)
5556 bStringFound = IsWordSeparator(str.Mid(end, 1).GetAt(0));
5557 }
5558 }
5559 return bStringFound;
5560 }
5561
5562 void CBaseView::OnEditFindprev()
5563 {
5564 Search(SearchPrevious, false, true, false);
5565 }
5566
5567 void CBaseView::OnEditFindnext()
5568 {
5569 Search(SearchNext, false, true, false);
5570 }
5571
5572 bool CBaseView::Search(SearchDirection srchDir, bool useStart, bool flashIfNotFound, bool stopEof)
5573 {
5574 if (m_sFindText.IsEmpty())
5575 return false;
5576 if(!m_pViewData)
5577 return false;
5578
5579 POINT start = useStart ? m_ptSelectionViewPosStart : m_ptSelectionViewPosEnd;
5580 POINT end;
5581 end.y = m_pViewData->GetCount()-1;
5582 if (end.y < 0)
5583 return false;
5584
5585 if (srchDir==SearchNext)
5586 end.x = GetViewLineLength(end.y);
5587 else
5588 {
5589 end.x = m_ptSelectionViewPosStart.x;
5590 start.x = 0;
5591 }
5592
5593 if (!HasTextSelection())
5594 {
5595 start.y = m_ptCaretViewPos.y;
5596 if (srchDir==SearchNext)
5597 start.x = m_ptCaretViewPos.x;
5598 else
5599 {
5600 start.x = 0;
5601 end.x = m_ptCaretViewPos.x;
5602 }
5603 }
5604 CString sSelectedText;
5605 int startline = -1;
5606 for (int nViewLine=start.y; ;srchDir==SearchNext ? nViewLine++ : nViewLine--)
5607 {
5608 if (nViewLine < 0)
5609 {
5610 if (stopEof)
5611 return false;
5612 nViewLine = m_pViewData->GetCount()-1;
5613 startline = start.y;
5614 if (flashIfNotFound)
5615 {
5616 if (m_pFindDialog)
5617 m_pFindDialog->SetStatusText(CString(MAKEINTRESOURCE(IDS_FIND_TOPREACHED)), RGB(63, 127, 47));
5618 m_pMainFrame->FlashWindowEx(FLASHW_ALL, 2, 100);
5619 }
5620 }
5621 if (nViewLine > end.y)
5622 {
5623 if (stopEof)
5624 return false;
5625 nViewLine = 0;
5626 startline = start.y;
5627 if (flashIfNotFound)
5628 {
5629 if (m_pFindDialog)
5630 m_pFindDialog->SetStatusText(CString(MAKEINTRESOURCE(IDS_FIND_BOTTOMREACHED)), RGB(63, 127, 47));
5631 m_pMainFrame->FlashWindowEx(FLASHW_ALL, 2, 100);
5632 }
5633 }
5634 switch (m_pViewData->GetState(nViewLine))
5635 {
5636 case DIFFSTATE_EMPTY:
5637 break;
5638 case DIFFSTATE_UNKNOWN:
5639 case DIFFSTATE_NORMAL:
5640 case DIFFSTATE_FILTEREDDIFF:
5641 if (m_bLimitToDiff)
5642 break;
5643 case DIFFSTATE_REMOVED:
5644 case DIFFSTATE_REMOVEDWHITESPACE:
5645 case DIFFSTATE_ADDED:
5646 case DIFFSTATE_ADDEDWHITESPACE:
5647 case DIFFSTATE_WHITESPACE:
5648 case DIFFSTATE_WHITESPACE_DIFF:
5649 case DIFFSTATE_CONFLICTED:
5650 case DIFFSTATE_CONFLICTED_IGNORED:
5651 case DIFFSTATE_CONFLICTADDED:
5652 case DIFFSTATE_CONFLICTEMPTY:
5653 case DIFFSTATE_CONFLICTRESOLVED:
5654 case DIFFSTATE_IDENTICALREMOVED:
5655 case DIFFSTATE_IDENTICALADDED:
5656 case DIFFSTATE_THEIRSREMOVED:
5657 case DIFFSTATE_THEIRSADDED:
5658 case DIFFSTATE_YOURSREMOVED:
5659 case DIFFSTATE_YOURSADDED:
5660 case DIFFSTATE_EDITED:
5661 {
5662 sSelectedText = GetViewLineChars(nViewLine);
5663 if (nViewLine == start.y && startline < 0)
5664 sSelectedText = srchDir == SearchNext ? sSelectedText.Mid(start.x) : sSelectedText.Left(end.x);
5665 if (!m_bMatchCase)
5666 sSelectedText = sSelectedText.MakeLower();
5667 int startfound = srchDir == SearchNext ? 0 : sSelectedText.GetLength();
5668 int endfound = 0;
5669 if (StringFound(sSelectedText, srchDir, startfound, endfound))
5670 {
5671 HighlightViewLines(nViewLine, nViewLine);
5672 m_ptSelectionViewPosStart.x = startfound;
5673 m_ptSelectionViewPosEnd.x = endfound;
5674 if (nViewLine == start.y && startline < 0)
5675 {
5676 m_ptSelectionViewPosStart.x += start.x;
5677 m_ptSelectionViewPosEnd.x += start.x;
5678 }
5679 m_ptSelectionViewPosEnd.x = m_ptSelectionViewPosStart.x + m_sFindText.GetLength();
5680 m_ptSelectionViewPosStart.y = nViewLine;
5681 m_ptSelectionViewPosEnd.y = nViewLine;
5682 m_ptCaretViewPos = m_ptSelectionViewPosStart;
5683 UpdateViewsCaretPosition();
5684 EnsureCaretVisible();
5685 Invalidate();
5686 return true;
5687 }
5688 }
5689 break;
5690 }
5691
5692 if (startline >= 0)
5693 {
5694 if (nViewLine == startline)
5695 {
5696 if (flashIfNotFound)
5697 {
5698 CString message;
5699 message.Format(IDS_FIND_NOTFOUND, (LPCTSTR)m_sFindText);
5700 if (m_pFindDialog)
5701 m_pFindDialog->SetStatusText(message, RGB(255, 0, 0));
5702 ::MessageBeep(0xFFFFFFFF);
5703 m_pMainFrame->FlashWindowEx(FLASHW_ALL, 3, 100);
5704 }
5705 break;
5706 }
5707 }
5708 }
5709 m_pMainFrame->m_nMoveMovesToIgnore = MOVESTOIGNORE;
5710 return false;
5711 }
5712
5713 CString CBaseView::GetSelectedText() const
5714 {
5715 CString sSelectedText;
5716 POINT start = m_ptSelectionViewPosStart;
5717 POINT end = m_ptSelectionViewPosEnd;
5718 if (!HasTextSelection())
5719 {
5720 if (!HasSelection())
5721 return sSelectedText;
5722 start.y = m_nSelViewBlockStart;
5723 start.x = 0;
5724 end.y = m_nSelViewBlockEnd;
5725 end.x = GetViewLineLength(m_nSelViewBlockEnd);
5726 }
5727 if (!m_pViewData)
5728 return sSelectedText;
5729 // first store the selected lines in one CString
5730 for (int nViewLine=start.y; nViewLine<=end.y; nViewLine++)
5731 {
5732 switch (m_pViewData->GetState(nViewLine))
5733 {
5734 case DIFFSTATE_EMPTY:
5735 break;
5736 case DIFFSTATE_UNKNOWN:
5737 case DIFFSTATE_NORMAL:
5738 case DIFFSTATE_REMOVED:
5739 case DIFFSTATE_REMOVEDWHITESPACE:
5740 case DIFFSTATE_ADDED:
5741 case DIFFSTATE_ADDEDWHITESPACE:
5742 case DIFFSTATE_WHITESPACE:
5743 case DIFFSTATE_WHITESPACE_DIFF:
5744 case DIFFSTATE_CONFLICTED:
5745 case DIFFSTATE_CONFLICTED_IGNORED:
5746 case DIFFSTATE_CONFLICTADDED:
5747 case DIFFSTATE_CONFLICTEMPTY:
5748 case DIFFSTATE_CONFLICTRESOLVED:
5749 case DIFFSTATE_IDENTICALREMOVED:
5750 case DIFFSTATE_IDENTICALADDED:
5751 case DIFFSTATE_THEIRSREMOVED:
5752 case DIFFSTATE_THEIRSADDED:
5753 case DIFFSTATE_YOURSREMOVED:
5754 case DIFFSTATE_YOURSADDED:
5755 case DIFFSTATE_EDITED:
5756 case DIFFSTATE_FILTEREDDIFF:
5757 sSelectedText += GetViewLineChars(nViewLine);
5758 sSelectedText += L"\r\n";
5759 break;
5760 }
5761 }
5762 // remove the non-selected chars from the first line, last line and last \r\n
5763 int nLeftCut = start.x;
5764 int nRightCut = GetViewLineChars(end.y).GetLength() - end.x + 2;
5765 sSelectedText = sSelectedText.Mid(nLeftCut, sSelectedText.GetLength()-nLeftCut-nRightCut);
5766 return sSelectedText;
5767 }
5768
5769 void CBaseView::CheckModifications(bool& hasMods, bool& hasConflicts, bool& hasWhitespaceMods, bool& hasFilteredMods)
5770 {
5771 hasMods = false;
5772 hasConflicts = false;
5773 hasWhitespaceMods = false;
5774 hasFilteredMods = false;
5775
5776 if (m_pViewData)
5777 {
5778 for (int i=0; i<m_pViewData->GetCount(); i++)
5779 {
5780 DiffStates state = m_pViewData->GetState(i);
5781 switch (state)
5782 {
5783 case DIFFSTATE_ADDED:
5784 case DIFFSTATE_IDENTICALADDED:
5785 case DIFFSTATE_THEIRSADDED:
5786 case DIFFSTATE_YOURSADDED:
5787 case DIFFSTATE_CONFLICTADDED:
5788 case DIFFSTATE_IDENTICALREMOVED:
5789 case DIFFSTATE_REMOVED:
5790 case DIFFSTATE_THEIRSREMOVED:
5791 case DIFFSTATE_YOURSREMOVED:
5792 case DIFFSTATE_EMPTY:
5793 hasMods = true;
5794 break;
5795 case DIFFSTATE_CONFLICTED:
5796 case DIFFSTATE_CONFLICTED_IGNORED:
5797 hasConflicts = true;
5798 break;
5799 case DIFFSTATE_REMOVEDWHITESPACE:
5800 case DIFFSTATE_ADDEDWHITESPACE:
5801 case DIFFSTATE_WHITESPACE:
5802 case DIFFSTATE_WHITESPACE_DIFF:
5803 hasWhitespaceMods = true;
5804 break;
5805 case DIFFSTATE_FILTEREDDIFF:
5806 hasFilteredMods = true;
5807 break;
5808 }
5809 }
5810 }
5811 }
5812
5813 void CBaseView::OnEditGotoline()
5814 {
5815 if (!m_pViewData)
5816 return;
5817 // find the last and first line number
5818 int nViewLineCount = m_pViewData->GetCount();
5819
5820 int nLastLineNumber = DIFF_EMPTYLINENUMBER;
5821 for (int nViewLine=nViewLineCount-1; nViewLine>=0; --nViewLine)
5822 {
5823 nLastLineNumber = m_pViewData->GetLineNumber(nViewLine);
5824 if (nLastLineNumber!=DIFF_EMPTYLINENUMBER)
5825 {
5826 break;
5827 }
5828 }
5829 if (nLastLineNumber==DIFF_EMPTYLINENUMBER || nLastLineNumber==0) // not numbered line foud or last one is first
5830 {
5831 return;
5832 }
5833 nLastLineNumber++;
5834 int nFirstLineNumber=1; // first is always 1
5835
5836 CString sText;
5837 sText.Format(IDS_GOTOLINE, nFirstLineNumber, nLastLineNumber);
5838
5839 CGotoLineDlg dlg(this);
5840 dlg.SetLabel(sText);
5841 dlg.SetLimits(nFirstLineNumber, nLastLineNumber);
5842 if (dlg.DoModal() == IDOK)
5843 {
5844 for (int nViewLine = 0; nViewLine < nViewLineCount; ++nViewLine)
5845 {
5846 if ((m_pViewData->GetLineNumber(nViewLine)+1) == dlg.GetLineNumber())
5847 {
5848 HighlightViewLines(nViewLine, nViewLine);
5849 return;
5850 }
5851 }
5852 }
5853 }
5854
5855 void CBaseView::OnToggleReadonly()
5856 {
5857 if (IsReadonlyChangable()) {
5858 SetWritable(IsReadonly());
5859 }
5860 }
5861
5862 int CBaseView::SaveFile(int nFlags)
5863 {
5864 Invalidate();
5865 if (m_pViewData && m_pWorkingFile)
5866 {
5867 CFileTextLines file;
5868 m_SaveParams.m_LineEndings = m_lineendings;
5869 m_SaveParams.m_UnicodeType = m_texttype;
5870 file.SetSaveParams(m_SaveParams);
5871
5872 for (int i=0; i<m_pViewData->GetCount(); i++)
5873 {
5874 //only copy non-removed lines
5875 DiffStates state = m_pViewData->GetState(i);
5876 switch (state)
5877 {
5878 case DIFFSTATE_CONFLICTED:
5879 case DIFFSTATE_CONFLICTED_IGNORED:
5880 {
5881 int first = i;
5882 int last = i;
5883 do
5884 {
5885 last++;
5886 } while((last<m_pViewData->GetCount()) && ((m_pViewData->GetState(last)==DIFFSTATE_CONFLICTED)||(m_pViewData->GetState(last)==DIFFSTATE_CONFLICTED_IGNORED)));
5887 file.Add(L"<<<<<<< .mine", EOL_NOENDING);
5888 for (int j=first; j<last; j++)
5889 {
5890 file.Add(m_pwndRight->m_pViewData->GetLine(j), m_pwndRight->m_pViewData->GetLineEnding(j));
5891 }
5892 file.Add(L"=======", EOL_NOENDING);
5893 for (int j=first; j<last; j++)
5894 {
5895 file.Add(m_pwndLeft->m_pViewData->GetLine(j), m_pwndLeft->m_pViewData->GetLineEnding(j));
5896 }
5897 file.Add(L">>>>>>> .theirs", EOL_NOENDING);
5898 i = last-1;
5899 }
5900 break;
5901 case DIFFSTATE_EMPTY:
5902 break;
5903 case DIFFSTATE_CONFLICTEMPTY:
5904 case DIFFSTATE_IDENTICALREMOVED:
5905 case DIFFSTATE_REMOVED:
5906 case DIFFSTATE_THEIRSREMOVED:
5907 case DIFFSTATE_YOURSREMOVED:
5908 case DIFFSTATE_CONFLICTRESOLVEDEMPTY:
5909 if ((nFlags&SAVE_REMOVEDLINES) == 0)
5910 {
5911 // do not save removed lines
5912 break;
5913 }
5914 default:
5915 file.Add(m_pViewData->GetLine(i), m_pViewData->GetLineEnding(i));
5916 break;
5917 }
5918 }
5919 CString filename = m_pWorkingFile->GetFilename();
5920 if (m_pWorkingFile->IsReadonly())
5921 if (!CCommonAppUtils::FileOpenSave(filename, nullptr, IDS_SAVEASTITLE, IDS_COMMONFILEFILTER, false, m_hWnd))
5922 return -1;
5923 if (!file.Save(filename))
5924 {
5925 ::MessageBox(m_hWnd, file.GetErrorString(), L"TortoiseGitMerge", MB_ICONERROR);
5926 return -1;
5927 }
5928 m_pWorkingFile->SetFileName(filename);
5929 m_pWorkingFile->StoreFileAttributes();
5930 // m_dlgFilePatches.SetFileStatusAsPatched(sFilePath);
5931 SetModified(FALSE);
5932 CUndo::GetInstance().MarkAsOriginalState(
5933 this == m_pwndLeft,
5934 this == m_pwndRight,
5935 this == m_pwndBottom);
5936 if (file.GetCount() == 1 && file.GetAt(0).IsEmpty() && file.GetLineEnding(0) == EOL_NOENDING)
5937 return 0;
5938 return file.GetCount();
5939 }
5940 return 1;
5941 }
5942
5943
5944 int CBaseView::SaveFileTo(CString sFileName, int nFlags)
5945 {
5946 if (m_pWorkingFile)
5947 {
5948 m_pWorkingFile->SetFileName(sFileName);
5949 return SaveFile(nFlags);
5950 }
5951 return -1;
5952 }
5953
5954
5955 EOL CBaseView::GetLineEndings()
5956 {
5957 return GetLineEndings(GetWhitecharsProperties().HasMixedEols);
5958 }
5959
5960 EOL CBaseView::GetLineEndings(bool bHasMixedEols)
5961 {
5962 if (bHasMixedEols)
5963 {
5964 return EOL_AUTOLINE; // mixed eols - hack value
5965 }
5966 if (m_lineendings == EOL_AUTOLINE)
5967 {
5968 return EOL_CRLF;
5969 }
5970 return m_lineendings;
5971 }
5972
5973 void CBaseView::ReplaceLineEndings(EOL eEol)
5974 {
5975 if (eEol == EOL_AUTOLINE)
5976 {
5977 return;
5978 }
5979 // set AUTOLINE
5980 m_lineendings = eEol;
5981 // replace all set EOLs
5982 // TODO store line endings and lineendings in undo
5983 //CUndo::BeginGrouping();
5984 for (int i = 0; i < GetViewCount(); ++i)
5985 {
5986 if (IsLineEmpty(i))
5987 {
5988 continue;
5989 }
5990 EOL eLineEol = GetViewLineEnding(i);
5991 if (eLineEol == EOL_AUTOLINE || eLineEol == EOL_NOENDING || eLineEol == m_lineendings)
5992 {
5993 continue;
5994 }
5995 SetViewLineEnding(i, eEol);
5996 }
5997 //CUndo::EndGrouping();
5998 //CUndo::saveundostep;
5999 DocumentUpdated();
6000 SetModified();
6001 }
6002
6003 void CBaseView::SetLineEndingStyle(EOL eEol)
6004 {
6005 m_lineendings = eEol;
6006 }
6007
6008 void CBaseView::SetTextType(CFileTextLines::UnicodeType eTextType)
6009 {
6010 if (m_texttype == eTextType)
6011 {
6012 return;
6013 }
6014 m_texttype = eTextType;
6015 DocumentUpdated();
6016 SetModified();
6017 }
6018
6019 void CBaseView::AskUserForNewLineEndingsAndTextType(int nTextId)
6020 {
6021 if (IsReadonly())
6022 return; // nothing to be changed in read-only view
6023 CEncodingDlg dlg;
6024 dlg.view.LoadString(nTextId);
6025 dlg.texttype = m_texttype;
6026 dlg.lineendings = GetLineEndings();
6027 if (dlg.DoModal() != IDOK)
6028 return;
6029 SetTextType(dlg.texttype);
6030 ReplaceLineEndings(dlg.lineendings);
6031 }
6032
6033 /**
6034 Replaces lines from source view to this
6035 */
6036 void CBaseView::UseViewBlock(CBaseView * pwndView, int nFirstViewLine, int nLastViewLine, std::function<bool(int)> fnSkip)
6037 {
6038 if (!IsViewGood(pwndView))
6039 return;
6040 if (!IsWritable())
6041 return;
6042 CUndo::GetInstance().BeginGrouping();
6043
6044 for (int viewLine = nFirstViewLine; viewLine <= nLastViewLine; viewLine++)
6045 {
6046 bool skip = fnSkip(viewLine);
6047 if (skip)
6048 {
6049 if (GetViewMarked(viewLine))
6050 SetViewMarked(viewLine, false);
6051 continue;
6052 }
6053 viewdata line = pwndView->GetViewData(viewLine);
6054 if (line.ending != EOL_NOENDING)
6055 line.ending = m_lineendings;
6056 switch (line.state)
6057 {
6058 case DIFFSTATE_CONFLICTEMPTY:
6059 case DIFFSTATE_UNKNOWN:
6060 line.state = DIFFSTATE_EMPTY;
6061 case DIFFSTATE_EMPTY:
6062 break;
6063 case DIFFSTATE_ADDED:
6064 case DIFFSTATE_CONFLICTADDED:
6065 case DIFFSTATE_CONFLICTED:
6066 case DIFFSTATE_CONFLICTED_IGNORED:
6067 case DIFFSTATE_IDENTICALADDED:
6068 case DIFFSTATE_THEIRSADDED:
6069 case DIFFSTATE_YOURSADDED:
6070 case DIFFSTATE_IDENTICALREMOVED:
6071 case DIFFSTATE_REMOVED:
6072 case DIFFSTATE_THEIRSREMOVED:
6073 case DIFFSTATE_YOURSREMOVED:
6074 pwndView->SetViewState(viewLine, DIFFSTATE_NORMAL);
6075 line.state = DIFFSTATE_NORMAL;
6076 case DIFFSTATE_NORMAL:
6077 break;
6078 default:
6079 break;
6080 }
6081 bool marked = GetViewMarked(viewLine);
6082 SetViewData(viewLine, line);
6083 if (marked)
6084 SetViewMarked(viewLine, false);
6085 if ((m_texttype == UnicodeType::ASCII) && (pwndView->GetTextType() != UnicodeType::ASCII))
6086 {
6087 // if this view is in ASCII and the other is not, we have to make sure that
6088 // the text we copy from the other view can actually be saved in ASCII encoding.
6089 // if not, we have to change this views encoding to the same encoding as the other view
6090 BOOL useDefault = FALSE;
6091 WideCharToMultiByte(CP_ACP, WC_NO_BEST_FIT_CHARS, line.sLine, -1, nullptr, 0, 0, &useDefault);
6092 if (useDefault) // a default char is required, so the char can not be saved as ASCII
6093 SetTextType(pwndView->GetTextType());
6094 }
6095 }
6096 // normal lines is mostly same but may differ in EOL so any copied line change view state to modified
6097 // TODO: check if copied line is same as original one set modified only when differ
6098 SetModified();
6099 SaveUndoStep();
6100
6101 int nRemovedLines = CleanEmptyLines();
6102 SaveUndoStep();
6103 //VerifyEols();
6104 // make sure all non empty line have EOL set but last
6105 // wrong can be last copied line(have eol, but no line under),
6106 // or old last line (line before copied block missing eol, but have line under)
6107 // we'll check all lines to be sure
6108 int nLine = GetViewCount();
6109 // check last line have no EOL set
6110 while (--nLine>=0)
6111 {
6112 if (!IsViewLineEmpty(nLine))
6113 {
6114 if (GetViewLineEnding(nLine) != EOL_NOENDING)
6115 {
6116 // we added non last line into empty block on the end (or should we remove eol from this one ?)
6117 // so next line is empty
6118 ASSERT(IsViewLineEmpty(nLine+1));
6119 // and we can turn it to normal empty line
6120 SetViewData(nLine+1, viewdata(CString(), DIFFSTATE_ADDED, 1, EOL_NOENDING, HIDESTATE_SHOWN));
6121 }
6122 break;
6123 }
6124 }
6125 // check all (nonlast) line have EOL set
6126 while (--nLine>=0)
6127 {
6128 if (!IsViewLineEmpty(nLine))
6129 {
6130 if (GetViewLineEnding(nLine) == EOL_NOENDING)
6131 {
6132 SetViewLineEnding(nLine, m_lineendings);
6133 // in theory there should be only one line needing fix, but most of time we get over all anyway
6134 // break;
6135 }
6136 }
6137 }
6138 SaveUndoStep();
6139 UpdateViewLineNumbers();
6140 SaveUndoStep();
6141
6142 CUndo::GetInstance().EndGrouping();
6143
6144 if (nRemovedLines!=0)
6145 {
6146 // some lines are gone update selection
6147 ClearSelection();
6148 SetupAllViewSelection(nFirstViewLine, nLastViewLine - nRemovedLines);
6149 }
6150 BuildAllScreen2ViewVector();
6151 pwndView->Invalidate();
6152 RefreshViews();
6153 }
6154
6155 void CBaseView::MarkBlock(bool marked, int nFirstViewLine, int nLastViewLine)
6156 {
6157 if (!IsWritable())
6158 return;
6159 CUndo::GetInstance().BeginGrouping();
6160
6161 for (int viewLine = nFirstViewLine; viewLine <= nLastViewLine; viewLine++)
6162 SetViewMarked(viewLine, marked);
6163
6164 SetModified();
6165 SaveUndoStep();
6166 CUndo::GetInstance().EndGrouping();
6167
6168 BuildAllScreen2ViewVector();
6169 Invalidate();
6170 RefreshViews();
6171 }
6172
6173 void CBaseView::LeaveOnlyMarkedBlocks(CBaseView *pwndView)
6174 {
6175 auto fn = [this](int viewLine) -> bool { return GetViewMarked(viewLine) || GetViewState(viewLine) == DIFFSTATE_EDITED; };
6176 UseViewBlock(pwndView, 0, GetViewCount() - 1, fn);
6177 }
6178
6179 void CBaseView::UseViewFileOfMarked(CBaseView *pwndView)
6180 {
6181 auto fn = [this](int viewLine) -> bool { return !GetViewMarked(viewLine) || GetViewState(viewLine) == DIFFSTATE_EDITED; };
6182 UseViewBlock(pwndView, 0, GetViewCount() - 1, fn);
6183 }
6184
6185 void CBaseView::UseViewFileExceptEdited(CBaseView *pwndView)
6186 {
6187 auto fn = [this](int viewLine) -> bool { return GetViewState(viewLine) == DIFFSTATE_EDITED; };
6188 UseViewBlock(pwndView, 0, GetViewCount() - 1, fn);
6189 }
6190
6191 int CBaseView::GetIndentCharsForLine(int x, int y)
6192 {
6193 const int maxGuessLine = 100;
6194 int nTabMode = -1;
6195 const CString& line = GetViewLine(y);
6196 if (m_nTabMode & TABMODE_SMARTINDENT)
6197 {
6198 // if the line contains one tab, use tabs
6199 // we can not test for spaces, since even if tabs are used,
6200 // spaces are used in a tabified file for alignment.
6201 if (line.Find(L'\t') >= 0)
6202 nTabMode = 0; // use tabs
6203 else if (line.GetLength() > m_nTabSize)
6204 nTabMode = 1; // use spaces
6205
6206 if (m_nTabMode & TABMODE_SMARTINDENT)
6207 {
6208 // detect lines nearby
6209 for (int i = y - 1, j = y + 1; nTabMode == -1; --i, ++j)
6210 {
6211 bool above = i > 0 && i >= y - maxGuessLine;
6212 bool below = j < GetViewCount() && j <= y + maxGuessLine;
6213 if (!(above || below))
6214 break;
6215 auto ac = GetViewLine(i);
6216 auto bc = GetViewLine(j);
6217 if ((ac.Find(L'\t') >= 0) || (bc.Find(L'\t') >= 0))
6218 {
6219 nTabMode = 0;
6220 break;
6221 }
6222 else if ((ac.GetLength() > m_nTabSize) && (bc.GetLength() > m_nTabSize))
6223 {
6224 nTabMode = 1;
6225 break;
6226 }
6227 }
6228 }
6229 }
6230 else
6231 nTabMode = m_nTabMode & TABMODE_USESPACES;
6232
6233 if (nTabMode > 0)
6234 {
6235 // use spaces
6236 x = CountExpandedChars(line, x);
6237 return (m_nTabSize - (x % m_nTabSize));
6238 }
6239
6240 // use tab
6241 return 0;
6242 }
6243
6244 void CBaseView::AddIndentationForSelectedBlock()
6245 {
6246 bool bModified = false;
6247 for (int nViewLine = m_ptSelectionViewPosStart.y; nViewLine <= m_ptSelectionViewPosEnd.y; nViewLine++)
6248 {
6249 // skip the line if no character is selected in the last selected line
6250 if (nViewLine == m_ptSelectionViewPosEnd.y && m_ptSelectionViewPosEnd.x == 0)
6251 {
6252 continue;
6253 }
6254 // skip empty lines
6255 if (IsLineEmpty(nViewLine))
6256 {
6257 continue;
6258 }
6259 const CString &sLine = GetViewLine(nViewLine);
6260 CString sTemp = sLine;
6261 if (sTemp.Trim().IsEmpty())
6262 {
6263 // skip empty and whitechar only lines
6264 continue;
6265 }
6266 // add tab to line start (alternatively m_nTabSize spaces can be used)
6267 CString tabStr;
6268 int indentChars = GetIndentCharsForLine(0, nViewLine);
6269 tabStr = indentChars > 0 ? CString(L' ', indentChars) : L"\t";
6270 SetViewLine(nViewLine, tabStr + sLine);
6271 bModified = true;
6272 }
6273 if (bModified)
6274 {
6275 SetModified();
6276 SaveUndoStep();
6277 BuildAllScreen2ViewVector();
6278 }
6279 }
6280
6281 void CBaseView::RemoveIndentationForSelectedBlock()
6282 {
6283 bool bModified = false;
6284 for (int nViewLine = m_ptSelectionViewPosStart.y; nViewLine <= m_ptSelectionViewPosEnd.y; nViewLine++)
6285 {
6286 // skip the line if no character is selected in the last selected line
6287 if (nViewLine == m_ptSelectionViewPosEnd.y && m_ptSelectionViewPosEnd.x == 0)
6288 {
6289 continue;
6290 }
6291 // skip empty lines
6292 if (IsLineEmpty(nViewLine))
6293 {
6294 continue;
6295 }
6296 CString sLine = GetViewLine(nViewLine);
6297 // remove up to n spaces from line start
6298 // and one tab (if less then n spaces was removed)
6299 int nPos = 0;
6300 while (nPos<m_nTabSize)
6301 {
6302 switch (sLine[nPos])
6303 {
6304 case ' ':
6305 nPos++;
6306 continue;
6307 case '\t':
6308 nPos++;
6309 }
6310 break;
6311 }
6312 if (nPos>0)
6313 {
6314 sLine.Delete(0, nPos);
6315 SetViewLine(nViewLine, sLine);
6316 bModified = true;
6317 }
6318 }
6319 if (bModified)
6320 {
6321 SetModified();
6322 SaveUndoStep();
6323 BuildAllScreen2ViewVector();
6324 }
6325 }
6326
6327 /**
6328 there are two possible versions
6329 - convert tabs to spaces only in front of text (implemented)
6330 - convert all tabs to spaces
6331 */
6332 void CBaseView::ConvertTabToSpaces()
6333 {
6334 bool bModified = false;
6335 for (int nViewLine = 0; nViewLine < GetViewCount(); nViewLine++)
6336 {
6337 if (IsLineEmpty(nViewLine))
6338 {
6339 continue;
6340 }
6341 const CString &sLine = GetViewLine(nViewLine);
6342 bool bTabToConvertFound = false;
6343 int nPosIn = 0;
6344 int nPosOut = 0;
6345 while (nPosIn<sLine.GetLength())
6346 {
6347 switch (sLine[nPosIn])
6348 {
6349 case ' ':
6350 nPosIn++;
6351 nPosOut++;
6352 continue;
6353 case '\t':
6354 nPosIn++;
6355 bTabToConvertFound = true;
6356 nPosOut = (nPosOut+m_nTabSize) - nPosOut%m_nTabSize;
6357 continue;
6358 }
6359 break;
6360 }
6361 if (bTabToConvertFound)
6362 {
6363 CString sLineNew = sLine;
6364 sLineNew.Delete(0, nPosIn);
6365 sLineNew = CString(' ', nPosOut) + sLineNew;
6366 SetViewLine(nViewLine, sLineNew);
6367 bModified = true;
6368 }
6369 }
6370 if (bModified)
6371 {
6372 SetModified();
6373 SaveUndoStep();
6374 BuildAllScreen2ViewVector();
6375 }
6376 }
6377
6378 /**
6379 there are two possible version
6380 - convert spaces to tabs only in front of text (implemented)
6381 - convert all spaces to tabs
6382 */
6383 void CBaseView::Tabularize()
6384 {
6385 bool bModified = false;
6386 for (int nViewLine = 0; nViewLine < GetViewCount(); nViewLine++)
6387 {
6388 if (IsLineEmpty(nViewLine))
6389 {
6390 continue;
6391 }
6392 const CString &sLine = GetViewLine(nViewLine);
6393 int nDel = 0;
6394 int nTabCount = 0; // total tabs to be used
6395 int nSpaceCount = 0; // number of spaces in tab size run
6396 int nPos = 0;
6397 while (nPos<sLine.GetLength())
6398 {
6399 switch (sLine[nPos++])
6400 {
6401 case ' ':
6402 //bSpace = true;
6403 if (++nSpaceCount < m_nTabSize)
6404 {
6405 continue;
6406 }
6407 case '\t':
6408 nTabCount++;
6409 nSpaceCount = 0;
6410 nDel = nPos;
6411 continue;
6412 }
6413 break;
6414 }
6415 if (nDel > 0)
6416 {
6417 CString sLineNew = sLine;
6418 sLineNew.Delete(0, nDel);
6419 sLineNew = CString('\t', nTabCount) + sLineNew;
6420 if (sLine!=sLineNew)
6421 {
6422 SetViewLine(nViewLine, sLineNew);
6423 bModified = true;
6424 }
6425 }
6426 }
6427 if (bModified)
6428 {
6429 SetModified();
6430 SaveUndoStep();
6431 BuildAllScreen2ViewVector();
6432 }
6433 }
6434
6435 void CBaseView::RemoveTrailWhiteChars()
6436 {
6437 bool bModified = false;
6438 for (int nViewLine = 0; nViewLine < GetViewCount(); nViewLine++)
6439 {
6440 if (IsLineEmpty(nViewLine))
6441 {
6442 continue;
6443 }
6444 const CString &sLine = GetViewLine(nViewLine);
6445 CString sLineNew = sLine;
6446 sLineNew.TrimRight();
6447 if (sLine.GetLength()!=sLineNew.GetLength())
6448 {
6449 SetViewLine(nViewLine, sLineNew);
6450 bModified = true;
6451 }
6452 }
6453 if (bModified)
6454 {
6455 SetModified();
6456 SaveUndoStep();
6457 BuildAllScreen2ViewVector();
6458 }
6459 }
6460
6461 CBaseView::TWhitecharsProperties CBaseView::GetWhitecharsProperties()
6462 {
6463 if (GetViewCount()>10000)
6464 {
6465 // 10k lines is enough to check
6466 TWhitecharsProperties oRet = {true, true, true, true};
6467 return oRet;
6468 }
6469 TWhitecharsProperties oRet = {};
6470 for (int nViewLine = 0; nViewLine < GetViewCount(); nViewLine++)
6471 {
6472 if (IsLineEmpty(nViewLine))
6473 {
6474 continue;
6475 }
6476 const CString &sLine = GetViewLine(nViewLine);
6477 if (sLine.IsEmpty())
6478 {
6479 continue;
6480 }
6481 // check leading whites for convertible tabs and spaces
6482 int nPos = 0;
6483 int nSpaceCount = 0; // number of spaces in tab size run
6484 while (nPos<sLine.GetLength() && (!oRet.HasSpacesToConvert || !oRet.HasTabsToConvert))
6485 {
6486 switch (sLine[nPos++])
6487 {
6488 case ' ':
6489 if (++nSpaceCount >= m_nTabSize)
6490 {
6491 oRet.HasSpacesToConvert = true;
6492 }
6493 continue;
6494 case '\t':
6495 oRet.HasTabsToConvert = true;
6496 if (nSpaceCount!=0)
6497 {
6498 oRet.HasSpacesToConvert = true;
6499 }
6500 continue;
6501 }
6502 break;
6503 }
6504
6505 // check trailing whites for removable chars
6506 switch (sLine[sLine.GetLength()-1])
6507 {
6508 case ' ':
6509 case '\t':
6510 oRet.HasTrailWhiteChars = true;
6511 }
6512
6513 // check EOLs
6514 EOL eLineEol = GetViewLineEnding(nViewLine);
6515 if (!oRet.HasMixedEols && (eLineEol != m_lineendings) && (eLineEol != EOL_AUTOLINE) && (eLineEol != EOL_NOENDING))
6516 {
6517 oRet.HasMixedEols = true;
6518 }
6519 }
6520 return oRet;
6521 }
6522
6523 void CBaseView::InsertText(const CString& sText)
6524 {
6525 ResetUndoStep();
6526
6527 POINT ptCaretViewPos = GetCaretViewPosition();
6528 int nLeft = ptCaretViewPos.x;
6529 int nViewLine = ptCaretViewPos.y;
6530
6531 if ((nViewLine == 0) && (GetViewCount() == 0))
6532 OnChar(VK_RETURN, 0, 0);
6533
6534 std::vector<CString> lines;
6535 int nStart = 0;
6536 int nEolPos = 0;
6537 while ((nEolPos = sText.Find('\r', nEolPos)) >= 0)
6538 {
6539 CString sLine = sText.Mid(nStart, nEolPos - nStart);
6540 lines.push_back(sLine);
6541 nEolPos++;
6542 nStart = nEolPos;
6543 }
6544 CString sLine = sText.Mid(nStart);
6545 lines.push_back(sLine);
6546
6547 int nLinesToPaste = (int)lines.size();
6548 if (nLinesToPaste > 1)
6549 {
6550 // multiline text
6551
6552 // We want to undo the multiline insertion in a single step.
6553 CUndo::GetInstance().BeginGrouping();
6554
6555 sLine = GetViewLineChars(nViewLine);
6556 CString sLineLeft = sLine.Left(nLeft);
6557 CString sLineRight = sLine.Right(sLine.GetLength() - nLeft);
6558 EOL eOriginalEnding = GetViewLineEnding(nViewLine);
6559 viewdata newLine(L"", DIFFSTATE_EDITED, 1, m_lineendings, HIDESTATE_SHOWN);
6560 if (!lines[0].IsEmpty() || !sLineRight.IsEmpty() || (eOriginalEnding != m_lineendings))
6561 {
6562 newLine.sLine = sLineLeft + lines[0];
6563 SetViewData(nViewLine, newLine);
6564 }
6565
6566 int nInsertLine = nViewLine;
6567 for (int i = 1; i < nLinesToPaste - 1; i++)
6568 {
6569 newLine.sLine = lines[i];
6570 InsertViewData(++nInsertLine, newLine);
6571 }
6572 newLine.sLine = lines[nLinesToPaste - 1] + sLineRight;
6573 newLine.ending = eOriginalEnding;
6574 InsertViewData(++nInsertLine, newLine);
6575
6576 SetModified();
6577 SaveUndoStep();
6578
6579 // adds new lines everywhere except me
6580 if (IsViewGood(m_pwndLeft) && m_pwndLeft != this)
6581 {
6582 m_pwndLeft->InsertViewEmptyLines(nViewLine + 1, nLinesToPaste - 1);
6583 }
6584 if (IsViewGood(m_pwndRight) && m_pwndRight != this)
6585 {
6586 m_pwndRight->InsertViewEmptyLines(nViewLine + 1, nLinesToPaste - 1);
6587 }
6588 if (IsViewGood(m_pwndBottom) && m_pwndBottom != this)
6589 {
6590 m_pwndBottom->InsertViewEmptyLines(nViewLine + 1, nLinesToPaste - 1);
6591 }
6592 SaveUndoStep();
6593
6594 UpdateViewLineNumbers();
6595 CUndo::GetInstance().EndGrouping();
6596
6597 ptCaretViewPos = SetupPoint(lines[nLinesToPaste - 1].GetLength(), nInsertLine);
6598 }
6599 else
6600 {
6601 // single line text - just insert it
6602 sLine = GetViewLineChars(nViewLine);
6603 sLine.Insert(nLeft, sText);
6604 ptCaretViewPos = SetupPoint(nLeft + sText.GetLength(), nViewLine);
6605 SetViewLine(nViewLine, sLine);
6606 SetViewState(nViewLine, DIFFSTATE_EDITED);
6607 SetModified();
6608 SaveUndoStep();
6609 }
6610
6611 RefreshViews();
6612 BuildAllScreen2ViewVector();
6613 UpdateCaretViewPosition(ptCaretViewPos);
6614 }
6615
6616 ULONG CBaseView::GetGestureStatus(CPoint /*ptTouch*/)
6617 {
6618 return 0;
6619 }
Windows Explorer Extension to Operate Git