665 lines
22 KiB
C#
665 lines
22 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
|
|
using Codice.CM.Client.Differences;
|
|
using Codice.CM.Client.Differences.Graphic;
|
|
|
|
using Unity.CodeEditor;
|
|
using Unity.CodeEditor.Document;
|
|
using Unity.CodeEditor.Editing;
|
|
using Unity.CodeEditor.Rendering;
|
|
|
|
using UnityEngine;
|
|
using UnityEngine.UIElements;
|
|
|
|
using XDiffGui;
|
|
|
|
namespace Unity.PlasticSCM.Editor.Diff.Text
|
|
{
|
|
internal class DiffScroll : IDiffSummaryListener
|
|
{
|
|
internal Unity.CodeEditor.TextEditor LeftTextEditor { get { return mLeftTextEditor; } }
|
|
internal Unity.CodeEditor.TextEditor RightTextEditor { get { return mRightTextEditor; } }
|
|
|
|
internal Scroller VerticalScroller { get { return mVerticalScroller; } }
|
|
internal Scroller HorizontalScroller { get { return mHorizontalScroller; } }
|
|
|
|
internal DiffScroll(
|
|
DiffSplitter diffSplitter,
|
|
Unity.CodeEditor.TextEditor leftTextEditor,
|
|
Unity.CodeEditor.TextEditor rightTextEditor,
|
|
LineNumbersView leftLineNumbers,
|
|
LineNumbersView rightLineNumbers,
|
|
ActionBar leftActionBar,
|
|
ActionBar rightActionBar)
|
|
{
|
|
mDiffSplitter = diffSplitter;
|
|
mLeftTextEditor = leftTextEditor;
|
|
mRightTextEditor = rightTextEditor;
|
|
|
|
mLeftLineNumbers = leftLineNumbers;
|
|
mRightLineNumbers = rightLineNumbers;
|
|
|
|
mLeftActionBar = leftActionBar;
|
|
mRightActionBar = rightActionBar;
|
|
|
|
mVerticalScroller = new Scroller(
|
|
0, 100, OnVerticalScrollerChanged, SliderDirection.Vertical);
|
|
mVerticalScroller.style.position = Position.Relative;
|
|
|
|
mHorizontalScroller = new Scroller(
|
|
0, 100, OnHorizontalScrollerChanged, SliderDirection.Horizontal);
|
|
mHorizontalScroller.style.position = Position.Relative;
|
|
|
|
AttachWheelEvents(mLeftTextEditor);
|
|
AttachWheelEvents(mRightTextEditor);
|
|
|
|
mDiffSplitter.RegisterCallback<WheelEvent>(
|
|
OnWheelEvent, TrickleDown.TrickleDown);
|
|
mLeftLineNumbers.RegisterCallback<WheelEvent>(
|
|
OnWheelEvent, TrickleDown.TrickleDown);
|
|
mRightLineNumbers.RegisterCallback<WheelEvent>(
|
|
OnWheelEvent, TrickleDown.TrickleDown);
|
|
mLeftActionBar.RegisterCallback<WheelEvent>(
|
|
OnWheelEvent, TrickleDown.TrickleDown);
|
|
mRightActionBar.RegisterCallback<WheelEvent>(
|
|
OnWheelEvent, TrickleDown.TrickleDown);
|
|
|
|
mLeftEditorScrollEvents = new TextEditorScrollEvents(
|
|
mLeftTextEditor,
|
|
OnEditorVerticalScrollChanged,
|
|
OnEditorHorizontalScrollChanged,
|
|
OnEditorLayoutUpdated);
|
|
|
|
mRightEditorScrollEvents = new TextEditorScrollEvents(
|
|
mRightTextEditor,
|
|
OnEditorVerticalScrollChanged,
|
|
OnEditorHorizontalScrollChanged,
|
|
OnEditorLayoutUpdated);
|
|
}
|
|
|
|
internal void GoToLineOnRightTextView(int line)
|
|
{
|
|
GoToLineOnTextView(line, mMapping.Right);
|
|
}
|
|
|
|
internal void GoToLineOnLeftTextView(int line)
|
|
{
|
|
GoToLineOnTextView(line, mMapping.Left);
|
|
}
|
|
|
|
internal void DisableScrollEvents()
|
|
{
|
|
mLeftEditorScrollEvents.DisableScrollEvents();
|
|
mRightEditorScrollEvents.DisableScrollEvents();
|
|
}
|
|
|
|
internal void EnableScrollEvents()
|
|
{
|
|
mLeftEditorScrollEvents.EnableScrollEvents();
|
|
mRightEditorScrollEvents.EnableScrollEvents();
|
|
}
|
|
|
|
internal void InvalidateViews()
|
|
{
|
|
mLeftTextEditor.TextArea.TextView.InvalidateVisual();
|
|
mRightTextEditor.TextArea.TextView.InvalidateVisual();
|
|
mLeftLineNumbers.InvalidateVisual();
|
|
mRightLineNumbers.InvalidateVisual();
|
|
mLeftActionBar.UpdateActions();
|
|
mRightActionBar.UpdateActions();
|
|
mDiffSplitter.MarkDirtyRepaint();
|
|
}
|
|
|
|
internal void UpdateVirtualMapping(VirtualLinesMapping mapping)
|
|
{
|
|
mMapping = mapping;
|
|
|
|
if (!mRightTextEditor.TextArea.TextView.VisualLinesValid)
|
|
mRightTextEditor.TextArea.TextView.EnsureVisualLines();
|
|
|
|
VisualLine fullyVisibleTopLine =
|
|
mRightTextEditor.TextArea.TextView.GetFullyVisibleTopLine();
|
|
|
|
if (fullyVisibleTopLine == null)
|
|
{
|
|
UpdateScrollBarMetrics();
|
|
return;
|
|
}
|
|
|
|
int virtualLine = GetVirtualLine(
|
|
fullyVisibleTopLine.FirstDocumentLine.LineNumber,
|
|
mMapping.Right) + 1;
|
|
|
|
mOffsetY = Mathf.Max(0, Mathf.Min(virtualLine,
|
|
mTotalLines - mVisibleLines));
|
|
|
|
UpdateScrollBarMetrics();
|
|
}
|
|
|
|
internal void SetDiffPosition(int line)
|
|
{
|
|
mForceNavigateToPosition = true;
|
|
try
|
|
{
|
|
SetVerticalOffset(
|
|
line - 1 - TopLineSynchronizer.DEFAULT_SYNC_LINE_POSITION);
|
|
}
|
|
finally
|
|
{
|
|
mForceNavigateToPosition = false;
|
|
}
|
|
}
|
|
|
|
void GoToLineOnTextView(
|
|
int line,
|
|
List<int> mapping)
|
|
{
|
|
int virtualLine = (line == 0) ? 0 : GetVirtualLine(
|
|
line + 1, mapping);
|
|
|
|
if (virtualLine == -1)
|
|
return;
|
|
|
|
mForceNavigateToPosition = true;
|
|
try
|
|
{
|
|
SetVerticalOffset(virtualLine);
|
|
}
|
|
finally
|
|
{
|
|
mForceNavigateToPosition = false;
|
|
}
|
|
}
|
|
|
|
void IDiffSummaryListener.Clicked(int line)
|
|
{
|
|
SetDiffPosition(line);
|
|
}
|
|
|
|
internal void Dispose()
|
|
{
|
|
DetachWheelEvents(mLeftTextEditor);
|
|
DetachWheelEvents(mRightTextEditor);
|
|
|
|
mDiffSplitter.UnregisterCallback<WheelEvent>(
|
|
OnWheelEvent, TrickleDown.TrickleDown);
|
|
mLeftLineNumbers.UnregisterCallback<WheelEvent>(
|
|
OnWheelEvent, TrickleDown.TrickleDown);
|
|
mRightLineNumbers.UnregisterCallback<WheelEvent>(
|
|
OnWheelEvent, TrickleDown.TrickleDown);
|
|
mLeftActionBar.UnregisterCallback<WheelEvent>(
|
|
OnWheelEvent, TrickleDown.TrickleDown);
|
|
mRightActionBar.UnregisterCallback<WheelEvent>(
|
|
OnWheelEvent, TrickleDown.TrickleDown);
|
|
|
|
mLeftEditorScrollEvents.Dispose();
|
|
mRightEditorScrollEvents.Dispose();
|
|
}
|
|
|
|
internal void BeginUpdate()
|
|
{
|
|
mIsUpdating = true;
|
|
}
|
|
|
|
internal void EndUpdate()
|
|
{
|
|
mIsUpdating = false;
|
|
UpdateScrollBarMetrics();
|
|
}
|
|
|
|
internal void DisableTextBoxScrollEvents()
|
|
{
|
|
mAreTextBoxForScrollEventsDisabled = true;
|
|
}
|
|
|
|
internal void EnableTextBoxScrollEvents()
|
|
{
|
|
mAreTextBoxForScrollEventsDisabled = false;
|
|
}
|
|
|
|
internal void UpdateScrollBarMetrics()
|
|
{
|
|
UpdateVScrollMetrics();
|
|
UpdateHScrollMetrics();
|
|
|
|
UpdateScrollerValues();
|
|
}
|
|
|
|
void OnVerticalScrollerChanged(float value)
|
|
{
|
|
if (mUpdatingScroller)
|
|
return;
|
|
|
|
SetVerticalOffset(value);
|
|
}
|
|
|
|
void OnHorizontalScrollerChanged(float value)
|
|
{
|
|
if (mUpdatingScroller)
|
|
return;
|
|
|
|
SetHorizontalOffset(value);
|
|
}
|
|
|
|
void AttachWheelEvents(Unity.CodeEditor.TextEditor editor)
|
|
{
|
|
editor.TextArea.RegisterCallback<WheelEvent>(
|
|
OnWheelEvent, TrickleDown.TrickleDown);
|
|
|
|
foreach (AbstractMargin margin in editor.TextArea.LeftMargins)
|
|
margin.RegisterCallback<WheelEvent>(
|
|
OnWheelEvent, TrickleDown.TrickleDown);
|
|
}
|
|
|
|
void DetachWheelEvents(Unity.CodeEditor.TextEditor editor)
|
|
{
|
|
editor.TextArea.UnregisterCallback<WheelEvent>(
|
|
OnWheelEvent, TrickleDown.TrickleDown);
|
|
|
|
foreach (AbstractMargin margin in editor.TextArea.LeftMargins)
|
|
margin.UnregisterCallback<WheelEvent>(
|
|
OnWheelEvent, TrickleDown.TrickleDown);
|
|
}
|
|
|
|
void OnWheelEvent(WheelEvent evt)
|
|
{
|
|
evt.StopPropagation();
|
|
|
|
if (evt.delta.x != 0)
|
|
SetHorizontalOffset(mOffsetX + evt.delta.x * HORIZONTAL_DELTA_MULTIPLIER);
|
|
|
|
if (evt.delta.y != 0)
|
|
SetVerticalOffset(mOffsetY + evt.delta.y * VERTICAL_DELTA_MULTIPLIER);
|
|
|
|
UpdateScrollerValues();
|
|
}
|
|
|
|
void OnEditorHorizontalScrollChanged(TextView sender)
|
|
{
|
|
if (mAreTextBoxForScrollEventsDisabled)
|
|
return;
|
|
|
|
Unity.CodeEditor.TextEditor editor =
|
|
(sender == mLeftTextEditor.TextArea.TextView) ?
|
|
mLeftTextEditor : mRightTextEditor;
|
|
|
|
OnHorizontalScrollOffsetValueChanged(editor);
|
|
}
|
|
|
|
void OnEditorVerticalScrollChanged(TextView sender)
|
|
{
|
|
if (mAreTextBoxForScrollEventsDisabled)
|
|
return;
|
|
|
|
Unity.CodeEditor.TextEditor editor =
|
|
(sender == mLeftTextEditor.TextArea.TextView) ?
|
|
mLeftTextEditor : mRightTextEditor;
|
|
|
|
OnVerticalScrollOffsetValueChanged(editor);
|
|
}
|
|
|
|
void OnHorizontalScrollOffsetValueChanged(
|
|
Unity.CodeEditor.TextEditor editor)
|
|
{
|
|
if (mUsableWidth + editor.HorizontalOffset > mTotalWidth)
|
|
mTotalWidth = mUsableWidth + editor.HorizontalOffset;
|
|
}
|
|
|
|
void OnVerticalScrollOffsetValueChanged(
|
|
Unity.CodeEditor.TextEditor editor)
|
|
{
|
|
UpdateHScrollMetrics();
|
|
|
|
// don't synchronize here: visual lines are stale because
|
|
// ScrollOffsetChanged fires before they are rebuilt.
|
|
// The sync runs in OnEditorLayoutUpdated once visual
|
|
// lines match the new scroll offset
|
|
mEditorPendingVerticalSync = editor;
|
|
}
|
|
|
|
void UpdateVerticalOffsetFromTextBox(
|
|
Unity.CodeEditor.TextEditor editor,
|
|
int line)
|
|
{
|
|
if (mMapping == null || mMapping.Left == null ||
|
|
mMapping.Left.Count == 0 ||
|
|
mMapping.Right == null || mMapping.Right.Count == 0)
|
|
return;
|
|
|
|
int virtualLine = -1;
|
|
|
|
if (editor == mLeftTextEditor)
|
|
virtualLine = line == 1 ? 1 :
|
|
GetVirtualLine(line, mMapping.Left);
|
|
|
|
if (editor == mRightTextEditor)
|
|
virtualLine = line == 1 ? 1 :
|
|
GetVirtualLine(line, mMapping.Right);
|
|
|
|
if (virtualLine == -1)
|
|
return;
|
|
|
|
if (mVisibleLines + virtualLine > mTotalLines)
|
|
mTotalLines = mVisibleLines + virtualLine;
|
|
|
|
mOffsetY = virtualLine - 1;
|
|
|
|
mForceNavigateToPosition = true;
|
|
try
|
|
{
|
|
SetVerticalPosition(mOffsetY);
|
|
UpdateScrollerValues();
|
|
}
|
|
finally
|
|
{
|
|
mForceNavigateToPosition = false;
|
|
}
|
|
}
|
|
|
|
void OnEditorLayoutUpdated(TextArea textArea)
|
|
{
|
|
UpdateScrollBarMetrics();
|
|
|
|
if (mEditorPendingVerticalSync == null)
|
|
return;
|
|
|
|
if (textArea != mEditorPendingVerticalSync.TextArea)
|
|
return;
|
|
|
|
Unity.CodeEditor.TextEditor editor = mEditorPendingVerticalSync;
|
|
mEditorPendingVerticalSync = null;
|
|
|
|
UpdateVerticalOffsetFromEditor(editor);
|
|
}
|
|
|
|
void UpdateVerticalOffsetFromEditor(Unity.CodeEditor.TextEditor editor)
|
|
{
|
|
TextView textView = editor.TextArea.TextView;
|
|
|
|
if (!textView.VisualLinesValid)
|
|
return;
|
|
|
|
VisualLine fullyVisibleTopLine = textView.GetFullyVisibleTopLine();
|
|
|
|
if (fullyVisibleTopLine == null)
|
|
return;
|
|
|
|
UpdateVerticalOffsetFromTextBox(
|
|
editor,
|
|
fullyVisibleTopLine.FirstDocumentLine.LineNumber);
|
|
}
|
|
|
|
void UpdateVScrollMetrics()
|
|
{
|
|
if (mIsUpdating)
|
|
return;
|
|
|
|
if (mMapping == null || mMapping.Left == null ||
|
|
mMapping.Left.Count == 0 ||
|
|
mMapping.Right == null || mMapping.Right.Count == 0)
|
|
return;
|
|
|
|
float totalLines = Mathf.Max(
|
|
mMapping.Left.Count, mMapping.Right.Count);
|
|
|
|
float leftViewport = mLeftTextEditor.TextArea.TextView.ScrollViewport.y;
|
|
float rightViewport = mRightTextEditor.TextArea.TextView.ScrollViewport.y;
|
|
float leftLineHeight = mLeftTextEditor.TextArea.TextView.DefaultLineHeight;
|
|
float rightLineHeight = mRightTextEditor.TextArea.TextView.DefaultLineHeight;
|
|
|
|
if (leftLineHeight <= 0) leftLineHeight = 1;
|
|
if (rightLineHeight <= 0) rightLineHeight = 1;
|
|
|
|
float visibleLines = Mathf.Min(
|
|
leftViewport / leftLineHeight,
|
|
rightViewport / rightLineHeight);
|
|
|
|
bool allowToScrollBelowDocument =
|
|
mLeftTextEditor.Options.AllowScrollBelowDocument &&
|
|
mRightTextEditor.Options.AllowScrollBelowDocument;
|
|
|
|
bool isScrollVisible =
|
|
mLeftTextEditor.TextArea.TextView.ScrollExtent.y >
|
|
mLeftTextEditor.TextArea.TextView.ScrollViewport.y ||
|
|
mRightTextEditor.TextArea.TextView.ScrollExtent.y >
|
|
mRightTextEditor.TextArea.TextView.ScrollViewport.y;
|
|
|
|
if (isScrollVisible && allowToScrollBelowDocument)
|
|
totalLines += visibleLines;
|
|
|
|
UpdateVScrollData(visibleLines, totalLines);
|
|
}
|
|
|
|
void UpdateHScrollMetrics()
|
|
{
|
|
if (mIsUpdating)
|
|
return;
|
|
|
|
float maxTotalWidth = Mathf.Max(
|
|
mLeftTextEditor.TextArea.TextView.ScrollExtent.x,
|
|
mRightTextEditor.TextArea.TextView.ScrollExtent.x);
|
|
|
|
float maxUsableWidth = Mathf.Min(
|
|
mLeftTextEditor.TextArea.TextView.ScrollViewport.x,
|
|
mRightTextEditor.TextArea.TextView.ScrollViewport.x);
|
|
|
|
UpdateHScrollData(maxUsableWidth, maxTotalWidth);
|
|
}
|
|
|
|
void UpdateHScrollData(float usableWidth, float totalWidth)
|
|
{
|
|
mTotalWidth = totalWidth;
|
|
mUsableWidth = usableWidth;
|
|
|
|
mOffsetX = Mathf.Max(0,
|
|
Mathf.Min(mOffsetX, mTotalWidth - mUsableWidth));
|
|
}
|
|
|
|
void UpdateVScrollData(float visibleLines, float totalLines)
|
|
{
|
|
mTotalLines = totalLines;
|
|
mVisibleLines = visibleLines - 1;
|
|
|
|
mOffsetY = Mathf.Max(0,
|
|
Mathf.Min(mOffsetY, mTotalLines - mVisibleLines));
|
|
}
|
|
|
|
void SetHorizontalOffset(float offset)
|
|
{
|
|
if (offset < 0)
|
|
offset = 0;
|
|
|
|
if (Mathf.Approximately(mOffsetX, offset))
|
|
return;
|
|
|
|
offset = Mathf.Max(0, Mathf.Min(offset, mTotalWidth - mUsableWidth));
|
|
mOffsetX = offset;
|
|
SetHorizontalPosition(mOffsetX);
|
|
|
|
UpdateScrollerValues();
|
|
}
|
|
|
|
void SetVerticalOffset(float offset)
|
|
{
|
|
offset = Mathf.Max(0, Mathf.Min(offset,
|
|
mTotalLines - mVisibleLines));
|
|
|
|
if (Mathf.Approximately(mOffsetY, offset) && !mForceNavigateToPosition)
|
|
return;
|
|
|
|
mOffsetY = offset;
|
|
SetVerticalPosition(mOffsetY);
|
|
|
|
UpdateScrollerValues();
|
|
}
|
|
|
|
void SetVerticalPosition(float position)
|
|
{
|
|
if (mMapping == null || mMapping.Left == null ||
|
|
mMapping.Left.Count == 0 ||
|
|
mMapping.Right == null || mMapping.Right.Count == 0)
|
|
return;
|
|
|
|
mLeftEditorScrollEvents.DisableScrollEvents();
|
|
mRightEditorScrollEvents.DisableScrollEvents();
|
|
|
|
try
|
|
{
|
|
int maxVirtualLinesCount = Mathf.Max(
|
|
mMapping.Left.Count - 1, mMapping.Right.Count - 1);
|
|
|
|
if (position > maxVirtualLinesCount)
|
|
position = maxVirtualLinesCount;
|
|
|
|
int leftPhysicalLine = TopLineSynchronizer.GetPhysicalTopLine(
|
|
mMapping.Left, (int)position, mForceNavigateToPosition);
|
|
|
|
int rightPhysicalLine = TopLineSynchronizer.GetPhysicalTopLine(
|
|
mMapping.Right, (int)position, mForceNavigateToPosition);
|
|
|
|
float lineOffsetPercent = position - Mathf.Floor(position);
|
|
|
|
if (leftPhysicalLine > 0)
|
|
SetLineOnTop(mLeftTextEditor, leftPhysicalLine, lineOffsetPercent);
|
|
|
|
if (rightPhysicalLine > 0)
|
|
SetLineOnTop(mRightTextEditor, rightPhysicalLine, lineOffsetPercent);
|
|
}
|
|
finally
|
|
{
|
|
mLeftEditorScrollEvents.EnableScrollEvents();
|
|
mRightEditorScrollEvents.EnableScrollEvents();
|
|
|
|
InvalidateViews();
|
|
}
|
|
}
|
|
|
|
void SetHorizontalPosition(float position)
|
|
{
|
|
mLeftEditorScrollEvents.DisableScrollEvents();
|
|
mRightEditorScrollEvents.DisableScrollEvents();
|
|
|
|
try
|
|
{
|
|
Vector2 leftOffset = mLeftTextEditor.TextArea.TextView.ScrollOffset;
|
|
mLeftTextEditor.TextArea.TextView.ScrollOffset =
|
|
new Vector2(position, leftOffset.y);
|
|
|
|
Vector2 rightOffset = mRightTextEditor.TextArea.TextView.ScrollOffset;
|
|
mRightTextEditor.TextArea.TextView.ScrollOffset =
|
|
new Vector2(position, rightOffset.y);
|
|
|
|
mLeftTextEditor.TextArea.TextView.UpdateVisualLines();
|
|
mRightTextEditor.TextArea.TextView.UpdateVisualLines();
|
|
}
|
|
finally
|
|
{
|
|
mLeftEditorScrollEvents.EnableScrollEvents();
|
|
mRightEditorScrollEvents.EnableScrollEvents();
|
|
}
|
|
}
|
|
|
|
void SetLineOnTop(
|
|
Unity.CodeEditor.TextEditor editor,
|
|
int line,
|
|
float lineOffsetPercent)
|
|
{
|
|
TextDocument document = editor.TextArea.TextView.Document;
|
|
if (document == null)
|
|
return;
|
|
|
|
if (line < 1) line = 1;
|
|
if (line > document.LineCount) line = document.LineCount;
|
|
|
|
VisualLine visualLine = editor.TextArea.TextView.GetOrConstructVisualLine(
|
|
document.GetLineByNumber(line));
|
|
|
|
float y = visualLine.VisualTop + (lineOffsetPercent * visualLine.Height);
|
|
|
|
Vector2 currentOffset = editor.TextArea.TextView.ScrollOffset;
|
|
if (Mathf.RoundToInt(currentOffset.y) == Mathf.RoundToInt(y))
|
|
return;
|
|
|
|
editor.TextArea.TextView.ScrollOffset =
|
|
new Vector2(currentOffset.x, Mathf.Max(0, y));
|
|
editor.TextArea.TextView.UpdateVisualLines();
|
|
}
|
|
|
|
static int GetVirtualLine(
|
|
int realLine,
|
|
List<int> virtualLineMapping)
|
|
{
|
|
return virtualLineMapping.IndexOf(realLine);
|
|
}
|
|
|
|
void UpdateScrollerValues()
|
|
{
|
|
mUpdatingScroller = true;
|
|
try
|
|
{
|
|
float vMax = Mathf.Max(0, mTotalLines - mVisibleLines);
|
|
mVerticalScroller.lowValue = 0;
|
|
mVerticalScroller.highValue = vMax;
|
|
mVerticalScroller.slider.pageSize = Mathf.Max(1, mVisibleLines);
|
|
mVerticalScroller.value = mOffsetY;
|
|
float vFactor = mTotalLines > 0
|
|
? Mathf.Clamp01(mVisibleLines / mTotalLines) : 1f;
|
|
mVerticalScroller.Adjust(vFactor);
|
|
mVerticalScroller.style.visibility =
|
|
vMax > 0 ? Visibility.Visible : Visibility.Hidden;
|
|
|
|
float hMax = Mathf.Max(0, mTotalWidth - mUsableWidth);
|
|
mHorizontalScroller.lowValue = 0;
|
|
mHorizontalScroller.highValue = hMax;
|
|
mHorizontalScroller.slider.pageSize = Mathf.Max(1, mUsableWidth);
|
|
mHorizontalScroller.value = mOffsetX;
|
|
float hFactor = mTotalWidth > 0
|
|
? Mathf.Clamp01(mUsableWidth / mTotalWidth) : 1f;
|
|
mHorizontalScroller.Adjust(hFactor);
|
|
mHorizontalScroller.style.visibility =
|
|
hMax > 0 ? Visibility.Visible : Visibility.Hidden;
|
|
}
|
|
finally
|
|
{
|
|
mUpdatingScroller = false;
|
|
}
|
|
}
|
|
|
|
VirtualLinesMapping mMapping;
|
|
|
|
float mTotalLines;
|
|
float mTotalWidth;
|
|
|
|
float mOffsetX;
|
|
float mOffsetY;
|
|
|
|
float mVisibleLines;
|
|
float mUsableWidth;
|
|
|
|
bool mForceNavigateToPosition;
|
|
bool mAreTextBoxForScrollEventsDisabled;
|
|
|
|
bool mIsUpdating;
|
|
bool mUpdatingScroller;
|
|
Unity.CodeEditor.TextEditor mEditorPendingVerticalSync;
|
|
|
|
TextEditorScrollEvents mLeftEditorScrollEvents;
|
|
TextEditorScrollEvents mRightEditorScrollEvents;
|
|
|
|
readonly Scroller mVerticalScroller;
|
|
readonly Scroller mHorizontalScroller;
|
|
|
|
readonly DiffSplitter mDiffSplitter;
|
|
readonly Unity.CodeEditor.TextEditor mLeftTextEditor;
|
|
readonly Unity.CodeEditor.TextEditor mRightTextEditor;
|
|
readonly LineNumbersView mLeftLineNumbers;
|
|
readonly LineNumbersView mRightLineNumbers;
|
|
readonly ActionBar mLeftActionBar;
|
|
readonly ActionBar mRightActionBar;
|
|
|
|
const float HORIZONTAL_DELTA_MULTIPLIER = 12f;
|
|
const float VERTICAL_DELTA_MULTIPLIER = 2.6f;
|
|
}
|
|
}
|