/// <summary>
/// Синхронизирован ли уже указанный плеер
/// </summary>
/// <param name="v">ВМ-ка плеера</param>
/// <returns></returns>
bool IsPlayerAlreadySyncronized(VideoPlayerVM v)
{
if (!v.IsSyncronizeLeader)
{
if (v.SyncronizationShiftVM.ShiftTime + VM.TimeSyncLead > v.Duration)
{
if (!(v.CurTime <= v.Duration && v.CurTime > v.Duration - TimeSpan.FromSeconds(0.02)))
{
return(false);
}
}
else if (v.SyncronizationShiftVM.ShiftTime + VM.TimeSyncLead <= TimeSpan.Zero)
{
if (!(v.CurTime >= TimeSpan.Zero && v.CurTime < TimeSpan.FromSeconds(0.02)))
{
return(false);
}
}
else
{
TimeSpan t = v.SyncronizationShiftVM.ShiftTime + VM.TimeSyncLead;
if (!(v.CurTime >= t - TimeSpan.FromSeconds(0.01) && v.CurTime <= t + TimeSpan.FromSeconds(0.01)))
{
return(false);
}
}
}
return(true);
}
public void SetUp()
{
controller = new LMEventsController();
playerController = new Mock <IVideoPlayerController> ();
videoPlayer = new VideoPlayerVM {
Player = playerController.Object,
CamerasConfig = new ObservableCollection <CameraConfig> ()
};
Mock <IVideoPlayer> playerMock = new Mock <IVideoPlayer> ();
playerMock.SetupAllProperties();
projectVM = new LMProjectVM {
Model = Utils.CreateProject(true)
};
controller.SetViewModel(new LMProjectAnalysisVM {
Project = projectVM,
VideoPlayer = videoPlayer
});
var mtkMock = new Mock <IMultimediaToolkit> ();
mtkMock.Setup(m => m.GetPlayer()).Returns(playerMock.Object);
App.Current.MultimediaToolkit = mtkMock.Object;
controller.Start();
}
public MainView(VideoPlayerVM videoPlayerVM)
{
InitializeComponent();
this.DataContext = videoPlayerVM;
this.Loaded += videoPlayerVM.Window_Loaded;
this.Loaded += MainView_Loaded;
}
public void SetUp()
{
videoPlayerVM = new VideoPlayerVM();
videoPlayerControllerMock = new Mock <IVideoPlayerController> ();
videoPlayerVM.Player = videoPlayerControllerMock.Object;
Project project = Utils.CreateProject(false);
var period = new Period();
period.Nodes.Add(new TimeNode {
Start = new Time(0),
Stop = new Time(3000)
});
project.Periods.Add(period);
projectVM = new DummyProjectVM {
Model = project
};
camSyncVM = new CameraSynchronizationVM {
VideoPlayer = videoPlayerVM, Project = projectVM
};
camSyncController = new CameraSynchronizationController();
videoPlayerControllerMock.ResetCalls();
stateControllerMock.ResetCalls();
KeyContext context = new KeyContext();
foreach (KeyAction action in camSyncController.GetDefaultKeyActions())
{
context.AddAction(action);
}
App.Current.KeyContextManager.NewKeyContexts(new List <KeyContext> {
context
});
}
public TimeDiffVideo(bool isSyncLead, string fileName, TimeDiffPosition position, VideoPlayerVM videoPlayerVM)
{
FileName = fileName;
IsSyncLead = isSyncLead;
CurrentPosition = position;
SnapShotsOnPositions = new Dictionary <int, System.Drawing.Bitmap>();
VideoPlayerVM = videoPlayerVM;
}
public MainView()
{
InitializeComponent();
VideoPlayerVM VM = new VideoPlayerVM();
this.DataContext = VM;
this.Loaded += VM.Window_Loaded;
}
public void FixtureSetup()
{
mockList = new List <Mock> ();
settings = new CaptureSettings();
settings.EncodingSettings = new EncodingSettings();
settings.EncodingSettings.EncodingProfile = EncodingProfiles.MP4;
App.Current.HotkeysService = new HotkeysService();
GeneralUIHotkeys.RegisterDefaultHotkeys();
LMGeneralUIHotkeys.RegisterDefaultHotkeys();
var playerMock = new Mock <IVideoPlayer> ();
playerMock.SetupAllProperties();
mockList.Add(playerMock);
capturerMock = new Mock <ICapturer> ();
capturerMock.SetupAllProperties();
mockList.Add(capturerMock);
mtkMock = new Mock <IMultimediaToolkit> ();
mtkMock.Setup(m => m.GetPlayer()).Returns(playerMock.Object);
mtkMock.Setup(m => m.GetMultiPlayer()).Throws(new Exception());
mtkMock.Setup(m => m.GetCapturer()).Returns(capturerMock.Object);
mtkMock.Setup(m => m.DiscoverFile(It.IsAny <string> (), It.IsAny <bool> ()))
.Returns((string s, bool b) => new MediaFile {
FilePath = s
});
App.Current.MultimediaToolkit = mtkMock.Object;
mockList.Add(mtkMock);
gtkMock = new Mock <IGUIToolkit> ();
gtkMock.SetupGet(o => o.DeviceScaleFactor).Returns(1.0f);
gtkMock.Setup(m => m.Invoke(It.IsAny <EventHandler> ())).Callback <EventHandler> (e => e(null, null));
gtkMock.Setup(g => g.RemuxFile(It.IsAny <string> (), It.IsAny <string> (), It.IsAny <VideoMuxerType> ()))
.Returns(() => settings.EncodingSettings.OutputFile)
.Callback((string s, string d, VideoMuxerType m) => File.Copy(s, d));
gtkMock.Setup(g => g.EndCapture(true)).Returns(EndCaptureResponse.Save);
App.Current.GUIToolkit = gtkMock.Object;
mockList.Add(gtkMock);
capturerBinMock = new Mock <ICapturerBin> ();
capturerBinMock.Setup(w => w.Capturer).Returns(capturerMock.Object);
capturerBinMock.Setup(w => w.CaptureSettings).Returns(() => settings);
capturerBinMock.Setup(w => w.Periods).Returns(() => new List <Period> ());
mockList.Add(capturerBinMock);
player = new VideoPlayerController();
videoPlayerVM = new VideoPlayerVM();
videoPlayerVM.Player = player;
player.SetViewModel(videoPlayerVM);
currentService = App.Current.LicenseLimitationsService;
stateControllerMock = new Mock <IStateController> ();
App.Current.StateController = stateControllerMock.Object;
}
public StripeVM(VideoPlayerVM videoPlayerVM, StripeContainerVM stripeContainerVM, Stripe body)
{
VideoPlayerVM = videoPlayerVM;
Body = body;
StripeContainerVM = stripeContainerVM;
Body.DataContext = this;
VideoPlayerVM.SyncronizationShiftVM.PropertyChanged += SyncronizationShiftVM_PropertyChanged;
VideoPlayerVM.PropertyChanged += VideoPlayerVM_PropertyChanged;
Body.UpFocus += Body_UpFocus;
}
public override void SetViewModel(IViewModel viewModel)
{
cameraSynchronizationVM = (CameraSynchronizationVM)viewModel;
if (viewModel != null)
{
videoPlayerVM = cameraSynchronizationVM.VideoPlayer;
projectVM = cameraSynchronizationVM.Project;
InitPeriods();
}
}
public SubtitleMediaController()
{
InitializeComponent();
var videoplayerViewModel = new VideoPlayerVM(this);
this.DataContext = videoplayerViewModel;
this.Loaded += (s, e) => {
videoplayerViewModel.Loaded();
};
this.controlRegion.Content = this.MediaController;
}
public void TestChangeVolume()
{
var playerController = new Mock <IVideoPlayerController> ();
playerController.SetupAllProperties();
var viewModel = new VideoPlayerVM {
Player = playerController.Object
};
viewModel.ChangeVolumeCommand.Execute(3D);
Assert.AreEqual(3D / 100, playerController.Object.Volume);
}
public void MoveROI_ROIMoved()
{
var playerController = new Mock <IVideoPlayerController> ();
playerController.SetupAllProperties();
var viewModel = new VideoPlayerVM {
Player = playerController.Object
};
viewModel.MoveROI(new Point(1, 3));
playerController.Verify(p => p.MoveROI(new Point(1, 3)));
}
public void Setup()
{
var drawingToolkitMock = new Mock <IDrawingToolkit> ();
drawingToolkitMock.Setup(d => d.CreateSurfaceFromIcon(It.IsAny <string> (), It.IsAny <bool> (), It.IsAny <bool> ())).
Returns(Mock.Of <ISurface> ());
App.Current.DrawingToolkit = drawingToolkitMock.Object;
widgetMock = new Mock <IWidget> ();
timerule = new Timerule(widgetMock.Object);
videoPlayer = new VideoPlayerVM();
timerule.SetViewModel(videoPlayer);
videoPlayerMock = new Mock <IVideoPlayerController> ();
videoPlayer.Player = videoPlayerMock.Object;
}
public void TestUpdateVolume()
{
var playerController = new Mock <IVideoPlayerController> ();
playerController.SetupAllProperties();
var viewModel = new VideoPlayerVM {
Player = playerController.Object
};
// Volume changes the VM property but not the actual volume
viewModel.Volume = 5;
Assert.AreEqual(0, playerController.Object.Volume);
}
public void TestUpdatePlaybackRate()
{
var playerController = new Mock <IVideoPlayerController> ();
playerController.SetupAllProperties();
var viewModel = new VideoPlayerVM {
Player = playerController.Object
};
// Rate changes the VM property but not the actual playback rate
viewModel.Rate = 3;
Assert.AreEqual(0, playerController.Object.Rate);
}
void AnalysisSetUp()
{
var viewModel = new LMProjectAnalysisVM();
viewModel.VideoPlayer = new VideoPlayerVM();
videoPlayer = viewModel.VideoPlayer;
teamTagger = viewModel.TeamTagger;
viewModel.Project = new LMProjectVM {
Model = Utils.CreateProject()
};
ControllerSetUp(viewModel);
eventsController = new LMEventsController();
eventsController.SetViewModel(viewModel);
eventsController.Start();
}
public void EditEventDurationCommand_Initialized_CommandCallsController()
{
var playerController = new Mock <IVideoPlayerController> ();
playerController.SetupAllProperties();
var viewModel = new VideoPlayerVM {
Player = playerController.Object
};
viewModel.EditEventDurationCommand.Executable = true;
viewModel.EditEventDurationCommand.Execute(true);
playerController.Verify(p => p.SetEditEventDurationMode(true));
}
public override void SetViewModel(IViewModel viewModel)
{
TeamTagger = ((ILMTeamTaggerDealer)viewModel).TeamTagger;
var analysisVM = viewModel as IAnalysisViewModel;
if (analysisVM != null)
{
isAnalysis = true;
Project = (LMProjectVM)analysisVM.Project;
VideoPlayer = analysisVM.VideoPlayer;
}
else
{
Project = (LMProjectVM)(viewModel as IProjectDealer)?.Project;
}
}
public void SetZoom_NoLimited_ViewModelUpdated()
{
Mock <ILicenseLimitationsService> mockService = new Mock <ILicenseLimitationsService> ();
App.Current.LicenseLimitationsService = mockService.Object;
mockService.Setup(s => s.CanExecute(VASFeature.Zoom.ToString())).Returns(true);
var playerController = new Mock <IVideoPlayerController> ();
playerController.SetupAllProperties();
var viewModel = new VideoPlayerVM {
Player = playerController.Object
};
viewModel.SetZoomCommand.Execute(3.0f);
playerController.Verify(p => p.SetZoom(3.0f), Times.Once);
}
public void ShowZoom_Limited_MoveToUpgradeDialog()
{
Mock <ILicenseLimitationsService> mockService = new Mock <ILicenseLimitationsService> ();
App.Current.LicenseLimitationsService = mockService.Object;
mockService.Setup(s => s.CanExecute(VASFeature.Zoom.ToString())).Returns(false);
var playerController = new Mock <IVideoPlayerController> ();
playerController.SetupAllProperties();
var viewModel = new VideoPlayerVM {
Player = playerController.Object
};
viewModel.ShowZoomCommand.Execute();
mockService.Verify(s => s.MoveToUpgradeDialog(VASFeature.Zoom.ToString()), Times.Once);
}
public void TestChangePlaybackRate()
{
var playerController = new Mock <IVideoPlayerController> ();
playerController.SetupAllProperties();
var viewModel = new VideoPlayerVM {
Player = playerController.Object
};
App.Current.RateList = new List <double> ()
{
3D
};
viewModel.ChangeRateCommand.Execute(0D);
Assert.AreEqual(3D, playerController.Object.Rate);
}
public void ChangeVolumeCommand_NewVideoPlayerVM_PlayerVolumeSettedTo0dot5()
{
///Arrange
var playerController = new Mock <IVideoPlayerController> ();
playerController.SetupAllProperties();
var target = new VideoPlayerVM {
Player = playerController.Object
};
///Act
target.ChangeVolumeCommand.Execute(50.0D);
///Assert
playerController.VerifySet(p => p.Volume, Times.Once());
Assert.AreEqual(0.5D, target.Player.Volume);
}
public void PreviousCommand_NewVideoPlayerVM_PlayerPreviousInvoked()
{
///Arrange
var playerController = new Mock <IVideoPlayerController> ();
playerController.SetupAllProperties();
var target = new VideoPlayerVM {
Player = playerController.Object
};
///Act
target.PreviousCommand.Execute();
///Assert
playerController.Verify(p => p.Previous(false), Times.Once());
}
public void ShowZoom_NoLimited_ViewModelUpdated()
{
Mock <ILicenseLimitationsService> mockService = new Mock <ILicenseLimitationsService> ();
App.Current.LicenseLimitationsService = mockService.Object;
mockService.Setup(s => s.CanExecute(VASFeature.Zoom.ToString())).Returns(true);
var playerController = new Mock <IVideoPlayerController> ();
playerController.SetupAllProperties();
var viewModel = new VideoPlayerVM {
Player = playerController.Object
};
Assert.IsFalse(viewModel.ShowZoom);
viewModel.ShowZoomCommand.Execute();
Assert.IsTrue(viewModel.ShowZoom);
}
public void StepForwardCommand_NewVideoPlayerVM_StepForwardInvoked()
{
///Arrange
var playerController = new Mock <IVideoPlayerController> ();
playerController.SetupAllProperties();
var target = new VideoPlayerVM {
Player = playerController.Object
};
///Act
target.StepForwardCommand.Execute();
///Assert
playerController.Verify(p => p.StepForward(), Times.Once());
}
public void ReadyCommand_NewVideoPlayerVM_PlayerReadyInvoked()
{
///Arrange
var playerController = new Mock <IVideoPlayerController> ();
playerController.SetupAllProperties();
var target = new VideoPlayerVM {
Player = playerController.Object
};
///Act
target.ReadyCommand.Execute(true);
///Assert
playerController.Verify(p => p.Ready(true), Times.Once());
}
public void CloseCommand_NewVideoPlayerVM_PlayerUnloadCurrentEventInvoked()
{
///Arrange
var playerController = new Mock <IVideoPlayerController> ();
playerController.SetupAllProperties();
var target = new VideoPlayerVM {
Player = playerController.Object
};
///Act
target.CloseCommand.Execute();
///Assert
playerController.Verify(p => p.UnloadCurrentEvent(), Times.Once());
}
public void ViewPortsSwitchToggleCommand_NewVideoPlayerVM_PlayerDetachCommandInvoked()
{
///Arrange
var playerController = new Mock <IVideoPlayerController> ();
playerController.SetupAllProperties();
var target = new VideoPlayerVM {
Player = playerController.Object
};
///Act
target.ViewPortsSwitchToggleCommand.Execute();
///Assert
Assert.IsFalse(target.ViewPortsSwitchActive);
}
public void SeekCommand_NewVideoPlayerVM_PlayerSeekInvoked()
{
///Arrange
var playerController = new Mock <IVideoPlayerController> ();
playerController.SetupAllProperties();
var time = new Time(1234);
var target = new VideoPlayerVM {
Player = playerController.Object
};
///Act
target.SeekCommand.Execute(new VideoPlayerSeekOptions(time));
///Assert
playerController.Verify(p => p.Seek(time, false, false, false), Times.Once());
}
public async Task Setup()
{
videoPlayerMock = new Mock <IVideoPlayerController> ();
videoPlayerMock.SetupGet(p => p.CurrentTime).Returns(new Time(100));
videoPlayerMock.SetupGet(p => p.CurrentFrame).Returns(Utils.LoadImageFromFile());
videoPlayer = new VideoPlayerVM {
Player = videoPlayerMock.Object
};
mToolkitMock = new Mock <IMultimediaToolkit> ();
framesCapturerMock = new Mock <IFramesCapturer> ();
mToolkitMock.Setup(m => m.GetFramesCapturer()).Returns(framesCapturerMock.Object);
stateControllerMock = new Mock <IStateController> ();
stateControllerMock.Setup(sc => sc.MoveToModal(It.IsAny <string> (), It.IsAny <object> (), It.IsAny <bool> ())).Callback(
(string s, Object e, bool f) => {
properties = (ExpandoObject)e;
});
App.Current.StateController = stateControllerMock.Object;
App.Current.MultimediaToolkit = mToolkitMock.Object;
controller = new DrawingsController();
await controller.Start();
}
