public SemanticErrorTagger(ITextView textView, BackgroundParser backgroundParser, IOptionsService optionsService) : base(PredefinedErrorTypeNames.CompilerError, textView, optionsService) { backgroundParser.SubscribeToThrottledSemanticModelAvailable(BackgroundParserSubscriptionDelay.Medium, async x => await InvalidateTags(x.Snapshot, x.CancellationToken)); }
public BraceCompletionContext(ISmartIndentationService smartIndentationService, ITextBufferUndoManagerProvider undoManager, HlslClassificationService classificationService, IOptionsService optionsService) { _smartIndentationService = smartIndentationService; _undoManager = undoManager; _classificationService = classificationService; _optionsService = optionsService; }
public static AssetType GetAssetType(IOptionsService optionsService, string fileName) { string extension = Path.GetExtension(fileName); if (extension == null) return AssetType.None; extension = extension.ToLower(); XBuilderOptionsGeneral options = optionsService.GetGeneralOptions(); if (options.ModelExtensions != null) { string[] modelExtensions = options.ModelExtensions.Split(new[] {','}, StringSplitOptions.RemoveEmptyEntries); if (modelExtensions.Any(e => e.Trim() == extension)) return AssetType.Model; } if (options.TextureExtensions != null) { string[] textureExtensions = options.TextureExtensions.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries); if (textureExtensions.Any(e => e.Trim() == extension)) return AssetType.Texture; } if (options.EffectExtensions != null) { string[] effectExtensions = options.EffectExtensions.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries); if (effectExtensions.Any(e => e.Trim() == extension)) return AssetType.Effect; } return AssetType.None; }
public AzureDnsOptions(IOptionsService options, IInputService input) { TenantId = options.TryGetOption(options.Options.AzureTenantId, input, "Tenant Id"); ClientId = options.TryGetOption(options.Options.AzureClientId, input, "Client Id"); Secret = options.TryGetOption(options.Options.AzureSecret, input, "Secret", true); SubscriptionId = options.TryGetOption(options.Options.AzureSubscriptionId, input, "DNS Subscription ID"); ResourceGroupName = options.TryGetOption(options.Options.AzureResourceGroupName, input, "DNS Resoure Group Name"); }
public CertificateService(IOptionsService options, ILogService log, LetsEncryptClient client, ISettingsService settingsService) { _log = log; _options = options.Options; _client = client; _configPath = settingsService.ConfigPath; InitCertificatePath(); }
public TaskSchedulerService(ISettingsService settings, IOptionsService options, IInputService input, ILogService log, string clientName) { _options = options.Options; _settings = settings; _input = input; _log = log; _clientName = clientName; }
/// <summary> /// Gets the talk schedule. /// </summary> /// <param name="optionsService">Options service.</param> /// <returns>A collection of TalkScheduleItem.</returns> public static IEnumerable <TalkScheduleItem> Read(IOptionsService optionsService) { var isCircuitVisit = optionsService.Options.IsCircuitVisit; return(optionsService.Options.MidWeekOrWeekend == MidWeekOrWeekend.Weekend ? GetWeekendMeetingSchedule(isCircuitVisit) : GetMidweekMeetingSchedule(isCircuitVisit, new TimesFeed().GetTodaysMeetingData())); }
Target ITargetPlugin.Default(IOptionsService optionsService) { var rawSiteId = optionsService.TryGetRequiredOption(nameof(optionsService.Options.SiteId), optionsService.Options.SiteId); var totalTarget = GetCombinedTarget(GetSites(false, false), rawSiteId); totalTarget.ExcludeBindings = optionsService.Options.ExcludeBindings; return(totalTarget); }
public CertificateService(IOptionsService options, ILogService log, AcmeClientWrapper client, SettingsService settingsService) { _log = log; _options = options.Options; _client = client; _configPath = settingsService.ConfigPath; InitCertificatePath(); }
/// <summary> /// Creates a <see cref="FlexiPictureBlockFactory"/>. /// </summary> /// <param name="imageService">The service that handles image file operations.</param> /// <param name="directoryService">The service that handles searching for image files.</param> /// <param name="optionsService">The service for creating <see cref="IFlexiPictureBlockOptions"/> and <see cref="IFlexiPictureBlocksExtensionOptions"/>.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="imageService"/> is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="directoryService"/> is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="optionsService"/> is <c>null</c>.</exception> public FlexiPictureBlockFactory(IImageService imageService, IDirectoryService directoryService, IOptionsService <IFlexiPictureBlockOptions, IFlexiPictureBlocksExtensionOptions> optionsService) : base(directoryService) { _optionsService = optionsService ?? throw new ArgumentNullException(nameof(optionsService)); _imageService = imageService ?? throw new ArgumentNullException(nameof(imageService)); }
public TalkScheduleService(IOptionsService optionsService) { _optionsService = optionsService; Reset(); // subscriptions... Messenger.Default.Register <TimerStopMessage>(this, OnTimerStopped); }
public AzureDnsOptions(IOptionsService options) { TenantId = options.TryGetRequiredOption(nameof(options.Options.AzureTenantId), options.Options.AzureTenantId); ClientId = options.TryGetRequiredOption(nameof(options.Options.AzureTenantId), options.Options.AzureClientId); Secret = options.TryGetRequiredOption(nameof(options.Options.AzureTenantId), options.Options.AzureSecret); SubscriptionId = options.TryGetRequiredOption(nameof(options.Options.AzureTenantId), options.Options.AzureSubscriptionId); ResourceGroupName = options.TryGetRequiredOption(nameof(options.Options.AzureTenantId), options.Options.AzureResourceGroupName); }
private FlexiPictureBlockFactory CreateFlexiPictureBlockFactory(IImageService imageService = null, IDirectoryService directoryService = null, IOptionsService <IFlexiPictureBlockOptions, IFlexiPictureBlocksExtensionOptions> optionsService = null) { return(new FlexiPictureBlockFactory(imageService ?? _mockRepository.Create <IImageService>().Object, directoryService ?? _mockRepository.Create <IDirectoryService>().Object, optionsService ?? _mockRepository.Create <IOptionsService <IFlexiPictureBlockOptions, IFlexiPictureBlocksExtensionOptions> >().Object)); }
public BellApiController( IOptionsService optionsService, IBellService bellService, ApiThrottler apiThrottler) { _optionsService = optionsService; _bellService = bellService; _apiThrottler = apiThrottler; }
public DragAndDropService( IMediaProviderService mediaProviderService, IOptionsService optionsService, ISnackbarService snackbarService) { _mediaProviderService = mediaProviderService; _optionsService = optionsService; _snackbarService = snackbarService; }
public BookService(IStorageService storageService, IOptionsService optionsService) { _storageService = storageService; _optionsService = optionsService; InitBook(); _saveTimer = new Timer(TimeSpan.FromSeconds(5).TotalMilliseconds); _saveTimer.Elapsed += (s, e) => OnTimerElapsed(); _saveTimer.Enabled = true; }
public ImagesService( IOptionsService optionsService, IUserInterfaceService userInterfaceService, IVerseEditorService verseEditorService) { _optionsService = optionsService; _userInterfaceService = userInterfaceService; _verseEditorService = verseEditorService; }
public MainViewModel( ScripturesViewModel scripturesViewModel, PreviewViewModel previewViewModel, SettingsViewModel settingsViewModel, EditTextViewModel editVerseTextViewModel, StartupViewModel startupViewModel, IImagesService imagesService, IOptionsService optionsService, ISnackbarService snackbarService, IUserInterfaceService userInterfaceService, ICommandLineService commandLineService, IVerseEditorService verseEditorService) { _scripturesViewModel = scripturesViewModel; _previewViewModel = previewViewModel; _settingsViewModel = settingsViewModel; _editVerseTextViewModel = editVerseTextViewModel; _startupViewModel = startupViewModel; _commandLineService = commandLineService; _verseEditorService = verseEditorService; if (commandLineService.NoGpu || ForceSoftwareRendering()) { // disable hardware (GPU) rendering so that it's all done by the CPU... RenderOptions.ProcessRenderMode = RenderMode.SoftwareOnly; } _settingsViewModel.EpubChangedEvent += HandleEpubChangedEvent; _previewViewModel.EditTextCommandEvent += HandleEditTextCommandEvent; _imagesService = imagesService; _optionsService = optionsService; _snackbarService = snackbarService; _userInterfaceService = userInterfaceService; _optionsService.AlwaysOnTopChangedEvent += HandleAlwaysOnTopChangedEvent; _optionsService.EpubPathChangedEvent += HandleEpubPathChangedEvent; InitCommands(); _currentPage = scripturesViewModel; _preSettingsPage = scripturesViewModel; if (IsNewInstallation()) { _currentPage = startupViewModel; } else if (IsBadEpubPath()) { _currentPage = settingsViewModel; } _nextPageTooltip = Properties.Resources.NEXT_PAGE_PREVIEW; GetVersionData(); }
public SurroundWithFeature(IServiceProvider serviceProvider, ILog log, IOptionsService optionsService, IShellHelperService shellHelperService, IShellSelectionService shellSelectionService, IFileTypeResolver fileTypeResolver, IKeyboardService keyboardService) : base(serviceProvider, log, optionsService) { _shellHelperService = shellHelperService; _shellSelectionService = shellSelectionService; _fileTypeResolver = fileTypeResolver; _keyboardService = keyboardService; }
public override SelfHostingOptions Default(Target target, IOptionsService optionsService) { var args = optionsService.GetArguments <SelfHostingArguments>(); return(new SelfHostingOptions() { Port = args.ValidationPort }); }
public ItSystemUsageOptionsController( IOptionsService <ItSystem, BusinessType> businessTypeService, IOptionsService <ItSystemRight, ItSystemRole> rolesService, IGenericRepository <OrganizationUnit> orgUnitsRepository) { _businessTypeService = businessTypeService; _rolesService = rolesService; _orgUnitsRepository = orgUnitsRepository; }
public override EcOptions Default(IOptionsService optionsService) { var args = optionsService.GetArguments <CsrArguments>(); return(new EcOptions() { OcspMustStaple = args.OcspMustStaple }); }
public override CertificateStorePluginOptions Default(IOptionsService optionsService) { var args = optionsService.GetArguments <CertificateStoreArguments>(); return(new CertificateStorePluginOptions { StoreName = args.CertificateStore, KeepExisting = args.KeepExisting }); }
public VideoDisplayManager(IMediaElement mediaElement, TextBlock subtitleBlock, IOptionsService optionsService) { _mediaElement = mediaElement; _subtitleBlock = subtitleBlock; _optionsService = optionsService; SubscribeEvents(); }
protected override void OnApply(PageApplyEventArgs e) { base.OnApply(e); // Make sure we broadcast changes to these options. IOptionsService optionsService = (IOptionsService)GetService(typeof(IOptionsService)); optionsService.InvokeOptionsChanged(EventArgs.Empty); }
public AdaptiveTimerService( IOptionsService optionsService, ITalkScheduleService scheduleService) { _optionsService = optionsService; _scheduleService = scheduleService; Messenger.Default.Register <CountdownWindowStatusChangedMessage>(this, OnCountdownWindowStatusChanged); }
public CountdownWindow( IOptionsService optionsService, IDateTimeService dateTimeService) { InitializeComponent(); _optionsService = optionsService; _dateTimeService = dateTimeService; }
public override void Default(ScheduledRenewal renewal, IOptionsService optionsService) { renewal.Script = optionsService.TryGetRequiredOption(nameof(optionsService.Options.Script), optionsService.Options.Script); if (!renewal.Script.ValidFile(_log)) { throw new ArgumentException(nameof(optionsService.Options.Script)); } renewal.ScriptParameters = optionsService.Options.ScriptParameters; }
public void StartRecording(RecordingCandidate candidateFile, IOptionsService optionsService) { if (_status == RecordingStatus.NotRecording) { _status = RecordingStatus.Recording; OnStartedEvent(); _timer.Start(); } }
public MediaProviderService(IOptionsService optionsService) { _optionsService = optionsService; foreach (var item in _supportedMediaTypes) { _supportedFileExtensions.Add(item.FileExtension); } }
public CountdownTimerViewModel(IOptionsService optionsService) { _optionsService = optionsService; // subscriptions... Messenger.Default.Register <ShutDownMessage>(this, OnShutDown); Messenger.Default.Register <CountdownFrameChangedMessage>(this, OnFrameChanged); Messenger.Default.Register <CountdownZoomOrPositionChangedMessage>(this, OnZoomOrPositionChanged); }
public CountdownTimerTriggerService( IOptionsService optionsService, IDateTimeService dateTimeService) { _optionsService = optionsService; _dateTimeService = dateTimeService; UpdateTriggerPeriods(); }
public AutomateService( IOptionsService optionsService, ITalkTimerService timerService, ITalkScheduleService scheduleService) { _optionsService = optionsService; _timerService = timerService; _scheduleService = scheduleService; }
public static void Format(this ITextBuffer buffer, TextSpan span, IOptionsService optionsService) { SyntaxTree syntaxTree; if (!TryGetSyntaxTree(buffer, out syntaxTree)) return; var edits = Formatter.GetEdits(syntaxTree, span, optionsService.FormattingOptions); ApplyEdits(buffer, edits); }
public SyntaxErrorManager(BackgroundParser backgroundParser, ITextView textView, IOptionsService optionsService, IServiceProvider serviceProvider, ITextDocumentFactoryService textDocumentFactoryService) : base(textView, optionsService, serviceProvider, textDocumentFactoryService) { backgroundParser.SubscribeToThrottledSyntaxTreeAvailable(BackgroundParserSubscriptionDelay.OnIdle, async x => await ExceptionHelper.TryCatchCancellation(() => { RefreshErrors(x.Snapshot, x.CancellationToken); return Task.FromResult(0); })); }
public void Initialize(XBuilderPackage package) { _optionsService = package.GetService<IOptionsService>(); _modelHandler.Initialize(package); _effectHandler.Initialize(_graphicsDeviceControl.Services, package); _modelHandler.Renderer.Initialize(_graphicsDeviceControl.Services, _graphicsDeviceControl.GraphicsDevice); _effectHandler.Renderer.Initialize(_graphicsDeviceControl.Services, _graphicsDeviceControl.GraphicsDevice); _textureHandler.Renderer.Initialize(_graphicsDeviceControl.Services, _graphicsDeviceControl.GraphicsDevice); }
public FormatCommandTarget(IVsTextView adapter, IWpfTextView textView, IOptionsService optionsService) { _textView = textView; _optionsService = optionsService; Dispatcher.CurrentDispatcher.InvokeAsync(() => { // Add the target later to make sure it makes it in before other command handlers ErrorHandler.ThrowOnFailure(adapter.AddCommandFilter(this, out _nextCommandTarget)); }, DispatcherPriority.ApplicationIdle); }
private static bool ShouldFormatOnCharacter(char ch, IOptionsService optionsService) { switch (ch) { case '}': return optionsService.GeneralOptions.AutomaticallyFormatBlockOnCloseBrace; case ';': return optionsService.GeneralOptions.AutomaticallyFormatStatementOnSemicolon; } return false; }
public BraceCompletionContext( ISmartIndentationService smartIndentationService, ITextBufferUndoManagerProvider undoManager, HlslClassificationService classificationService, IOptionsService optionsService, VisualStudioSourceTextFactory sourceTextFactory) { _smartIndentationService = smartIndentationService; _undoManager = undoManager; _classificationService = classificationService; _optionsService = optionsService; _sourceTextFactory = sourceTextFactory; }
public SyntaxErrorTagger(ITextView textView, BackgroundParser backgroundParser, IErrorListHelper errorListHelper, IOptionsService optionsService) : base(PredefinedErrorTypeNames.SyntaxError, errorListHelper) { optionsService.OptionsChanged += OnOptionsChanged; textView.Closed += (sender, e) => optionsService.OptionsChanged -= OnOptionsChanged; _errorListHelper = errorListHelper; _optionsService = optionsService; backgroundParser.RegisterSyntaxTreeHandler(BackgroundParserHandlerPriority.Low, this); OnOptionsChanged(this, EventArgs.Empty); }
// https://github.com/Microsoft/nodejstools/blob/master/Nodejs/Product/Nodejs/EditFilter.cs#L866 public static void FormatAfterTyping(this ITextView textView, char ch, IOptionsService optionsService) { if (!ShouldFormatOnCharacter(ch, optionsService)) return; SyntaxTree syntaxTree; if (!TryGetSyntaxTree(textView.TextBuffer, out syntaxTree)) return; var edits = Formatter.GetEditsAfterKeystroke(syntaxTree, textView.Caret.Position.BufferPosition.Position, ch, optionsService.FormattingOptions); ApplyEdits(textView.TextBuffer, edits); }
protected ErrorManager(ITextView textView, IOptionsService optionsService, IServiceProvider serviceProvider, ITextDocumentFactoryService textDocumentFactoryService) { _textView = textView; _optionsService = optionsService; optionsService.OptionsChanged += OnOptionsChanged; ITextDocument document; if (textDocumentFactoryService.TryGetTextDocument(textView.TextBuffer, out document)) ErrorListHelper = new ErrorListHelper(serviceProvider, document); textView.Closed += OnViewClosed; OnOptionsChanged(this, EventArgs.Empty); }
/// <summary> /// Initializes a new instance of the <see cref="OptionsViewModel"/> class. /// </summary> /// <param name="optionsService">The options service.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="optionsService"/> is <see langword="null"/>. /// </exception> public OptionsViewModel(IOptionsService optionsService) : this() { if (optionsService == null) throw new ArgumentNullException(nameof(optionsService)); _rootNode = new MergeableNode<OptionsPageViewModel>(null) { Children = new MergeableNodeCollection<OptionsPageViewModel>() }; OkCommand = new DelegateCommand(Ok); ApplyCommand = new DelegateCommand(Apply); CancelCommand = new DelegateCommand(Cancel); // Merge all options node collections. _rootNode.Children.Clear(); var merger = new OptionsMergeAlgorithm(); foreach (var optionsNodes in optionsService.OptionsNodeCollections) merger.Merge(_rootNode.Children, optionsNodes); SelectedNode = OptionsNodes.FirstOrDefault(); }
public TemplateModule(IOptionsService service) : base("/options") { Get ["/options"] = _ => { string template=TemplatesCache.Current.Items["index"]; var templates=service.Table.ToList (); string current=""; foreach(var item in templates){ current+=string.Format ("##[{0}](/template/{1})",item.Slug,item.Slug); } return template.Replace ("{content}",current); }; Get ["/template/{slug}"] = _ => { string slug = _.slug; var current = service.Table.FirstOrDefault(item=>item.Slug==slug); var template = service.Table.FirstOrDefault (item=>item.Slug=="template_editor"); string result = template.Content.Replace ("{id}",current.ID); result = result.Replace ("{slug}",current.Slug); result = result.Replace ("{content}",current.Content); return result; }; }
private void RecreateGrid(GraphicsDevice graphicsDevice, IOptionsService optionsService) { _options = optionsService.GetContentPreviewOptions(); _spacing = _options.GridSpacing; _majorLines = _options.MajorLinesEveryNthGridLine; _minorColor = ConvertUtility.ToXnaColor(_options.GridLineMinorColor); _majorColor = ConvertUtility.ToXnaColor(_options.GridLineMajorColor); _axisColor = ConvertUtility.ToXnaColor(_options.GridLineAxisColor); int size = _options.GridSize; _lineBuffer = new VertexBuffer(graphicsDevice, typeof(VertexPositionColor), size * 4, BufferUsage.WriteOnly); VertexPositionColor[] vertices = new VertexPositionColor[size * 4]; int end = (size - 1) / 2; int start = -end; int index = 0; // Lines along z. for (int x = start; x <= end; ++x) { Color color = GetColor(x); vertices[index++] = new VertexPositionColor(new Vector3(GetCoordinate(x), 0, GetCoordinate(start)), color); vertices[index++] = new VertexPositionColor(new Vector3(GetCoordinate(x), 0, GetCoordinate(end)), color); } // Lines along x. for (int z = start; z <= end; ++z) { Color color = GetColor(z); vertices[index++] = new VertexPositionColor(new Vector3(GetCoordinate(start), 0, GetCoordinate(z)), color); vertices[index++] = new VertexPositionColor(new Vector3(GetCoordinate(end), 0, GetCoordinate(z)), color); } _lineBuffer.SetData(vertices); }
public ContentPreviewIntegrationManager(XBuilderPackage package) { _package = package; _optionsService = package.GetService<IOptionsService>(); }
public override void Initialize(IServiceProvider serviceProvider, GraphicsDevice graphicsDevice) { _optionsService = (IOptionsService)serviceProvider.GetService(typeof(IOptionsService)); _optionsService.OptionsChanged += (sender, e) => { RecreateNormals(); _parentControl.Invalidate(); }; _lineEffect = new BasicEffect(graphicsDevice); _lineEffect.LightingEnabled = false; _lineEffect.TextureEnabled = false; _lineEffect.VertexColorEnabled = true; }
public static bool IsInspectableFile(IOptionsService optionsService, string fileName) { return GetAssetType(optionsService, fileName) != AssetType.None; }
public ContentPreviewService(XBuilderPackage package) { _package = package; _optionsService = package.GetService<IOptionsService>(); }
public override void Initialize(IServiceProvider serviceProvider, GraphicsDevice graphicsDevice) { _serviceProvider = serviceProvider; _optionsService = (IOptionsService) serviceProvider.GetService(typeof (IOptionsService)); _optionsService.OptionsChanged += (sender, e) => { SetOptions(); _parentControl.Invalidate(); }; SetOptions(); foreach (ModelRendererWidget widget in _widgets) widget.Initialize(serviceProvider, graphicsDevice); }