private async Task PlaySongInternal(SongRequestItem item)
{
if (item != null)
{
if (item.Type == SongRequestServiceTypeEnum.Spotify)
{
if (ChannelSession.Services.Spotify != null)
{
SpotifySong song = await ChannelSession.Services.Spotify.GetSong(item.ID);
if (song != null)
{
await ChannelSession.Services.Spotify.PlaySong(song);
this.currentSong = item;
}
}
}
else if (item.Type == SongRequestServiceTypeEnum.YouTube)
{
IOverlayService overlay = ChannelSession.Services.OverlayServers.GetOverlay(ChannelSession.Services.OverlayServers.DefaultOverlayName);
if (overlay != null)
{
await overlay.SendSongRequest(new OverlaySongRequest()
{
Type = SongRequestServiceTypeEnum.YouTube.ToString(), Action = "song", Source = item.ID, Volume = ChannelSession.Settings.SongRequestVolume
});
this.currentSong = item;
}
}
}
}
public StateViewModel(IRecordDirectoryObserver recordObserver,
IEventAggregator eventAggregator,
IAppConfiguration appConfiguration,
ICaptureService captureService,
IOverlayService overlayService,
IUpdateCheck updateCheck,
IAppVersionProvider appVersionProvider,
IWebVersionProvider webVersionProvider,
LoginManager loginManager,
IRTSSService rTSSService,
ILogger <StateViewModel> logger)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
_recordObserver = recordObserver;
_eventAggregator = eventAggregator;
_appConfiguration = appConfiguration;
_captureService = captureService;
_overlayService = overlayService;
_updateCheck = updateCheck;
_appVersionProvider = appVersionProvider;
_logger = logger;
IsCaptureModeActive = false;
IsOverlayActive = _appConfiguration.IsOverlayActive && rTSSService.IsRTSSInstalled();
_captureService.IsCaptureModeActiveStream
.Subscribe(state => IsCaptureModeActive = state);
_captureService.IsLoggingActiveStream
.Subscribe(state => IsLoggingActive = state);
_overlayService.IsOverlayActiveStream
.Subscribe(state => IsOverlayActive = state);
IsLoggedIn = loginManager.State.Token != null;
_eventAggregator.GetEvent <PubSubEvent <AppMessages.LoginState> >().Subscribe(state =>
{
IsLoggedIn = state.IsLoggedIn;
RaisePropertyChanged(nameof(IsLoggedIn));
});
Task.Run(async() =>
{
var(updateAvailable, updateVersion) = await _updateCheck.IsUpdateAvailable();
Dispatcher.CurrentDispatcher.Invoke(() =>
{
IsUpdateAvailable = updateAvailable;
UpdateHyperlinkText = $"New version available on GitHub: v{updateVersion}";
RaisePropertyChanged(nameof(IsUpdateAvailable));
});
});
stopwatch.Stop();
_logger.LogInformation(this.GetType().Name + " {initializationTime}s initialization time", Math.Round(stopwatch.ElapsedMilliseconds * 1E-03, 1));
}
public SelectProfileBubble(IOverlayService overlayService)
{
BackgroundColor = "DarkGrey";
Name = "Select profile";
Icon = "mdi-arrow-left-right";
_overlayService = overlayService;
}
public ErrorMessageViewModel(IEventAggregator eventAggregator, IOverlayService overlayService)
{
_eventAggregator = eventAggregator;
_overlayService = overlayService;
_eventAggregator.GetEvent <UpdateErrorView>().Subscribe(OnUpdateErrorView);
CloseCommand = new DelegateCommand(() => _overlayService.RemoveOverlay());
}
public StateViewModel(IRecordDirectoryObserver recordObserver,
IEventAggregator eventAggregator,
IAppConfiguration appConfiguration,
ICaptureService captureService,
IOverlayService overlayService,
IUpdateCheck updateCheck,
IAppVersionProvider appVersionProvider,
IWebVersionProvider webVersionProvider)
{
_recordObserver = recordObserver;
_eventAggregator = eventAggregator;
_appConfiguration = appConfiguration;
_captureService = captureService;
_overlayService = overlayService;
_updateCheck = updateCheck;
_appVersionProvider = appVersionProvider;
IsDirectoryObserving = true;
IsCaptureModeActive = false;
IsOverlayActive = _appConfiguration.IsOverlayActive && !string.IsNullOrEmpty(RTSSUtils.GetRTSSFullPath());
UpdateHyperlinkText = $"New version available on GitHub: v{webVersionProvider.GetWebVersion()}";
_recordObserver.HasValidSourceStream
.Subscribe(state => IsDirectoryObserving = state);
_captureService.IsCaptureModeActiveStream
.Subscribe(state => IsCaptureModeActive = state);
_overlayService.IsOverlayActiveStream
.Subscribe(state => IsOverlayActive = state);
}
public SelectEntitiesBubble(IOverlayService overlayService)
{
BackgroundColor = "DarkGrey";
Name = "Select entities";
Icon = "mdi-plus";
_overlayService = overlayService;
}
/// <summary>
/// Creates an instance of the chat room view model and resolves its dependencies
/// </summary>
/// <param name="eventAggregator"></param>
/// <param name="networkConnectionController"></param>
/// <param name="currentUser"></param>
/// <param name="chatManager"></param>
/// <param name="regionManager"></param>
/// <param name="overlayService"></param>
public ChatRoomViewModel(IEventAggregator eventAggregator, INetworkConnectionController networkConnectionController, ICurrentUser currentUser, IChatManager chatManager, IRegionManager regionManager, IOverlayService overlayService)
{
//assigns local variables
_eventAggregator = eventAggregator;
_networkConnectionController = networkConnectionController;
_currentUser = currentUser;
_chatManager = chatManager;
_regionManager = regionManager;
_overlayService = overlayService;
_eventAggregator.GetEvent <UserLoginEvent>().Subscribe(UserLogin);
_eventAggregator.GetEvent <OfflineUsersLoadedEvent>().Subscribe(() => IsConnectAllowed = true);
_eventAggregator.GetEvent <UserEditedEvent>().Subscribe((user) => User = user);
//Sets up the basic server settings
ServerModel = new ServerModel();
ServerModel.IpAddress = "192.168.1.97";
ServerModel.Port = 2500;
ServerModel.ServerStatus = ServerStatus.Disconnected;
//Sets up command executions
ServerConnectCommand = new DelegateCommand(Connect);
ToggleBaseCommand = new DelegateCommand <object>(ToggleBaseColor);
CurrentUserClickedCommand = new DelegateCommand(CurrentUserClicked);
LogoutCommand = new DelegateCommand(Logout);
}
public async Task HideItem()
{
IOverlayService overlay = this.GetOverlay();
if (overlay != null)
{
await overlay.HideItem(this.Item);
}
}
public async Task UpdateItem(UserViewModel user, IEnumerable <string> arguments, Dictionary <string, string> extraSpecialIdentifiers)
{
IOverlayService overlay = this.GetOverlay();
if (overlay != null)
{
await overlay.UpdateItem(this.Item, user, arguments, extraSpecialIdentifiers);
}
}
public MainViewModel(IDiagnosticsViewModel diagnosticsViewModel,
ITabularDataService tabularDataService,
IColumnsService columnsService,
IOverlayService overlayService,
IDateTimeService dateTimeService,
ISchedulerService schedulerService)
{
_tabularDataService = tabularDataService;
_schedulerService = schedulerService;
_columnsService = columnsService;
_overlayService = overlayService;
_dateTimeService = dateTimeService;
Diagnostics = diagnosticsViewModel;
_dataIds = new Dictionary <object, DynamicDataViewModel>(1000);
_data = new CustomTypeRangeObservableCollection <DynamicDataViewModel>();
_collectionView = new ListCollectionView(_data)
{
Filter = FilterData
};
_updateStats = new Dictionary <long, int>();
RefreshCommand = ReactiveCommand.Create()
.DisposeWith(this);
ClearCommand = ReactiveCommand.Create()
.DisposeWith(this);
ColumnPickerCommand = ReactiveCommand.Create(HasDataChanged)
.DisposeWith(this);
_dataStream = InitialiseAndProcessDataAsync()
.DisposeWith(this);
RefreshCommand.Subscribe(x => Refresh())
.DisposeWith(this);
ClearCommand.Subscribe(x => Clear())
.DisposeWith(this);
ColumnPickerCommand.Subscribe(x => ShowColumnPicker())
.DisposeWith(this);
_suspendNotifications = new SerialDisposable()
.DisposeWith(this);
FilterChanged.Subscribe(x => _collectionView.Refresh())
.DisposeWith(this);
ColumnsChanged.ObserveOn(schedulerService.Dispatcher)
.Subscribe(x => OnPropertyChanged(nameof(VisibleColumns)))
.DisposeWith(this);
Disposable.Create(() => Clear())
.DisposeWith(this);
}
private async Task HideWidget(OverlayWidget widget)
{
IOverlayService overlay = ChannelSession.Services.OverlayServers.GetOverlay(widget.OverlayName);
if (overlay != null)
{
await overlay.RemoveItem(widget.Item);
}
}
/// <summary>
/// Called when it is time for the tab order UI to go away.
/// </summary>
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (region != null)
{
region.Dispose();
region = null;
}
if (host != null)
{
IOverlayService os = (IOverlayService)host.GetService(typeof(IOverlayService));
if (os != null)
{
os.RemoveOverlay(this);
}
IEventHandlerService ehs = (IEventHandlerService)host.GetService(typeof(IEventHandlerService));
if (ehs != null)
{
ehs.PopHandler(this);
}
IMenuCommandService mcs = (IMenuCommandService)host.GetService(typeof(IMenuCommandService));
if (mcs != null)
{
foreach (MenuCommand mc in newCommands)
{
mcs.RemoveCommand(mc);
}
}
// We sync add, remove and change events so we remain in sync with any nastiness that the
// form may pull on us.
//
IComponentChangeService cs = (IComponentChangeService)host.GetService(typeof(IComponentChangeService));
if (cs != null)
{
cs.ComponentAdded -= new ComponentEventHandler(OnComponentAddRemove);
cs.ComponentRemoved -= new ComponentEventHandler(OnComponentAddRemove);
cs.ComponentChanged -= new ComponentChangedEventHandler(OnComponentChanged);
}
IHelpService hs = (IHelpService)host.GetService(typeof(IHelpService));
if (hs != null)
{
hs.RemoveContextAttribute("Keyword", "TabOrderView");
}
host = null;
}
}
base.Dispose(disposing);
}
public async Task RemoveOverlay(string name)
{
IOverlayService overlay = this.GetOverlay(name);
if (overlay != null)
{
overlay.OnWebSocketConnectedOccurred -= Overlay_OnWebSocketConnectedOccurred;
overlay.OnWebSocketDisconnectedOccurred -= Overlay_OnWebSocketDisconnectedOccurred;
await overlay.Disconnect();
this.overlays.Remove(name);
}
}
public LoginViewModel(IRegionManager regionManager, IPasswordProtectionService passwordProtectionService, IEventAggregator eventAggregator, INetworkConnectionController networkConnectionController, ICurrentUser currentUser, IOverlayService overlayService)
{
_regionManager = regionManager;
_passwordProtectionService = passwordProtectionService;
_eventAggregator = eventAggregator;
_networkConnectionController = networkConnectionController;
_currentUser = currentUser;
_overlayService = overlayService;
PasswordChangedCommand = new DelegateCommand <object>(PasswordChanged);
LoginCommand = new DelegateCommand(Login);
RegisterCommand = new DelegateCommand(Register);
}
private async Task PlayPauseOverlaySong(SongRequestServiceTypeEnum type)
{
IOverlayService overlay = ChannelSession.Services.OverlayServers.GetOverlay(ChannelSession.Services.OverlayServers.DefaultOverlayName);
if (overlay != null)
{
await overlay.SendSongRequest(new OverlaySongRequest()
{
Type = type.ToString(), Action = "playpause", Volume = ChannelSession.Settings.SongRequestVolume
});
}
}
private async Task SkipToNextSongInternal()
{
if (this.allRequests.Count > 0 && this.allRequests.First().Equals(this.currentSong))
{
this.allRequests.RemoveAt(0);
}
else if (this.playlistItems.Count > 0 && this.playlistItems.First().Equals(this.currentSong))
{
this.playlistItems.RemoveAt(0);
}
if (this.currentSong != null)
{
if (this.currentSong.Type == SongRequestServiceTypeEnum.Spotify)
{
await ChannelSession.Services.Spotify.PauseCurrentlyPlaying();
this.spotifyStatus = null;
}
else if (this.currentSong.Type == SongRequestServiceTypeEnum.YouTube)
{
IOverlayService overlay = ChannelSession.Services.OverlayServers.GetOverlay(ChannelSession.Services.OverlayServers.DefaultOverlayName);
if (overlay != null)
{
await overlay.SendSongRequest(new OverlaySongRequest()
{
Type = SongRequestServiceTypeEnum.YouTube.ToString(), Action = "stop", Volume = ChannelSession.Settings.SongRequestVolume
});
this.youTubeStatus = null;
}
}
this.currentSong.State = SongRequestStateEnum.Ended;
this.currentSong = null;
}
SongRequestItem newSong = null;
if (this.allRequests.Count > 0)
{
newSong = this.allRequests.First();
}
else if (this.playlistItems.Count > 0)
{
newSong = this.playlistItems.First();
}
if (newSong != null)
{
await this.PlaySongInternal(newSong);
}
}
public RegisterViewModel(IFileProcessorService fileProcessorService, IRegionManager regionManager, IPasswordProtectionService passwordProtectionService, IOverlayService overlayService)
{
_fileProcessorService = fileProcessorService;
_regionManager = regionManager;
_passwordProtectionService = passwordProtectionService;
_overlayService = overlayService;
SelectImageCommand = new DelegateCommand(SelectImage);
PasswordChangedCommand = new DelegateCommand <object>(PasswordChanged);
RePasswordChangedCommand = new DelegateCommand <object>(RePasswordChanged);
LoginCommand = new DelegateCommand(() => _regionManager.RequestNavigate(RegionNames.MainRegion, nameof(LoginView)));
RegisterCommand = new DelegateCommand(Register);
User = new SocketUser();
}
private async Task WidgetsBackgroundUpdate()
{
await BackgroundTaskWrapper.RunBackgroundTask(this.backgroundThreadCancellationTokenSource, async (tokenSource) =>
{
tokenSource.Token.ThrowIfCancellationRequested();
UserViewModel user = await ChannelSession.GetCurrentUser();
foreach (var widgetGroup in ChannelSession.Settings.OverlayWidgets.GroupBy(ow => ow.OverlayName))
{
IOverlayService overlay = this.GetOverlay(widgetGroup.Key);
if (overlay != null)
{
overlay.StartBatching();
foreach (OverlayWidget widget in widgetGroup)
{
try
{
if (widget.IsEnabled)
{
bool isInitialized = widget.Item.IsInitialized;
if (!isInitialized)
{
await widget.Item.Initialize();
}
if (!isInitialized || !widget.DontRefresh)
{
OverlayItemBase item = await widget.Item.GetProcessedItem(user, new List <string>(), new Dictionary <string, string>());
if (item != null)
{
await overlay.SendItem(item, widget.Position, new OverlayItemEffects());
}
}
}
else
{
await widget.Item.Disable();
}
}
catch (Exception ex) { Logger.Log(ex); }
}
await overlay.EndBatching();
}
}
await Task.Delay(ChannelSession.Settings.OverlayWidgetRefreshTime * 1000);
});
}
protected override async Task PerformInternal(UserViewModel user, IEnumerable <string> arguments)
{
IOverlayService overlay = ChannelSession.Services.OverlayServers.GetOverlay(ChannelSession.Services.OverlayServers.DefaultOverlayName);
if (overlay != null)
{
string message = await this.ReplaceStringWithSpecialModifiers(this.SpeechText, user, arguments);
await overlay.SendTextToSpeech(new OverlayTextToSpeech()
{
Text = message, Voice = this.Voice, Volume = this.Volume, Pitch = this.Pitch, Rate = this.Rate
});
}
}
public ChromeViewModel(IStartWindowViewModel main, IOverlayService overlayService)
{
Main = main;
overlayService.Show
.Subscribe(UpdateOverlay)
.DisposeWith(this);
CloseOverlayCommand = ReactiveCommand <object> .Create()
.DisposeWith(this);
CloseOverlayCommand.Subscribe(x => ClearOverlay())
.DisposeWith(this);
}
public StateViewModel(IRecordDirectoryObserver recordObserver,
IEventAggregator eventAggregator,
IAppConfiguration appConfiguration,
ICaptureService captureService,
IOverlayService overlayService,
IUpdateCheck updateCheck,
IAppVersionProvider appVersionProvider,
IWebVersionProvider webVersionProvider,
LoginManager loginManager,
IRTSSService rTSSService)
{
_recordObserver = recordObserver;
_eventAggregator = eventAggregator;
_appConfiguration = appConfiguration;
_captureService = captureService;
_overlayService = overlayService;
_updateCheck = updateCheck;
_appVersionProvider = appVersionProvider;
IsCaptureModeActive = false;
IsOverlayActive = _appConfiguration.IsOverlayActive && rTSSService.IsRTSSInstalled();
_captureService.IsCaptureModeActiveStream
.Subscribe(state => IsCaptureModeActive = state);
_captureService.IsLoggingActiveStream
.Subscribe(state => IsLoggingActive = state);
_overlayService.IsOverlayActiveStream
.Subscribe(state => IsOverlayActive = state);
IsLoggedIn = loginManager.State.Token != null;
_eventAggregator.GetEvent <PubSubEvent <AppMessages.LoginState> >().Subscribe(state => {
IsLoggedIn = state.IsLoggedIn;
RaisePropertyChanged(nameof(IsLoggedIn));
});
Task.Run(async() =>
{
var(updateAvailable, updateVersion) = await _updateCheck.IsUpdateAvailable();
Dispatcher.CurrentDispatcher.Invoke(() =>
{
IsUpdateAvailable = updateAvailable;
UpdateHyperlinkText = $"New version available on GitHub: v{updateVersion}";
RaisePropertyChanged(nameof(IsUpdateAvailable));
});
});
}
private async Task WidgetsBackgroundUpdate()
{
long updateSeconds = 0;
await BackgroundTaskWrapper.RunBackgroundTask(this.backgroundThreadCancellationTokenSource, async (tokenSource) =>
{
tokenSource.Token.ThrowIfCancellationRequested();
UserViewModel user = await ChannelSession.GetCurrentUser();
foreach (var widgetGroup in ChannelSession.Settings.OverlayWidgets.GroupBy(ow => ow.OverlayName))
{
IOverlayService overlay = this.GetOverlay(widgetGroup.Key);
if (overlay != null)
{
overlay.StartBatching();
foreach (OverlayWidgetModel widget in widgetGroup)
{
try
{
if (widget.IsEnabled)
{
if (!widget.Item.IsInitialized)
{
await widget.Initialize();
}
else if (widget.SupportsRefreshUpdating && widget.RefreshTime > 0 && (updateSeconds % widget.RefreshTime) == 0)
{
await widget.UpdateItem();
}
}
else
{
if (widget.Item.IsInitialized)
{
await widget.Disable();
}
}
}
catch (Exception ex) { Logger.Log(ex); }
}
await overlay.EndBatching();
}
}
await Task.Delay(1000);
updateSeconds++;
});
}
public SettingsService(IOverlayService overlayService, IJSRuntime jsRuntime)
{
var settingsBubble = new SettingsBubble(this);
_settingsOffDefaultBubbles = new Bubble[] { settingsBubble };
_settingsOnDefaultBubbles = new Bubble[]
{
new SelectEntitiesBubble(overlayService),
new ReloadBubble(jsRuntime),
new SelectProfileBubble(overlayService),
settingsBubble
};
_defaultBubbles = new BehaviorSubject <IReadOnlyCollection <Bubble> >(_settingsOffDefaultBubbles);
_areSettingEnabled = new BehaviorSubject <bool>(false);
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (this.region != null)
{
this.region.Dispose();
this.region = null;
}
if (this.host != null)
{
IOverlayService service = (IOverlayService)this.host.GetService(typeof(IOverlayService));
if (service != null)
{
service.RemoveOverlay(this);
}
IEventHandlerService service2 = (IEventHandlerService)this.host.GetService(typeof(IEventHandlerService));
if (service2 != null)
{
service2.PopHandler(this);
}
IMenuCommandService service3 = (IMenuCommandService)this.host.GetService(typeof(IMenuCommandService));
if (service3 != null)
{
foreach (MenuCommand command in this.newCommands)
{
service3.RemoveCommand(command);
}
}
IComponentChangeService service4 = (IComponentChangeService)this.host.GetService(typeof(IComponentChangeService));
if (service4 != null)
{
service4.ComponentAdded -= new ComponentEventHandler(this.OnComponentAddRemove);
service4.ComponentRemoved -= new ComponentEventHandler(this.OnComponentAddRemove);
service4.ComponentChanged -= new ComponentChangedEventHandler(this.OnComponentChanged);
}
IHelpService service5 = (IHelpService)this.host.GetService(typeof(IHelpService));
if (service5 != null)
{
service5.RemoveContextAttribute("Keyword", "TabOrderView");
}
this.host = null;
}
}
base.Dispose(disposing);
}
public CaptureManager(ICaptureService presentMonCaptureService,
ISensorService sensorService,
IOverlayService overlayService,
SoundManager soundManager,
IRecordManager recordManager,
ILogger <CaptureManager> logger,
IAppConfiguration appConfiguration)
{
_presentMonCaptureService = presentMonCaptureService;
_sensorService = sensorService;
_overlayService = overlayService;
_soundManager = soundManager;
_recordManager = recordManager;
_logger = logger;
_appConfiguration = appConfiguration;
_presentMonCaptureService.IsCaptureModeActiveStream.OnNext(false);
}
private async Task RefreshVolumeInternal()
{
if (ChannelSession.Services.Spotify != null)
{
await ChannelSession.Services.Spotify.SetVolume(ChannelSession.Settings.SongRequestVolume);
}
IOverlayService overlay = ChannelSession.Services.OverlayServers.GetOverlay(ChannelSession.Services.OverlayServers.DefaultOverlayName);
if (overlay != null)
{
await overlay.SendSongRequest(new OverlaySongRequest()
{
Type = SongRequestServiceTypeEnum.YouTube.ToString(), Action = "volume", Volume = ChannelSession.Settings.SongRequestVolume
});
}
}
public ChromeViewModel(IMainViewModel main, IOverlayService overlayService)
{
Main = main;
overlayService.Show
.Subscribe(x => UpdateOverlay(x))
.DisposeWith(this);
CloseOverlayCommand = ReactiveCommand <object> .Create()
.DisposeWith(this);
CloseOverlayCommand.Subscribe(x => ClearOverlay())
.DisposeWith(this);
Disposable.Create(() => CloseOverlayCommand = null)
.DisposeWith(this);
}
private const string ToolboxFormat = ".NET Toolbox Item"; // used to detect if a drag is coming from the toolbox.
internal BehaviorService(IServiceProvider serviceProvider, Control windowFrame)
{
_serviceProvider = serviceProvider;
_adornerWindow = new AdornerWindow(this, windowFrame);
// Use the adornerWindow as an overlay
IOverlayService os = (IOverlayService)serviceProvider.GetService(typeof(IOverlayService));
if (os != null)
{
AdornerWindowIndex = os.PushOverlay(_adornerWindow);
}
_dragEnterReplies = new Hashtable();
// Start with an empty adorner collection & no behavior on the stack
Adorners = new BehaviorServiceAdornerCollection(this);
_behaviorStack = new ArrayList();
_hitTestedGlyph = null;
_validDragArgs = null;
DesignerActionUI = null;
_trackMouseEvent = default;
_trackingMouseEvent = false;
// Create out object that will handle all menucommands
if (serviceProvider.GetService(typeof(IMenuCommandService)) is IMenuCommandService menuCommandService &&
serviceProvider.GetService(typeof(IDesignerHost)) is IDesignerHost host)
{
_menuCommandHandler = new MenuCommandHandler(this, menuCommandService);
host.RemoveService(typeof(IMenuCommandService));
host.AddService(typeof(IMenuCommandService), _menuCommandHandler);
}
// Default layoutmode is SnapToGrid.
_useSnapLines = false;
_queriedSnapLines = false;
// Test hooks
WM_GETALLSNAPLINES = User32.RegisterWindowMessageW("WM_GETALLSNAPLINES");
WM_GETRECENTSNAPLINES = User32.RegisterWindowMessageW("WM_GETRECENTSNAPLINES");
// Listen to the SystemEvents so that we can resync selection based on display settings etc.
SystemEvents.UserPreferenceChanged += new UserPreferenceChangedEventHandler(OnUserPreferenceChanged);
}
internal ToolStripAdornerWindowService(IServiceProvider serviceProvider, Control windowFrame)
{
this.serviceProvider = serviceProvider;
this.toolStripAdornerWindow = new ToolStripAdornerWindow(windowFrame);
this.bs = (BehaviorService) serviceProvider.GetService(typeof(BehaviorService));
int adornerWindowIndex = this.bs.AdornerWindowIndex;
this.os = (IOverlayService) serviceProvider.GetService(typeof(IOverlayService));
if (this.os != null)
{
this.os.InsertOverlay(this.toolStripAdornerWindow, adornerWindowIndex);
}
this.dropDownAdorner = new Adorner();
int count = this.bs.Adorners.Count;
if (count > 1)
{
this.bs.Adorners.Insert(count - 1, this.dropDownAdorner);
}
}
private async Task <SongRequestItem> GetYouTubeStatus()
{
IOverlayService overlay = ChannelSession.Services.OverlayServers.GetOverlay(ChannelSession.Services.OverlayServers.DefaultOverlayName);
if (overlay != null)
{
this.youTubeStatus = null;
await overlay.SendSongRequest(new OverlaySongRequest()
{
Type = SongRequestServiceTypeEnum.YouTube.ToString(), Action = "status"
});
for (int i = 0; i < 10 && this.youTubeStatus == null; i++)
{
await Task.Delay(500);
}
}
return(this.youTubeStatus);
}
protected override async Task PerformInternal(UserViewModel user, IEnumerable <string> arguments)
{
if (this.WidgetID != Guid.Empty)
{
OverlayWidget widget = ChannelSession.Settings.OverlayWidgets.FirstOrDefault(w => w.Item.ID.Equals(this.WidgetID));
if (widget != null)
{
widget.IsEnabled = this.ShowWidget;
if (!widget.IsEnabled)
{
IOverlayService overlay = ChannelSession.Services.OverlayServers.GetOverlay(widget.OverlayName);
if (overlay != null)
{
await overlay.RemoveItem(widget.Item);
}
}
}
}
else
{
#pragma warning disable CS0612 // Type or member is obsolete
if (this.Position == null && this.Effect != null)
{
this.Position = new OverlayItemPosition(OverlayEffectPositionType.Percentage, this.Effect.Horizontal, this.Effect.Vertical);
}
if (this.Effects == null && this.Effect != null)
{
this.Effects = new OverlayItemEffects((OverlayEffectEntranceAnimationTypeEnum)this.Effect.EntranceAnimation,
(OverlayEffectVisibleAnimationTypeEnum)this.Effect.VisibleAnimation, (OverlayEffectExitAnimationTypeEnum)this.Effect.ExitAnimation, this.Effect.Duration);
}
this.Effect = null;
#pragma warning restore CS0612 // Type or member is obsolete
string overlayName = (string.IsNullOrEmpty(this.OverlayName)) ? ChannelSession.Services.OverlayServers.DefaultOverlayName : this.OverlayName;
IOverlayService overlay = ChannelSession.Services.OverlayServers.GetOverlay(overlayName);
if (overlay != null)
{
OverlayItemBase processedItem = await this.Item.GetProcessedItem(user, arguments, this.extraSpecialIdentifiers);
await overlay.SendItem(processedItem, this.Position, this.Effects);
}
}
}
private void onFaulted()
{
m_serviceProxy = null;
m_pipeFactory = null;
try
{
if (m_performingAction)
{
m_performingAction = false;
m_callback.onError("Error: Action could not be performed. Lost connection to server.");
}
}
catch
{
// do nothing
}
changeState(CommunicationState.Created);
activityOccured();
}
private void onOpening()
{
m_pipeFactory.Open(new TimeSpan(0,0,0,5));
m_serviceProxy = m_pipeFactory.CreateChannel();
m_serviceProxy.subscribeMessageListUpdate();
m_callback.initializeMessages(m_serviceProxy.getDisplayMessages().ToArray());
changeState(CommunicationState.Opened);
}
private void onClosing()
{
if (m_serviceProxy != null)
{
m_serviceProxy.unsubscribeMessageListUpdate();
m_serviceProxy = null;
}
if (m_pipeFactory != null)
{
m_pipeFactory.Close();
m_pipeFactory = null;
}
changeState(CommunicationState.Closed);
activityOccured();
}
