public TimelineEvent CreateTimelineEvent()
{
TimelineEvent evt = new TimelineEvent ();
evtType1 = new EventType { Name = "Cat1" };
evt.EventType = evtType1;
evt.Notes = "notes";
evt.Selected = true;
evt.Team = TeamType.LOCAL;
evt.FieldPosition = new Coordinates ();
evt.FieldPosition.Points.Add (new Point (1, 2));
evt.HalfFieldPosition = new Coordinates ();
evt.HalfFieldPosition.Points.Add (new Point (4, 5));
evt.GoalPosition = new Coordinates ();
evt.GoalPosition.Points.Add (new Point (6, 7));
evt.Rate = 1.5f;
evt.Name = "Play";
evt.Start = new Time (1000);
evt.EventTime = new Time (1500);
evt.Stop = new Time (2000);
evt.Rate = 2.3f;
evt.Tags.Add (new Tag ("test"));
return evt;
}
public TimelineEventObject(TimelineEvent play, Project project)
: base(play)
{
Project = project;
// Only event boundaries can be dragged
DraggingMode = NodeDraggingMode.Borders;
}
public void LoadPlay(TimelineEvent play, Project project, bool editTags, bool editPos, bool editPlayers, bool editNotes)
{
this.play = play;
notesframe.Visible = editNotes;
tagger.Visible = editPos && (play.EventType.TagFieldPosition ||
play.EventType.TagHalfFieldPosition ||
play.EventType.TagGoalPosition);
drawingarea3.Visible = editPlayers;
nameframe.Visible = editTags;
tagsvbox.Visible = editTags;
nameentry.Text = play.Name;
nameentry.GrabFocus ();
if (editPos) {
tagger.LoadBackgrounds (project);
tagger.LoadPlay (play);
}
if (editNotes) {
notes.Play = play;
}
if (editPlayers) {
teamtagger.Project = project;
teamtagger.LoadTeams (project.LocalTeamTemplate, project.VisitorTeamTemplate,
project.Dashboard.FieldBackground);
/* Force lineup update */
teamtagger.CurrentTime = play.EventTime;
teamtagger.Select (play.Players, play.Team);
}
if (editTags) {
FillTags (project, play);
}
}
public override void AddPlay(TimelineEvent play)
{
TimelineEventObject po = new TimelineEventObject (play, project);
po.SelectionLeft = selectionBorderL;
po.SelectionRight = selectionBorderR;
po.OffsetY = OffsetY;
po.Height = Height;
po.SecondsPerPixel = SecondsPerPixel;
po.MaxTime = maxTime;
AddNode (po);
}
protected override bool IsVisibleByPlayer(TimelineEvent play)
{
if (play.Players.Count == 0 &&
VisiblePlayers.Count == Project.LocalTeamTemplate.PlayingPlayersList.Union (
Project.VisitorTeamTemplate.PlayingPlayersList).Count<Player> ()) {
return true;
} else {
return VisiblePlayers.Intersect (play.Players).Any ();
}
}
public FramesSeriesCapturer(MediaFileSet fileSet, TimelineEvent evt, uint interval, string outputDir)
{
this.capturer = Config.MultimediaToolkit.GetFramesCapturer ();
this.fileSet = fileSet;
this.evt = evt;
this.start = evt.Start;
this.stop = evt.Stop;
this.interval = interval;
this.outputDir = outputDir;
this.seriesName = System.IO.Path.GetFileName (outputDir);
this.totalFrames = ((int)Math.Floor ((double)((stop - start).MSeconds / interval)) + 1) * evt.CamerasConfig.Count;
this.cancel = false;
}
protected override bool IsVisibleByPeriod(TimelineEvent play)
{
if (periodsFilter.Count == 0)
return true;
bool period_match = false;
foreach (Period p in periodsFilter) {
if (p.PeriodNode.Join (play) != null) {
period_match = true;
}
}
return period_match;
}
public void TestAddDefaultPositions()
{
TimelineEvent evt = new TimelineEvent ();
evt.EventType = new EventType ();
evt.EventType.TagFieldPosition = false;
evt.EventType.TagHalfFieldPosition = false;
evt.EventType.TagGoalPosition = false;
Assert.IsNull (evt.FieldPosition);
Assert.IsNull (evt.HalfFieldPosition);
Assert.IsNull (evt.GoalPosition);
evt.AddDefaultPositions ();
Assert.IsNull (evt.FieldPosition);
Assert.IsNull (evt.HalfFieldPosition);
Assert.IsNull (evt.GoalPosition);
evt.EventType.TagFieldPosition = true;
evt.AddDefaultPositions ();
Assert.IsNotNull (evt.FieldPosition);
Assert.IsNull (evt.HalfFieldPosition);
Assert.IsNull (evt.GoalPosition);
evt.EventType.TagFieldPosition = false;
evt.EventType.TagHalfFieldPosition = true;
evt.AddDefaultPositions ();
Assert.IsNotNull (evt.FieldPosition);
Assert.IsNotNull (evt.HalfFieldPosition);
Assert.IsNull (evt.GoalPosition);
evt.EventType.TagFieldPosition = false;
evt.EventType.TagHalfFieldPosition = false;
evt.EventType.TagGoalPosition = true;
evt.AddDefaultPositions ();
Assert.IsNotNull (evt.FieldPosition);
Assert.IsNotNull (evt.HalfFieldPosition);
Assert.IsNotNull (evt.GoalPosition);
/* Adding the default positions doesn't not overwrite the existing data */
evt.EventType.FieldPositionIsDistance = true;
evt.EventType.HalfFieldPositionIsDistance = true;
evt.FieldPosition.Points [0].X = 100;
evt.FieldPosition.Points [0].Y = 100;
evt.HalfFieldPosition.Points [0].X = 100;
evt.HalfFieldPosition.Points [0].Y = 100;
evt.AddDefaultPositions ();
Assert.AreEqual (1, evt.FieldPosition.Points.Count);
Assert.AreEqual (1, evt.HalfFieldPosition.Points.Count);
Assert.AreEqual (100, evt.FieldPosition.Points [0].X);
Assert.AreEqual (100, evt.HalfFieldPosition.Points [0].X);
}
public void TestPropertiesProxy()
{
TimelineEvent evt = new TimelineEvent ();
evt.Start = new Time (1000);
evt.Stop = new Time (2000);
evt.CamerasLayout = 1;
evt.CamerasConfig = new List<CameraConfig> { new CameraConfig (2), new CameraConfig (4) };
PlaylistPlayElement element = new PlaylistPlayElement (evt);
Assert.AreEqual (evt.Duration, element.Duration);
Assert.AreEqual (evt.CamerasLayout, element.CamerasLayout);
Assert.AreEqual (evt.CamerasConfig, element.CamerasConfig);
Assert.AreEqual (evt.Rate, element.Rate);
Assert.AreEqual (evt.Name, element.Title);
}
public void AddEvent(TimelineEvent evt)
{
TreeIter piter;
if (evt.Players == null) {
return;
}
team.GetIterFirst (out piter);
while (team.IterIsValid (piter)) {
Player player = team.GetValue (piter, 0) as Player;
if (evt.Players.Contains (player)) {
team.AppendValues (piter, evt);
}
team.IterNext (ref piter);
}
}
public void LoadPlay(TimelineEvent play)
{
field.Visible = play.EventType.TagFieldPosition;
hfield.Visible = play.EventType.TagHalfFieldPosition;
goal.Visible = play.EventType.TagGoalPosition;
play.AddDefaultPositions ();
if (play.FieldPosition != null) {
field.Tagger.Points = play.FieldPosition.Points;
}
if (play.HalfFieldPosition != null) {
hfield.Tagger.Points = play.HalfFieldPosition.Points;
}
if (play.GoalPosition != null) {
goal.Tagger.Points = play.GoalPosition.Points;
}
}
public void TestSerialization()
{
TimelineEvent evt = new TimelineEvent ();
evt.Start = new Time (1000);
evt.Stop = new Time (2000);
evt.CamerasLayout = 1;
evt.CamerasConfig.Add (new CameraConfig (0));
PlaylistPlayElement element = new PlaylistPlayElement (evt);
Utils.CheckSerialization (element);
PlaylistPlayElement element2 = Utils.SerializeDeserialize (element);
Assert.AreEqual (element.Description, element2.Description);
Assert.AreEqual (element.Duration, element2.Duration);
Assert.AreEqual (element.Rate, element2.Rate);
Assert.AreEqual (element.RateString, element2.RateString);
Assert.AreEqual (element.Title, element2.Title);
Assert.AreEqual (new List<CameraConfig> { new CameraConfig (0) }, element2.CamerasConfig);
Assert.AreEqual (element.CamerasLayout, element2.CamerasLayout);
}
void HandlePlayLoaded(TimelineEvent play)
{
Play = play;
}
public TimelineEventObject Load(TimelineEvent evt)
{
return nodes.FirstOrDefault (n => (n as TimelineEventObject).Event == evt) as TimelineEventObject;
}
public void TestTimeNodeChanged()
{
TimelineEvent timelineEvent = new TimelineEvent ();
timelineEvent.Start = new Time (10);
timelineEvent.Stop = new Time (20);
App.Current.EventsBroker.Publish<TimeNodeChangedEvent> (
new TimeNodeChangedEvent {
TimeNode = timelineEvent,
Time = new Time (5)
}
);
mockPlayerController.Verify (p => p.LoadEvent (timelineEvent, new Time (5), false), Times.Once);
}
public void EmitNewDashboardEvent(TimelineEvent evt, DashboardButton btn, bool edit, List<DashboardButton> from)
{
if (NewDashboardEventEvent != null) {
if (from == null)
from = new List<DashboardButton> ();
NewDashboardEventEvent (evt, btn, edit, from);
}
}
public void EmitLoadEvent(TimelineEvent evt)
{
if (LoadEventEvent != null)
LoadEventEvent (evt);
}
public void EmitEventEdited(TimelineEvent play)
{
if (EventEditedEvent != null) {
EventEditedEvent (play);
}
}
public void EmitDrawFrame(TimelineEvent play, int drawingIndex, CameraConfig camConfig, bool current)
{
if (DrawFrame != null) {
DrawFrame (play, drawingIndex, camConfig, current);
}
}
public TreePath AddEvent(TimelineEvent evt, TreeIter evtTter)
{
TreeIter childIter = childModel.AppendValues (evtTter, evt);
TreePath childPath = childModel.GetPath (childIter);
TreePath path = modelSort.ConvertChildPathToPath (
modelFilter.ConvertChildPathToPath (childPath));
return path;
}
public void EmitEventCreated(TimelineEvent evt)
{
if (EventCreatedEvent != null) {
EventCreatedEvent (evt);
}
}
public void AddPlay(TimelineEvent play)
{
playsSelection.AddPlay (play);
codingwidget.AddPlay (play);
}
public void EmitEventLoaded(TimelineEvent play)
{
if (EventLoadedEvent != null)
EventLoadedEvent (play);
}
public void TestLoadPlayEvent()
{
TimelineEvent element = new TimelineEvent { Start = new Time (0), Stop = new Time (5) };
App.Current.EventsBroker.Publish<LoadEventEvent> (
new LoadEventEvent {
TimelineEvent = element
}
);
mockPlayerController.Verify (player => player.LoadEvent (element, new Time (0), true),
Times.Once ());
}
public virtual void EmitMoveToEventType(TimelineEvent evnt, EventType eventType)
{
if (MoveToEventTypeEvent != null)
MoveToEventTypeEvent (evnt, eventType);
}
public void TestLoadPlayEventFake()
{
var project = new ProjectLongoMatch ();
OpenProject (project, ProjectType.FakeCaptureProject);
TimelineEvent element = new TimelineEvent ();
App.Current.EventsBroker.Publish<LoadEventEvent> (
new LoadEventEvent {
TimelineEvent = element
}
);
mockPlayerController.Verify (player => player.Seek (It.IsAny<Time> (), It.IsAny<bool> (),
It.IsAny<bool> (), It.IsAny<bool> ()), Times.Never ());
mockPlayerController.Verify (player => player.Play (false), Times.Never ());
}
public void EmitSnapshotSeries(TimelineEvent play)
{
if (SnapshotSeries != null)
SnapshotSeries (play);
}
public void TestLoadPlayEventWithoutDuration()
{
TimelineEvent element = new TimelineEvent { Start = new Time (0), Stop = new Time (0) };
App.Current.EventsBroker.Publish<LoadEventEvent> (
new LoadEventEvent {
TimelineEvent = element
}
);
mockPlayerController.Verify (
player => player.Seek (element.EventTime, true, false, false), Times.Once ());
mockPlayerController.Verify (player => player.Play (false), Times.Once ());
}
void HandlePlayLoaded(EventLoadedEvent e)
{
loadedPlay = e.TimelineEvent;
}
public void TestPrev()
{
TimelineEvent element = new TimelineEvent ();
App.Current.EventsBroker.Publish<LoadEventEvent> (
new LoadEventEvent {
TimelineEvent = element
}
);
// loadedPlay != null
mockPlayerController.ResetCalls ();
App.Current.EventsBroker.Publish<PreviousPlaylistElementEvent> (
new PreviousPlaylistElementEvent ()
);
mockPlayerController.Verify (player => player.Previous (false), Times.Once ());
}
