protected override void DrawItem(Track track, ITimeConverter converter)
{
float lastTime = 0;
var count = m_LayerNames.Count;
var oldColor = GUI.backgroundColor;
for (int i = 0; i < count; i++)
{
var leftTime = converter.TimeToPixel(m_LayerNames[i].time);
var nextTime = i + 1 == count
? Time.unscaledTime - GameDebuggerDatabase.StartRecordingTime
: m_LayerNames[i + 1].time;
var rightTime = converter.TimeToPixel(nextTime);
var rect = track.contentRect;
rect.xMin = leftTime;
rect.xMax = rightTime;
rect.yMax -= 5;
GUI.backgroundColor = StringToColor(m_LayerNames[i].name);
GUI.Box(rect, m_LayerNames[i].name, EditorStyles.helpBox);
}
GUI.backgroundColor = oldColor;
}
public string BerlinClockOutput(string time)
{
ITimeConverter outputFormat = factory.ConvertTime(time);
string output = outputFormat.ConvertTime(inputTime);
return(output);
}
void DrawLine(Track track, ITimeConverter converter)
{
var x = converter.TimeToPixel(0);
var w = converter.TimeToPixel(Time.unscaledTime - GameDebuggerDatabase.StartRecordingTime) - x;
EditorGUI.DrawRect(new Rect(x, 24, w, 1), m_LineColor);
}
protected override void DrawItem(Track track, ITimeConverter converter)
{
foreach (var screenshot in m_Screenshots)
{
GUI.DrawTexture(GetRectForScreenshot(converter, screenshot), screenshot.screenshot);
}
}
public static int ValidateHour(this ITimeConverter timeConverter, string aTime)
{
if (string.IsNullOrEmpty(aTime))
{
throw new ArgumentNullException(nameof(aTime));
}
string[] time = aTime.Split(':');
int hours;
if (int.TryParse(time[0], out hours))
{
if (hours < 0 || hours > 24)
{
throw new ArgumentOutOfRangeException(nameof(hours), hours, "No valid hours range (0 - 24)");
}
}
else
{
throw new ArgumentException("No valid hours time value", nameof(hours));
}
return(hours);
}
public TheBerlinClockSteps()
{
berlinClock = new TimeConverter(
//new TimeSpanCoverterMock(),
new BerlinClockFactory().Create(),
new TimeSpanParser()
);
}
void DrawKeys(ITimeConverter converter)
{
foreach (var frameId in m_FrameIds)
{
var frameTime = GameDebuggerDatabase.GetRecords(frameId).time;
var keyPixelXPos = converter.TimeToPixel(frameTime);
EditorGUI.DrawRect(new Rect(keyPixelXPos - 3, 22, 6, 6), m_KeyColor);
}
}
public void Draw(Track track, ITimeConverter converter)
{
// Set track icon and name.
track.Q <VisualElement>("trackIcon").style.backgroundImage = ItemImage();
track.Q <Label>().text = ItemName();
DrawBackground(track);
DrawItem(track, converter);
}
public TheBerlinClockSteps()
{
var lineFormatter = new LineFormatter((char)TimeConverter.Lamp.Off);
var hourConverter = new HourConverter(lineFormatter);
var minuteConverter = new MinuteConverter(lineFormatter);
var secondConverter = new SecondConverter(lineFormatter);
_berlinClock = new TimeConverter(hourConverter, minuteConverter, secondConverter);
}
/// <summary>Initializes a new instance of the <see cref="TheBerlinClockSteps"/> class.</summary>
public TheBerlinClockSteps()
{
// Initialize container to enable dependency injection.
_Container = new WindsorContainer();
_Container.Register(
Component.For <ITimeConverter>().ImplementedBy <TimeConverter>(),
Component.For <ILog>().ImplementedBy <StubILog>()
);
_BerlinClock = _Container.Resolve <ITimeConverter>();
}
static Rect GetRectForScreenshot(ITimeConverter converter, ScreenshotForTime screenshot)
{
var pixel = converter.TimeToPixel(screenshot.time);
if (screenshot.screenshot != null)
{
var width = screenshot.screenshot.width * 45 / screenshot.screenshot.height;
return(new Rect(pixel, 0, width, 45));
}
return(Rect.zero);
}
public void AnyExceptionThrownAtTimeInputConversionIsPropagated()
{
this.berlinClockServiceMock = new Mock <IBerlineClockService>();
this.inputConverterServiceMock = new Mock <ITimeTextInputConverter>();
this.berlinClockVisualisationServiceMock = new Mock <IBerlinClockVisualisationService>();
this.timeConverter = new TimeConverter(this.inputConverterServiceMock.Object, this.berlinClockServiceMock.Object, this.berlinClockVisualisationServiceMock.Object);
Exception thrown = new Exception();
this.inputConverterServiceMock.Setup(x => x.Convert(It.IsAny <string>())).Throws(thrown);
Assert.Throws(thrown.GetType(), () => timeConverter.convertTime("dd"));
}
public void Setup()
{
var timeParser = Substitute.For <ITimeParser>();
timeParser.Parse(Arg.Any <string>())
.Returns(new Time(17, 24, 31));
var berlinClockBuilder = Substitute.For <IBerlinClockBuilder>();
berlinClockBuilder.Build(Arg.Any <ITime>()).Returns(ExpectedOutput);
timeConverter = new TimeConverter(timeParser, berlinClockBuilder);
}
public CberlinClock(ITimeConverter topFirstRow, ITimeConverter topSecondRow, ITimeConverter bottomFirstRow, ITimeConverter bottomSecondRow, ITimeConverter lampGenerator)
{
_topFirstRow = topFirstRow;
_topSecondRow = topSecondRow;
_bottomFirstRow = bottomFirstRow;
_bottomSecondRow = bottomSecondRow;
_lampGenerator = lampGenerator;
_hourBiggestFit = new CValueBiggest(new List <int> {
5, 10, 15, 20
});
_minuteBiggestFit = new CValueBiggest(new List <int> {
5, 10, 15, 20, 25, 30, 35, 40, 35, 50, 55
});
}
public PlayheadElement(ITimeConverter timeConverter)
{
m_TimeConverter = timeConverter;
var playheadCursor = new Box();
playheadCursor.name = "playheadCursor";
var playheadLine = new Box();
playheadLine.name = "playheadLine";
Add(playheadLine);
Add(playheadCursor);
}
public TrackContainer(ITimeConverter timeConverter, RefreshScheduler scheduler, VisualElement extraViewer)
{
m_TimeConverter = timeConverter;
m_ExtraViwer = extraViewer;
var trackTemplate = Resources.Load <VisualTreeAsset>("Replay/GameDebuggerTrackTemplate");
m_ListView = new ListView(new List <int>(), 50, () => CreateTrack(trackTemplate), DrawItem);
m_ListView.selectionType = SelectionType.None;
Add(m_ListView);
scheduler.ExitPlayMode += () =>
{
m_ListView.itemsSource = null;
m_ListView.Refresh();
};
scheduler.Refresh += RefreshTracks;
GameDebuggerDatabase.GameDebugerDatabaseLoaded += () => { RefreshTracks(true); };
}
public void AnyExceptionAtVisualisationStepIsPropagated()
{
this.berlinClockServiceMock = new Mock <IBerlineClockService>();
this.inputConverterServiceMock = new Mock <ITimeTextInputConverter>();
this.berlinClockVisualisationServiceMock = new Mock <IBerlinClockVisualisationService>();
this.timeConverter = new TimeConverter(this.inputConverterServiceMock.Object, this.berlinClockServiceMock.Object, this.berlinClockVisualisationServiceMock.Object);
this.inputConverterServiceMock.Setup(x => x.Convert(It.IsAny <string>())).Returns(new TimeSpan());
Exception thrown = new Exception();
this.berlinClockServiceMock.Setup(x => x.RepresentTime(It.IsAny <TimeSpan>()))
.Returns(new BerlinClockTimeRepresentation());
this.berlinClockVisualisationServiceMock
.Setup(x => x.TextVisualisation(It.IsAny <BerlinClockTimeRepresentation>())).Throws(thrown);
Assert.Throws(thrown.GetType(), () => timeConverter.convertTime("dd"));
}
public static int ValidateSeconds(this ITimeConverter timeConverter, string aTime)
{
string[] time = aTime.Split(':');
int seconds;
if (int.TryParse(time[2], out seconds))
{
if (seconds < 0 || seconds > 59)
{
throw new ArgumentOutOfRangeException(nameof(seconds), seconds, "No valid seconds range (0 - 59)");
}
}
else
{
throw new ArgumentException("No valid seconds value", nameof(seconds));
}
return(seconds);
}
public static int ValidateMinutes(this ITimeConverter timeConverter, string aTime)
{
string[] time = aTime.Split(':');
int minutes;
if (int.TryParse(time[1], out minutes))
{
if (minutes < 0 || minutes > 59)
{
throw new ArgumentOutOfRangeException(nameof(minutes), minutes, "No valid minutes range range (0 - 59)");
}
}
else
{
throw new ArgumentException("No valid minutes value", nameof(minutes));
}
return(minutes);
}
void DrawKeys(Track track, ITimeConverter converter)
{
if (m_FrameIds.Count == 0)
{
return;
}
// Get max velocity.
var maxVelocity = Mathf.Max(m_Velocities.Max(v => v), 0.1f);
var height = track.contentRect.height;
var prevVelocity = m_Velocities[0];
var prevVelocityHeight = 5.0f + (prevVelocity / maxVelocity) * 25.0f;
var prevFrameTime = GameDebuggerDatabase.GetRecords(m_FrameIds[0]).time;
var prevFrameTimeXPos = converter.TimeToPixel(prevFrameTime);
var prevFrameTimeYPos = (height - prevVelocityHeight) / 2.0f;
var prevColor = Color.Lerp(m_LowVelocityColor, m_HighVelocityColor, prevVelocity / maxVelocity);
for (var f = 1; f < m_FrameIds.Count; ++f)
{
var frameId = m_FrameIds[f];
var frameTime = GameDebuggerDatabase.GetRecords(frameId).time;
var frameTimeXPos = converter.TimeToPixel(frameTime);
EditorGUI.DrawRect(new Rect(prevFrameTimeXPos, prevFrameTimeYPos, frameTimeXPos - prevFrameTimeXPos, prevVelocityHeight), prevColor);
prevVelocity = m_Velocities[f];
prevVelocityHeight = 5.0f + (prevVelocity / maxVelocity) * 25.0f;
prevFrameTimeXPos = frameTimeXPos;
prevFrameTimeYPos = (height - prevVelocityHeight) / 2.0f;
prevColor = Color.Lerp(m_LowVelocityColor, m_HighVelocityColor, prevVelocity / maxVelocity);
}
var currentTimeXPos = converter.TimeToPixel(Time.unscaledTime - GameDebuggerDatabase.StartRecordingTime);
EditorGUI.DrawRect(new Rect(prevFrameTimeXPos, prevFrameTimeYPos, currentTimeXPos - prevFrameTimeXPos, prevVelocityHeight), prevColor);
}
protected override void DrawItem(Track track, ITimeConverter converter)
{
var oldColor = GUI.color;
for (int i = 0; i < m_Inputs.Count; i++)
{
if (m_Height[i] == -1)
{
m_Height[i] = s_Random.Next(0, 34);
}
var pixel = converter.TimeToPixel(m_Inputs[i].time);
var line = new Rect(pixel, 0, 3, 45);
var pos = new Rect(pixel + 3, m_Height[i], 50, 50);
foreach (var input in m_Inputs[i].inputs)
{
var color = StringToColor(input);
EditorGUI.DrawRect(line, color);
GUI.Label(pos, input);
}
}
GUI.color = oldColor;
}
public void StringInputConvertedAndBerlinClockRepresentationCalculatedAndVisualised()
{
this.berlinClockServiceMock = new Mock <IBerlineClockService>();
this.inputConverterServiceMock = new Mock <ITimeTextInputConverter>();
this.berlinClockVisualisationServiceMock = new Mock <IBerlinClockVisualisationService>();
this.timeConverter = new TimeConverter(this.inputConverterServiceMock.Object, this.berlinClockServiceMock.Object, this.berlinClockVisualisationServiceMock.Object);
string inputParam = "10:10:10";
TimeSpan mockTimeSpan = new TimeSpan();
this.inputConverterServiceMock.Setup(x => x.Convert(inputParam)).Returns(mockTimeSpan);
Mock <BerlinClockTimeRepresentation> timeRepresentationMock = new Mock <BerlinClockTimeRepresentation>();
string fakeStringRepresentation = "Fake";
berlinClockVisualisationServiceMock.Setup(x => x.TextVisualisation(timeRepresentationMock.Object))
.Returns(fakeStringRepresentation);
this.berlinClockServiceMock.Setup(x => x.RepresentTime(mockTimeSpan))
.Returns(timeRepresentationMock.Object);
string result = this.timeConverter.convertTime(inputParam);
Assert.AreEqual(fakeStringRepresentation, result);
}
public TheBerlinClockSteps(IServiceLocator serviceLocator)
{
_berlinClock = serviceLocator.Get <ITimeConverter>();
}
public AppointmentsFinder(IAppointmentRepository repository, ITimeConverter timeConverter)
{
_repository = repository;
_timeConverter = timeConverter;
}
public void Initialize()
{
_timeConver = new TimeConverter();
}
public TheBerlinClockSteps()
{
Container.Register();
berlinClock = TinyIoCContainer.Current.Resolve <ITimeConverter>();
}
public TheBerlinClockSteps()
{
var timeParser = new Time24hParser();
var clockRenderer = new TextClockRenderer("\n");
berlinClock = new TimeConverter(timeParser, clockRenderer);
}
public AppointmentsNotificationPolicy(Appointment appointment, ITimeConverter timeConverter)
{
_appointment = appointment;
_timeConverter = timeConverter;
}
public void Setup()
{
this.clockMock = new Mock <IClock>();
this.timeConverter = new TimeConverter(this.clockMock.Object);
}
public TheBerlinClockSteps()
{
Initialize();
berlinClock = container.Resolve <ITimeConverter>();
}
public TheBerlinClockSteps()
{
var toStringConverter = BerlinClockConverterFactory.GetStringConverter();
_timeConverter = new TimeConverter(toStringConverter);
}
public SecondsConversionCommand(ITimeConverter converter, string secondsTimeComponent)
{
this._converter = converter;
this._secondsTimeComponent = secondsTimeComponent;
}
public AppointmentsFinder(IAppointmentRepository repository, ITimeConverter timeConverter)
{
_repository = repository;
_timeConverter = timeConverter;
}
