public ComplexityAnalysisOptionPage(Lifetime lifetime, OptionsSettingsSmartContext optionsSettingsSmartContext,
ILanguages languages, ILanguageManager languageManager)
: base(lifetime, optionsSettingsSmartContext)
{
AddText("Specify cyclomatic complexity thresholds:");
var thresholds = OptionsSettingsSmartContext.Schema.GetIndexedEntry((CyclomaticComplexityAnalysisSettings s) => s.Thresholds);
var list = new List<LanguageSpecificComplexityProperties>();
foreach (var languageType in languages.All.Where(languageManager.HasService<IControlFlowBuilder>).OrderBy(GetPresentableName))
{
var presentableName = GetPresentableName(languageType);
var thing = new LanguageSpecificComplexityProperties(lifetime, optionsSettingsSmartContext, thresholds, languageType.Name, presentableName, CyclomaticComplexityAnalysisSettings.DefaultThreshold);
list.Add(thing);
}
// TODO: Do we want to add any keywords for the list view?
// We would use OptionEntities.Add if the view model also implements IOptionEntity,
// or use RegisterWord if we just want to add keyword(s)
// (But the list view is just language name + threshold, so not very interesting)
AddCustomOption(new ComplexityAnalysisOptionsViewModel(list));
OptionEntities.Add(new HyperlinkOptionViewModel(lifetime, "What is a good threshold value?",
new DelegateCommand(() => Process.Start("https://github.com/JetBrains/resharper-cyclomatic-complexity/blob/master/docs/ThresholdGuidance.md#readme"))));
FinishPage();
}
public JetBoxOptionsPage(Lifetime lifetime, IUIApplication environment, ClientFactory clientFactory, JetBoxSettingsStorage jetBoxSettings, JetPopupMenus jetPopupMenus)
: base(lifetime, environment, PID)
{
mySettingsStore = jetBoxSettings.SettingsStore.BindToContextLive(lifetime, ContextRange.ApplicationWide);
myLifetimes = new SequentialLifetimes(lifetime);
myClient = clientFactory.CreateClient();
myClient.UserLogin = mySettingsStore.GetValue(JetBoxSettingsAccessor.Login);
// init UI
myLoggedPanel = new FlowLayoutPanel { Visible = false, AutoSize = true };
myLoggedPanel.Controls.Add(myLoginLabel = new RichTextLabel(environment));
myLoggedPanel.Controls.Add(new LinkLabel("Logout", Logout, jetPopupMenus));
myNonLoggedPanel = new FlowLayoutPanel { Visible = false, AutoSize = true, FlowDirection = FlowDirection.TopDown };
myNonLoggedPanel.Controls.Add(new LinkLabel("Login", Login, jetPopupMenus)
{
Image = Environment.Theming.Icons[UnnamedThemedIcons.Dropbox.Id].CurrentGdipBitmapScreenDpi,
ImageAlign = ContentAlignment.MiddleLeft,
Padding = new Padding(20, 0, 0, 0)
});
Controls.Add(myLoggedPanel);
Controls.Add(myNonLoggedPanel);
InitLoginState();
}
public static Animation CreateCounterExample2(Lifetime life)
{
var animation = new Animation();
var state = Ani.Anon(step => {
var t = (step.TotalSeconds * 8).SmoothCycle(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
var t1 = TimeSpan.Zero;
var t2 = t.Seconds();
var ra = new EndPoint("Robot A", skew: 0.Seconds() + t1);
var rb = new EndPoint("Robot B", skew: 0.Seconds() + t2);
var graph = new EndPointGraph(
new[] { ra, rb },
new Dictionary<Tuple<EndPoint, EndPoint>, TimeSpan> {
{Tuple.Create(ra, rb), 2.Seconds() + t2 - t1},
{Tuple.Create(rb, ra), 2.Seconds() + t1 - t2},
});
var m1 = new Message("I think it's t=0s.", graph, ra, rb, ra.Skew + 0.Seconds());
var m2 = new Message("Received at t=2s", graph, rb, ra, m1.ArrivalTime);
var s1 = new Measurement("Apparent Time Mistake = 2s+2s", ra, ra, m2.ArrivalTime, m2.ArrivalTime + 4.Seconds(), 60);
var s2 = new Measurement("Time mistake = RTT - 4s", ra, ra, m2.ArrivalTime + 4.Seconds(), m2.ArrivalTime + 4.Seconds(), 140);
return new GraphMessages(graph, new[] { m1, m2}, new[] { s1, s2});
});
return CreateNetworkAnimation(animation, state, life);
}
/// <summary>
/// The initializer for this ShellComponent.
/// </summary>
/// <param name="lifetime">
/// The lifetime for this object.
/// </param>
private void Init(Lifetime lifetime)
{
RegistryUtils registryUtils = new RegistryUtils();
object oneTimeInitializationRequiredRegistryKey = registryUtils.CUGetValue("LastInitializationDate");
DateTime initializationDate = Convert.ToDateTime(oneTimeInitializationRequiredRegistryKey);
string todayAsString = DateTime.Today.ToString("yyyy-MM-dd");
string value = registryUtils.LMGetValue("InstallDate") as string;
DateTime lastInstalledDate;
try
{
lastInstalledDate = Convert.ToDateTime(value);
// If the installer stored a date that has now been read back in and seems to be in the future
// then use the LocalUserInstallDate value.
if (lastInstalledDate > DateTime.Today)
{
lastInstalledDate = GetInstallDateFromLocalUserRegistry(registryUtils, todayAsString);
}
}
catch (FormatException ex)
{
// In some locales the installer saves the date in a format we can't parse back out.
// Use today as the installed date and store it in the HKCU key.
lastInstalledDate = GetInstallDateFromLocalUserRegistry(registryUtils, todayAsString);
}
if (oneTimeInitializationRequiredRegistryKey == null || initializationDate < lastInstalledDate)
{
SettingsStore settingsStore = Shell.Instance.GetComponent<SettingsStore>();
IContextBoundSettingsStoreLive settings = settingsStore.BindToContextLive(lifetime, ContextRange.ApplicationWide);
bool checkReSharperCodeStyleOptionsAtStartUp = settings.GetValue((StyleCopOptionsSettingsKey key) => key.CheckReSharperCodeStyleOptionsAtStartUp);
if (checkReSharperCodeStyleOptionsAtStartUp)
{
if (!CodeStyleOptions.CodeStyleOptionsValid(settings, Core.Utils.GetSolution()))
{
DialogResult result =
MessageBox.Show(
@"Your ReSharper code style settings are not completely compatible with StyleCop. Would you like to reset them now?",
@"StyleCop",
MessageBoxButtons.YesNo,
MessageBoxIcon.Question,
MessageBoxDefaultButton.Button2);
if (result == DialogResult.Yes)
{
CodeStyleOptions.CodeStyleOptionsReset(settings, Core.Utils.GetSolution());
}
}
}
}
registryUtils.CUSetValue("LastInitializationDate", todayAsString);
}
public UpdatesNotifier(Lifetime lifetime, UpdatesManager updatesManager)
{
var uri = new Uri("https://raw.github.com/hmemcpy/Nancy-ReSharper-Plugin/master/updates.xslt");
var category = updatesManager.Categories.AddOrActivate("NancyFxSupport", uri);
category.CustomizeLocalEnvironmentInfo.Advise(lifetime, args =>
{
// We can customize the local environment info that the xslt will be applied to
// It should be an instance of UpdateLocalEnvironmentInfo, bail out early if it's
// not. The only reason it wouldn't be is if someone has got hold of the "NancyFxSupport"
// category and subscribed to the CustomizeLocalEnvironmentInfo signal. Unlikely.
if (!(args.Out is UpdateLocalEnvironmentInfoVs))
return;
// Set the data the xslt will be applied against. Pass in the current environment,
// in case we ever need it, but really, we only care about the current version
args.Out = new PluginLocalEnvironmentInfo
{
LocalEnvironment = args.Out as UpdateLocalEnvironmentInfoVs,
PluginVersion = new UpdateLocalEnvironmentInfo.VersionSubInfo(GetThisVersion())
};
});
RemoveStaleUpdateNotification(category);
}
private static ToolStripMenuItem BindCommand(this ToolStripDropDown dropDown, Lifetime<ICommand> command, object argument)
{
ToolStripMenuItem item = dropDown.Add(string.Empty);
item.Tag = new ToolStripItemCommandBinding(dropDown, item, command, argument);
return item;
}
/// <summary>
/// Creates new instance of ComplexityAnalysisOptionPage
/// </summary>
public ComplexityAnalysisOptionPage(Lifetime lifetime, FontsManager fontsManager, OptionsSettingsSmartContext settings)
: base(lifetime, fontsManager, PID)
{
myLifetime = lifetime;
mySettings = settings;
InitControls();
}
public ProductSettingsTracker(Lifetime lifetime, ClientFactory clientFactory, IViewable<ISyncSource> syncSources, IFileSystemTracker fileSystemTracker, JetBoxSettingsStorage jetBoxSettings)
{
myClientFactory = clientFactory;
mySettingsStore = jetBoxSettings.SettingsStore.BindToContextLive(lifetime, ContextRange.ApplicationWide);
mySettingsStore.Changed.Advise(lifetime, _ => InitClient());
myRootFolder = FileSystemPath.Parse("ReSharperPlatform");
InitClient();
syncSources.View(lifetime, (lt1, source) =>
source.FilesToSync.View(lt1, (lt2, fileToSync) =>
{
SyncFromCloud(fileToSync.Value);
var fileTrackingLifetime = new SequentialLifetimes(lt2);
fileToSync.Change.Advise(lt2,
args =>
{
var path = args.Property.Value;
if (lifetime.IsTerminated || path.IsNullOrEmpty())
{
fileTrackingLifetime.TerminateCurrent();
}
else
{
fileTrackingLifetime.Next(lt =>
fileSystemTracker.AdviseFileChanges(lt, path,
delta => delta.Accept(new FileChangesVisitor(myClient, myRootFolder))));
}
});
}));
}
/// <summary>
/// Initializes a new instance of the <see cref="ExternalBuildPlan"/> class.
/// </summary>
/// <param name="services">Services that the build plan is for</param>
/// <param name="lifetime">The lifetime.</param>
/// <param name="instanceStrategy">The instance strategy.</param>
public ExternalBuildPlan(IEnumerable<Type> services, Lifetime lifetime, IInstanceStrategy instanceStrategy)
{
if (instanceStrategy == null) throw new ArgumentNullException("instanceStrategy");
_lifetime = lifetime;
_instanceStrategy = instanceStrategy;
Services = services.ToArray();
}
public GlobalProductSyncSource(Lifetime lifetime, GlobalPerProductStorage globalPerProductStorage)
{
FilesToSync = new CollectionEvents<IProperty<FileSystemPath>>(lifetime, "GlobalProductSyncSource")
{
globalPerProductStorage.XmlFileStorage.Path
};
}
public GraphCodeWindowRegistrar(Lifetime lifetime, ToolWindowManager toolWindowManager,
GraphCodeToolWindow descriptor, UIApplication environment)
{
_environment = environment;
_lifetime = lifetime;
_toolWindowClass = toolWindowManager.Classes[descriptor];
//_toolWindowClass.RegisterEmptyContent(
// lifetime,
// lt =>
// {
// var graphs = (new GraphLoader()).Load();
// var tabControl = new System.Windows.Controls.TabControl();
// var zcontrols = new List<ZoomControl>();
// foreach (var graph in graphs)
// {
// var gArea = InitializeGraphArea.Initialize(graph);
// var zcontrol = new ZoomControl();
// zcontrol.Content = gArea;
// zcontrols.Add(zcontrol);
// }
// tabControl.ItemsSource = zcontrols;
// return (new EitherControl(tabControl)).BindToLifetime(lt);
// });
}
public ZenCodingOptionsPage(Lifetime lifetime, OptionsSettingsSmartContext settings, IThreading threading, IThemedIconManager iconManager)
{
myLifetime = lifetime;
mySettings = settings;
myThreading = threading;
myIconManager = iconManager;
myLambdaExpression = s => s.FileAssociations;
InitializeComponent();
myFileAssociations = new SortedDictionary<int, FileAssociation>();
foreach (var pair in mySettings.EnumerateIndexedEntry(myLambdaExpression))
{
myFileAssociations[pair.First] = pair.Second;
}
var model = BuildModel();
myView = new FileAssociationsTreeView(model, new FileAssociationViewController())
{
Presenter = new FileAssociationPresenter(),
Dock = DockStyle.Fill
};
myView.DoubleClick += EditFileAssociation;
myRules.Controls.Add(myView);
_buttons.Items.Add("Create", myIconManager.Icons[ZenCodingCommonThemedIcons.Add.Id].CurrentGdipBitmap96, CreateFileAssociation);
_buttons.Items.Add("Edit", myIconManager.Icons[CommonThemedIcons.Edit.Id].CurrentGdipBitmap96, EditFileAssociation);
_buttons.Items.Add("Remove", myIconManager.Icons[CommonThemedIcons.Remove.Id].CurrentGdipBitmap96, RemoveFileAssociation);
_buttons.Items.Add("Up", myIconManager.Icons[CommonThemedIcons.Up.Id].CurrentGdipBitmap96, MoveUp);
_buttons.Items.Add("Down", myIconManager.Icons[CommonThemedIcons.Down.Id].CurrentGdipBitmap96, MoveDown);
}
public Stream GetDefaultSettingsStream(Lifetime lifetime)
{
var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("JetBrains.ReSharper.Plugins.CyclomaticComplexity.Resources.DefaultSettings.xml");
Assertion.Assert(stream != null, "stream != null");
lifetime.AddDispose(stream);
return stream;
}
public NancyReferenceProviderFactory(Lifetime lifetime, ISolution solution, ISettingsStore settingsStore, MvcReferenceProviderValidator providerValidator)
{
this.solution = solution;
lifetime.AddBracket(() => providerValidator.OnChanged += FireOnChanged,
() => providerValidator.OnChanged -= FireOnChanged);
}
public void Add(Severity severity,
Lifetime lifeTime,
Scope scope,
IPrincipal principal,
string title,
string message,
params NotificationAction[] actions)
{
if (scope == Scope.User && principal == null)
throw new ArgumentNullException("principal", "Argument cannot be null when Scope is 'User'.");
var note = new Notification(Guid.NewGuid(),
DateTime.UtcNow,
severity,
lifeTime,
scope,
title,
message,
actions);
if (scope == Scope.User)
{
var userNotifications = this._userNotifications.GetOrAdd(principal.Identity.Name,
s => new ConcurrentDictionary<Guid, Notification>());
if (!userNotifications.TryAdd(note.Id, note))
throw new ReadOnlyException("Failed to add notifications.");
}
else
{
if (!this._notifications.TryAdd(note.Id, note))
throw new ReadOnlyException("Failed to add notifications.");
}
}
public void Add(Severity severity, Lifetime lifeTime, Scope scope, string title, string message, params NotificationAction[] actions)
{
if (scope == Scope.User)
throw new ArgumentException("Scope 'User' is not allowed for this overload as no IPrincipal is provided.", "scope");
this.Add(severity, lifeTime, scope, null, title, message, actions);
}
public RsDocOptionsPage(Lifetime lifetime, OptionsSettingsSmartContext optionsSettingsSmartContext)
: base(lifetime, optionsSettingsSmartContext)
{
// output path
IProperty<FileSystemPath> outputPath = new Property<FileSystemPath>(lifetime, "RsDocOptionsPage::OutputPath");
outputPath.SetValue(FileSystemPath.TryParse(optionsSettingsSmartContext.StoreOptionsTransactionContext.GetValue((RsDocSettingsKey key) => key.RsDocOutputFolder)));
outputPath.Change.Advise(lifetime, a =>
{
if (!a.HasNew || a.New == null) return;
optionsSettingsSmartContext.StoreOptionsTransactionContext.SetValue((RsDocSettingsKey key) => key.RsDocOutputFolder, a.New.FullPath);
});
AddText("Output folder for generated content:");
var outputPathOption = AddFolderChooserOption(outputPath, null, null);
outputPathOption.IsEnabledProperty.SetValue(true);
// folder with samples for context actions
IProperty<FileSystemPath> caFolder = new Property<FileSystemPath>(lifetime, "RsDocOptionsPage::CaFolder");
caFolder.SetValue(FileSystemPath.TryParse(optionsSettingsSmartContext.StoreOptionsTransactionContext.GetValue((RsDocSettingsKey key) => key.RsDocCaFolder)));
caFolder.Change.Advise(lifetime, a =>
{
if (!a.HasNew || a.New == null) return;
optionsSettingsSmartContext.StoreOptionsTransactionContext.SetValue((RsDocSettingsKey key) => key.RsDocCaFolder, a.New.FullPath);
});
AddText("Folder with context actions samples:");
var caFoolderOption = AddFolderChooserOption(caFolder, null, null);
caFoolderOption.IsEnabledProperty.SetValue(true);
}
public Stream GetDefaultSettingsStream(Lifetime lifetime)
{
var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("JetBrains.ReSharper.PowerToys.ZenCoding.resources.PredefinedZenCodingSettings.xml");
Assertion.AssertNotNull(stream, "stream == null");
lifetime.AddDispose(stream);
return stream;
}
public static ILifetimeStrategy Get(Lifetime lifetime, INCopDependencyResolver container)
{
switch (lifetime) {
case Lifetime.None:
return defaultLifetimeStrategy;
case Lifetime.PerThread :
return PerThreadLifetimeStrategy.Instance;
case Lifetime.HttpRequest:
return HttpRequestLifetimeStrategy.Instance;
case Lifetime.Hierarchy:
return new HierarchySingletonLifetimeStrategy();
case Lifetime.Container:
return new ContainerSingletonLifetimeStrategy(container);
case Lifetime.HybridRequest:
return hybridRequestLifetimeStrategy;
default:
throw new ResolutionException(Resources.UnknownLifetime);
}
}
public void Open(Lifetime lifetime, IShellLocks shellLocks, ChangeManager changeManager, ISolution solution, DocumentManager documentManager, IActionManager actionManager, ICommandProcessor commandProcessor, TextControlChangeUnitFactory changeUnitFactory, JetPopupMenus jetPopupMenus)
{
Debug.Assert(!IsOpened);
_solution = solution;
DocumentManager = documentManager;
_jetPopupMenus = jetPopupMenus;
changeManager.Changed2.Advise(lifetime, Handler);
lifetime.AddAction(Close);
var expandAction = actionManager.Defs.TryGetActionDefById(GotoDeclarationAction.ACTION_ID);
if (expandAction != null)
{
var postfixHandler = new GotoDeclarationHandler(lifetime, shellLocks, commandProcessor, changeUnitFactory, this);
lifetime.AddBracket(
FOpening: () => actionManager.Handlers.AddHandler(expandAction, postfixHandler),
FClosing: () => actionManager.Handlers.RemoveHandler(expandAction, postfixHandler));
}
var findUsagesAction = actionManager.Defs.GetActionDef<FindUsagesAction>();
var findUsagesHandler = new FindUsagesHandler(lifetime, shellLocks, commandProcessor, changeUnitFactory, this);
lifetime.AddBracket(
FOpening: () => actionManager.Handlers.AddHandler(findUsagesAction, findUsagesHandler),
FClosing: () => actionManager.Handlers.RemoveHandler(findUsagesAction, findUsagesHandler));
}
private ILookup<string, FileSystemPath> installedPackages; // there can be several versions of one package (different versions)
#endregion Fields
#region Constructors
public NuGetApi(ISolution solution, Lifetime lifetime, IComponentModel componentModel, IThreading threading, ProjectModelSynchronizer projectModelSynchronizer)
{
this.solution = solution;
this.threading = threading;
this.projectModelSynchronizer = projectModelSynchronizer;
try
{
vsPackageInstallerServices = componentModel.GetExtensions<IVsPackageInstallerServices>().SingleOrDefault();
vsPackageInstaller = componentModel.GetExtensions<IVsPackageInstaller>().SingleOrDefault();
vsPackageInstallerEvents = componentModel.GetExtensions<IVsPackageInstallerEvents>().SingleOrDefault();
}
catch (Exception e)
{
Logger.LogException("Unable to get NuGet interfaces.", e);
}
if (!IsNuGetAvailable)
{
Logger.LogMessage(LoggingLevel.VERBOSE, "[NUGET PLUGIN] Unable to get NuGet interfaces. No exception thrown");
return;
}
lifetime.AddBracket(
() => vsPackageInstallerEvents.PackageInstalled += RecalcInstalledPackages,
() => vsPackageInstallerEvents.PackageInstalled -= RecalcInstalledPackages);
lifetime.AddBracket(
() => vsPackageInstallerEvents.PackageUninstalled += RecalcInstalledPackages,
() => vsPackageInstallerEvents.PackageUninstalled -= RecalcInstalledPackages);
RecalcInstalledPackages(null);
}
public MockMetricsOptionPage(Lifetime lifetime, UIApplication environment, OptionsSettingsSmartContext settings)
: base(lifetime, environment, PID)
{
myLifetime = lifetime;
mySettings = settings;
InitControls();
}
public PsiCodeFormatter(Lifetime lifetime, PsiLanguage language, ISettingsStore settingsStore, IViewable<IPsiCodeFormatterExtension> extensions, ISettingsOptimization settingsOptimization)
: base(settingsStore)
{
myLanguage = language;
myExtensions = extensions.ToLiveEnumerable(lifetime);
mySettingsOptimization = settingsOptimization;
}
public ProductSettingsTracker(Lifetime lifetime, IProductNameAndVersion product, ClientFactory clientFactory, GlobalPerProductStorage globalPerProductStorage, IFileSystemTracker fileSystemTracker, JetBoxSettingsStorage jetBoxSettings)
{
myClientFactory = clientFactory;
mySettingsStore = jetBoxSettings.SettingsStore.BindToContextLive(lifetime, ContextRange.ApplicationWide);
mySettingsStore.Changed.Advise(lifetime, _ => InitClient());
myRootFolder = FileSystemPath.Parse(product.ProductName);
InitClient();
var productSettingsPath = globalPerProductStorage.XmlFileStorage.Path;
SyncFromCloud(productSettingsPath.Value);
var fileTrackingLifetime = new SequentialLifetimes(lifetime);
productSettingsPath.Change.Advise(lifetime,
args =>
{
var path = args.Property.Value;
if (lifetime.IsTerminated || path.IsNullOrEmpty())
{
fileTrackingLifetime.TerminateCurrent();
}
else
{
fileTrackingLifetime.Next(lt => fileSystemTracker.AdviseFileChanges(lt, path, delta => delta.Accept(new FileChangesVisitor(myClient, myRootFolder))));
}
});
}
public T4PsiModuleProvider([NotNull] Lifetime lifetime, [NotNull] IShellLocks shellLocks, [NotNull] ChangeManager changeManager, [NotNull] T4Environment t4Environment)
{
_lifetime = lifetime;
_shellLocks = shellLocks;
_changeManager = changeManager;
_t4Environment = t4Environment;
}
public PatternManagerCache(Lifetime lifetime, CacheManagerEx cacheManager, PsiProjectFileTypeCoordinator projectFileTypeCoordinator, SolutionAnalyzer solutionAnalyzer)
{
this.projectFileTypeCoordinator = projectFileTypeCoordinator;
this.solutionAnalyzer = solutionAnalyzer;
lifetime.AddBracket(() => cacheManager.RegisterCache(this), () => cacheManager.UnregisterCache(this));
}
public TypeInterfaceToolWindowRegistrar(Lifetime lifetime,
ToolWindowManager toolWindowManager,
IShellLocks locks,
ISettingsStore settingsStore,
IActionManager actionManager,
IActionBarManager actionBarManager,
IShortcutManager shortcutManager,
TypeInterfaceToolWindowDescriptor toolWindowDescriptor,
ITheming theming,
IThemedIconManager themedIconManager, IColorThemeManager colorThemeManager)
{
myLifetime = lifetime;
myLocks = locks;
mySettingsStore = settingsStore;
myActionBarManager = actionBarManager;
myTheming = theming;
myThemedIconManager = themedIconManager;
myColorThemeManager = colorThemeManager;
myToolWindowClass = toolWindowManager.Classes[toolWindowDescriptor];
myToolWindowClass.RegisterEmptyContent(
lifetime,
lt =>
{
var emptyLabel = new RichTextLabel { BackColor = SystemColors.Control, Dock = DockStyle.Fill };
emptyLabel.RichTextBlock.Add(new RichText("No hierarchies open", new TextStyle(FontStyle.Bold)));
emptyLabel.RichTextBlock.Add(
new RichText("Use " + actionManager.GetHowToExecuteAction(shortcutManager, typeof(BrowseTypeHierarchyAction)), TextStyle.Default));
emptyLabel.RichTextBlock.Add(new RichText("on a type to see hierarchy", TextStyle.Default));
emptyLabel.RichTextBlock.Parameters = new RichTextBlockParameters(8, ContentAlignment.MiddleCenter);
return emptyLabel.BindToLifetime(lt);
});
}
/// <summary>
/// Initializes a new instance of the <see cref="CodeAnnotationsOptionsPage"/> class.
/// </summary>
/// <param name="lifetime">
/// The lifetime.
/// </param>
/// <param name="settings">
/// The settings.
/// </param>
public CodeAnnotationsOptionsPage(Lifetime lifetime, OptionsSettingsSmartContext settings)
{
this.InitializeComponent();
settings.SetBinding(lifetime, (CodeAnnotationPackSettings s) => s.PublicAssertion, WinFormsProperty.Create(lifetime, this.PublicAssertion, box => box.Text, true));
settings.SetBinding(lifetime, (CodeAnnotationPackSettings s) => s.NonPublicAssertion, WinFormsProperty.Create(lifetime, this.NonPublicAssertion, box => box.Text, true));
settings.SetBinding(lifetime, (CodeAnnotationPackSettings s) => s.AlternativeAssertions, WinFormsProperty.Create(lifetime, this.AlternativeAssertions, box => box.Text, true));
}
public DisposePluginOptionsPage(Lifetime lifetime, UIApplication environment,
OptionsSettingsSmartContext settings)
: base(lifetime, environment, PID)
{
_lifetime = lifetime;
_settings = settings;
InitControls();
}
public void InitModel(Lifetime lifetime, GotoByNameModel model)
{
model.IsCheckBoxCheckerVisible.FlowInto(
lifetime, model.CheckBoxText, flag => flag ? "Middle match" : string.Empty);
model.CaptionText.Value = "Enter words:";
model.NotReadyMessage.Value = "Some textual occurances may be missing at the moment";
}
public static SequentialScheduler FromIScheduler(string id, Lifetime lifetime, IScheduler scheduler)
{
return(new SequentialScheduler(id, lifetime, scheduler as TaskScheduler ?? new SchedulerWrapper(scheduler)));
}
public NavigateFromHereAction(Lifetime lifetime, Agent agent, IActionManager actionManager)
{
actionHelper = new ExtensibleActionHelper(lifetime, this, agent, actionManager);
}
public ModelWithLifetime(EditorPluginModel model, Lifetime lifetime)
{
Model = model;
Lifetime = lifetime;
}
public static void Add <T>(this IServiceCollection serviceCollection, Lifetime lifetime)
{
serviceCollection.Add(typeof(T), lifetime);
}
public static RegistrationBuilder Register <TInterface, TImplement>(
this IContainerBuilder builder,
Lifetime lifetime)
where TImplement : TInterface
=> builder.Register <TImplement>(lifetime).As <TInterface>();
public static RegistrationBuilder Register <TInterface>(
this IContainerBuilder builder,
Func <IObjectResolver, TInterface> implementationConfiguration,
Lifetime lifetime)
where TInterface : class
=> builder.Register(new FuncRegistrationBuilder(implementationConfiguration, typeof(TInterface), lifetime));
public ComponentRegistrationBuilder AddInNewPrefab <T>(T prefab, Lifetime lifetime)
where T : MonoBehaviour
=> containerBuilder.RegisterComponentInNewPrefab(prefab, lifetime);
public ComponentRegistrationBuilder AddOnNewGameObject <T>(Lifetime lifetime, string newGameObjectName = null)
where T : MonoBehaviour
=> containerBuilder.RegisterComponentOnNewGameObject <T>(lifetime, newGameObjectName);
public static void Add(this IServiceCollection serviceCollection, Type serviceType, Type implementationType, Lifetime lifetime)
{
switch (lifetime)
{
case Lifetime.Singleton:
serviceCollection.AddSingleton(serviceType, implementationType);
break;
case Lifetime.Transient:
serviceCollection.AddTransient(serviceType, implementationType);
break;
case Lifetime.Scoped:
serviceCollection.AddScoped(serviceType, implementationType);
break;
default:
throw new ArgumentOutOfRangeException(nameof(lifetime), lifetime, null);
}
}
public static void AddTypesImplementing <T>(this IServiceCollection servicecollection, Lifetime lifetime, params string[] assemblies)
{
servicecollection.AddTypesImplementing <T>(lifetime, GetAssemblies(assemblies));
}
public GenericFindUsagesContextSearch(Lifetime lifetime, ISettingsStore settingsStore) : base(lifetime, settingsStore)
{
}
public AltEnterHandler(Lifetime lifetime, Agent agent)
{
this.lifetime = lifetime;
this.agent = agent;
bulbKeysBuilder = new BulbKeysBuilder();
}
public void Advise(Lifetime lifetime, IRdReactive entity)
{
RealWire.Advise(lifetime, entity);
}
public static RegistrationBuilder RegisterFactory <TParam1, TParam2, T>(
this IContainerBuilder builder,
Func <IObjectResolver, Func <TParam1, TParam2, T> > factoryFactory,
Lifetime lifetime)
=> builder.Register(new FactoryRegistration <TParam1, TParam2, T>(factoryFactory, lifetime));
public static RegistrationBuilder Register(
this IContainerBuilder builder,
Type type,
Lifetime lifetime)
=> builder.Register(new RegistrationBuilder(type, lifetime));
private async Task RefreshInternal(Lifetime lifetime, RefreshType refreshType)
{
myLocks.ReentrancyGuard.AssertGuarded();
if (myBackendUnityHost.BackendUnityModel.Value == null)
{
return;
}
if (!myBackendUnityHost.IsConnectionEstablished())
{
return;
}
var lifetimeDef = Lifetime.Define(lifetime);
try
{
myLogger.Verbose($"myPluginProtocolController.UnityModel.Value.Refresh.StartAsTask, force = {refreshType} Started");
mySolution.GetComponent <RiderBackgroundTaskHost>().AddNewTask(lifetimeDef.Lifetime,
RiderBackgroundTaskBuilder.Create().WithHeader("Refreshing solution in Unity Editor...")
.AsIndeterminate().AsNonCancelable());
var version = myUnityVersion.ActualVersionForSolution.Value;
try
{
if (version != null && version.Major < 2018)
{
using (mySolution.GetComponent <VfsListener>().PauseChanges())
{
try
{
await myBackendUnityHost.BackendUnityModel.Value.Refresh.Start(lifetimeDef.Lifetime, refreshType).AsTask();
}
finally
{
await myLocks.Tasks.YieldTo(myLifetime, Scheduling.MainGuard);
}
}
}
else // it is a risk to pause vfs https://github.com/JetBrains/resharper-unity/issues/1601
{
await myBackendUnityHost.BackendUnityModel.Value.Refresh.Start(lifetimeDef.Lifetime, refreshType).AsTask();
}
}
catch (Exception e)
{
myLogger.Warn(e, comment: "connection usually brakes during refresh.");
}
finally
{
await myLocks.Tasks.YieldTo(myLifetime, Scheduling.MainGuard);
myLogger.Verbose(
$"myPluginProtocolController.UnityModel.Value.Refresh.StartAsTask, force = {refreshType} Finished");
var solution = mySolution.GetProtocolSolution();
var solFolder = mySolution.SolutionDirectory;
var list = new List <string> {
solFolder.FullPath
};
myLogger.Verbose("RefreshPaths.StartAsTask Finished.");
await solution.GetFileSystemModel().RefreshPaths
.Start(lifetimeDef.Lifetime, new RdRefreshRequest(list, true)).AsTask();
await myLocks.Tasks.YieldTo(myLifetime, Scheduling.MainGuard);
}
}
catch (Exception e)
{
myLogger.LogException(e);
}
finally
{
lifetimeDef.Terminate();
}
}
public static RegistrationBuilder Register <TInterface1, TInterface2, TInterface3, TImplement>(
this IContainerBuilder builder,
Lifetime lifetime)
where TImplement : TInterface1, TInterface2, TInterface3
=> builder.Register <TImplement>(lifetime).As(typeof(TInterface1), typeof(TInterface2), typeof(TInterface3));
public PerformanceLineMarkerAnalyzer(Lifetime lifetime, ISolution solution,
IApplicationWideContextBoundSettingStore settingsStore)
{
LineMarkerStatus = settingsStore.BoundSettingsStore
.GetValueProperty(lifetime, (UnitySettings key) => key.PerformanceHighlightingMode);
}
public static RegistrationBuilder Register <T>(
this IContainerBuilder builder,
Lifetime lifetime)
=> builder.Register(typeof(T), lifetime);
public void AddLifetime(Lifetime lifetime)
{
_lifetimes.Add(lifetime);
}
public static void AddTypesImplementing <T>(this IServiceCollection serviceCollection, Lifetime lifetime, params Assembly[] assemblies)
{
var types = GetTypesImplementing(typeof(T), assemblies);
serviceCollection.Add(lifetime, types.ToArray());
}
public BurstContextProvider(Lifetime lifetime, IElementIdProvider elementIdProvider, IApplicationWideContextBoundSettingStore store,
CallGraphSwaExtensionProvider callGraphSwaExtensionProvider, BurstMarksProvider marksProviderBase)
: base(elementIdProvider, callGraphSwaExtensionProvider, marksProviderBase)
{
myIsBurstEnabledProperty = store.BoundSettingsStore.GetValueProperty(lifetime, (UnitySettings key) => key.EnableBurstCodeHighlighting);
}
public UnityObjectTypeReferenceProviderFactory(Lifetime lifetime)
{
Changed = new Signal <IReferenceProviderFactory>(lifetime, GetType().FullName);
}
public MetaFileGuidCache(Lifetime lifetime, IPersistentIndexManager persistentIndexManager)
: base(lifetime, persistentIndexManager, MetaFileCacheItem.Marshaller)
{
}
public RefactorThisAction(Lifetime lifetime, Agent agent, IActionManager actionManager)
{
actionHelper = new ExtensibleActionHelper(lifetime, this, agent, actionManager);
}
public static void AddTypesImplementingInCurrentAssembly <T>(this IServiceCollection serviceCollection, Lifetime lifetime)
{
var types = GetTypesImplementing(typeof(T), new[] { Assembly.GetCallingAssembly() });
serviceCollection.Add(lifetime, types.ToArray());
}
public EntryPointsBuilder(IContainerBuilder containerBuilder, Lifetime lifetime)
{
this.containerBuilder = containerBuilder;
this.lifetime = lifetime;
}
public NewWorldBuilder(IContainerBuilder containerBuilder, string worldName, Lifetime worldLifetime)
{
this.containerBuilder = containerBuilder;
this.worldName = worldName;
this.worldLifetime = worldLifetime;
containerBuilder.RegisterNewWorld(worldName, worldLifetime);
}
public LimboLife()
{
this._lifetime = _source.Lifetime;
}
public RefRoot(Lifetime lifetime, IProtocol protocol) : this()
{
Identify(protocol.Identities, RdId.Root.Mix("RefRoot"));
Bind(lifetime, protocol, "RefRoot");
}
