/// <summary> /// Secondary entry point for all object representations. Called primarily by /// <see cref="Prepare(object,bool)"/>, but also recursively when preparing interactive /// reflected objects, etc. to prepare child member values. /// </summary> /// <param name="representations">The representations already produced for this object.</param> /// <param name="depth">The current object graph depth.</param> /// <param name="obj">The current object to represent.</param> internal void Prepare(RepresentedObject representations, int depth, object obj) { if (obj == null) { return; } MainThread.Ensure(); var normalizedObj = Normalize(obj); representations.Add(normalizedObj); if (normalizedObj == null) { representations.Add(ToJson(obj)); } else { representations.Add(ToJson(normalizedObj)); } var skipInteractive = false; var interactiveObj = obj; // It is not safe to provide Representation objects to providers // which can cause a stack overflow in Normalize if the provider // decides to directly pack the provied Representation object in // another Representation object for whatever reason. if (obj is Representation) { obj = ((Representation)obj).Value; } foreach (var provider in providers) { try { foreach (var representation in provider.ProvideRepresentations(obj)) { representations.Add(Normalize(representation)); skipInteractive |= representation is InteractiveObject.GetMemberValueError; } } catch (Exception e) { Log.Error(TAG, $"provider {provider}.ProvideRepresentation", e); } } if (skipInteractive) { return; } foreach (var interactiveObject in PrepareInteractiveObjects(depth, interactiveObj)) { interactiveObject.Handle = ObjectCache.Shared.GetHandle(interactiveObject); interactiveObject.Initialize(); representations.Add(interactiveObject); } }
public void AddProvider(RepresentationProvider provider) { if (provider == null) { throw new ArgumentNullException(nameof(provider)); } MainThread.Ensure(); var agentProvider = provider as AgentRepresentationProvider; if (agentProvider != null) { if (agentRepresentationProvider != null) { throw new InvalidOperationException( $"{agentRepresentationProvider.GetType ()} already registered; " + $"only one {nameof (AgentRepresentationProvider)} can be registered"); } agentRepresentationProvider = agentProvider; } providers.Add(provider); }
public static void Present(this UserPresentableException e, object uiContext = null) { Log.Error(TAG, $"{e.Message} ({e.Details})", e.InnerException ?? e); MainThread.Ensure(); var window = new MetroDialogWindow { Title = e.Message, Message = e.Details, AffirmativeButtonText = Catalog.GetString("OK") }; var ownerWindow = uiContext as Window; if (ownerWindow == null) { window.Owner = ownerWindow; window.Width = 400; window.WindowStartupLocation = WindowStartupLocation.CenterScreen; } else { window.Width = ownerWindow.Width; window.WindowStartupLocation = WindowStartupLocation.CenterOwner; } window.ShowDialog(); }
public static void Present(this UserPresentableException e, object uiContext = null) { Log.Error(TAG, $"{e.Message} ({e.Details})", e.InnerException ?? e); MainThread.Ensure(); uiContext = uiContext ?? e.UIContext; var window = (uiContext as NSViewController)?.View?.Window ?? (uiContext as NSView)?.Window ?? (uiContext as NSWindowController)?.Window ?? uiContext as NSWindow; var alert = new NSAlert { AlertStyle = NSAlertStyle.Critical, MessageText = e.Message, InformativeText = e.Details }; if (window == null) { alert.RunModal(); } else { alert.BeginSheet(window, resp => { }); } }
protected override void RunErrorDialog(bool isDownloadError, string message) { MainThread.Ensure(); MetroDialogWindow dialog; if (isDownloadError) { dialog = CreateDialog(Catalog.GetString("Download Failed"), message); dialog.ButtonStyle = MessageDialogStyle.AffirmativeAndNegative; dialog.AffirmativeButtonText = Catalog.GetString("Download & Install Manually"); dialog.NegativeButtonText = Catalog.GetString("Cancel"); } else { dialog = CreateDialog(Catalog.GetString("Installation Failed"), message); dialog.ButtonStyle = MessageDialogStyle.Affirmative; dialog.AffirmativeButtonText = Catalog.GetString("Close"); } dialog.ShowDialog(); if (dialog.Result == MessageDialogResult.Affirmative && isDownloadError) { try { Process.Start(UpdateItem.DownloadUrl.ToString()); } catch (Exception e) { Log.Error(TAG, $"unable to Process.Start({UpdateItem.DownloadUrl})", e); } } }
protected Agent(bool unitTestContext) { MainThread.Initialize(); agentServer = new AgentServer(this); evaluationContextManager = new Lazy <EvaluationContextManager> (() => { MainThread.Ensure(); var host = CreateEvaluationContextManager(); host.Events.Subscribe(new Observer <ICodeCellEvent> (evnt => { switch (evnt) { case EvaluationInFlight _: break; default: MessageChannel.Push(evnt); break; } })); return(host); }); if (!unitTestContext) { RepresentationManager.AddProvider(new ReflectionRepresentationProvider()); } }
public override void WindowDidLoad() { MainThread.Ensure(); Session = SessionDocument.InstanceForWindowControllers?.Session; if (Session == null) { Log.Error(TAG, "Unable to get ClientSession from SessionDocument"); throw new InvalidOperationException(); } var viewControllers = new MacClientSessionViewControllers(this); Session.InitializeViewControllers(viewControllers); ShouldCascadeWindows = false; Window.FrameAutosaveName = "SessionWindow"; Window.TitleVisibility = NSWindowTitleVisibility.Hidden; var toolbar = new NSToolbar("xi-toolbar-main-toolbar-" + Guid.NewGuid()) { SizeMode = NSToolbarSizeMode.Regular, DisplayMode = NSToolbarDisplayMode.Icon, AllowsUserCustomization = false }; new SessionToolbarDelegate(Session, viewControllers, toolbar); Window.Toolbar = toolbar; base.WindowDidLoad(); }
protected override Task InstallUpdateAsync() { MainThread.Ensure(); var window = CreateDialog( Catalog.Format(Catalog.GetString( "{0} must be closed before continuing.", comment: "{0} is the application name"), AppName), Catalog.Format(Catalog.GetString( "The update was downloaded successfully and is ready " + "to be installed, but {0} must be closed first.", comment: "{0} is the application name"), AppName)); window.ButtonStyle = MessageDialogStyle.AffirmativeAndNegative; window.AffirmativeButtonText = Catalog.GetString("Quit & Install Update"); window.NegativeButtonText = Catalog.GetString("Cancel Update"); window.ShowDialog(); if (window.Result != MessageDialogResult.Affirmative) { DeleteUpdate(); ownerWindow.Close(); return(Task.CompletedTask); } Process.Start(DownloadItem.TargetFile).WaitForInputIdle(2000); App.Current.Shutdown(); return(Task.CompletedTask); }
public AppSessionStart() : base("app.sessionStart") { MainThread.Ensure(); // explicitly get and set in the case where it was not persisted // and so we were returned the default Guid.NewGuid. save it. userId = Prefs.Telemetry.UserGuid.GetValue(); Prefs.Telemetry.UserGuid.SetValue(userId); // force this object to init on the main thread so that we can read // the update channel preference Objects.Application.Initialize(); }
public async Task OneAgentProcessForManyTickets(int ticketCount) { MainThread.Ensure(); var ticketRequests = new Task <AgentProcessTicket> [ticketCount]; AgentIdentity firstIdentity = null; Func <Task <AgentProcessTicket> > RequestTicketAsync = async() => { var ticket = await workbookApp.RequestTestTicketAsync(); ticket.ShouldNotBeNull(); var identity = await ticket.GetAgentIdentityAsync(); identity.ShouldNotBeNull(); Interlocked.CompareExchange(ref firstIdentity, identity, null); return(ticket); }; await Task.Run(async() => { for (var i = 0; i < ticketRequests.Length; i++) { ticketRequests [i] = RequestTicketAsync(); } await Task.WhenAll(ticketRequests).ConfigureAwait(false); }); MainThread.Ensure(); foreach (var ticketRequest in ticketRequests) { ticketRequest.IsCompleted.ShouldBeTrue(); var ticket = ticketRequest.Result; var identity = await ticket.GetAgentIdentityAsync(); identity.Id.ShouldEqual(firstIdentity.Id); identity.ShouldBeSameAs(firstIdentity); } observedAgentIdentityIds.ShouldNotContain(firstIdentity.Id); observedAgentIdentityIds.Add(firstIdentity.Id); foreach (var ticketRequest in ticketRequests) { ticketRequest.Result.Dispose(); } }
void Save() { MainThread.Ensure(); try { recentDocumentsFile.ParentDirectory.CreateDirectory(); using (var writer = new StreamWriter(recentDocumentsFile)) new SerializerBuilder() .WithNamingConvention(new CamelCaseNamingConvention()) .Build() .Serialize(writer, this); } catch (Exception e) { Log.Error(TAG, "Unable to save recent documents list", e); } }
public void AddViewHierarchyHandler(string hierarchyKind, IViewHierarchyHandler handler) { if (handler == null) { throw new ArgumentNullException(nameof(handler)); } MainThread.Ensure(); if (handlers == null) { handlers = new OrderedMapOfList <string, IViewHierarchyHandler> (); } handlers.Add(hierarchyKind, handler); }
public async Task AgentProcessTerminated() { MainThread.Ensure(); FixtureSetUp(); TestAgent agent = null; TestAgent.PushAllocHandler(a => agent = a); var taskCompletionSource = new TaskCompletionSource(); await workbookApp.RequestTestTicketAsync(taskCompletionSource.SetResult); agent.Stop(); (await Task.WhenAny(Task.Delay(60000), taskCompletionSource.Task)) .ShouldBeSameAs(taskCompletionSource.Task); taskCompletionSource.Task.IsCompleted.ShouldBeTrue(); }
void Load() { MainThread.Ensure(); try { loading = true; if (recentDocumentsFile.Exists) { using (var reader = new StreamReader(recentDocumentsFile)) Load(new DeserializerBuilder() .WithNamingConvention(new CamelCaseNamingConvention()) .Build() .Deserialize <RecentDocument []> (reader)); } } catch (Exception e) { Log.Error(TAG, "Unable to load recent documents list", e); } finally { loading = false; } }
/// <summary> /// Prepare serializable representations for an arbitrary object. /// </summary> public RepresentedObject Prepare(object obj, bool allowISerializableObject = true) { if (obj == null) { return(null); } MainThread.Ensure(); currentPreparePassAllowsISerializableObject = allowISerializableObject; var representations = new RepresentedObject(obj.GetType()); Prepare(representations, 0, obj); if (representations.Count == 0) { return(null); } return(representations); }
public override void MakeWindowControllers() { MainThread.Ensure(); InstanceForWindowControllers = this; sessionWindowController = (SessionWindowController)NSStoryboard .FromName("Main", NSBundle.MainBundle) .InstantiateControllerWithIdentifier(nameof(SessionWindowController)); InstanceForWindowControllers = null; Session.Subscribe(this); Session.Workbook.EditorHub.Events.Subscribe( new Observer <EditorEvent> (HandleEditorEvent)); AddWindowController(sessionWindowController); Log.Info(TAG, $"Created {sessionWindowController.GetType ()}"); }
public void Dispose() { MainThread.Ensure(); inhibitions--; }
public T GetValue() { MainThread.Ensure(); var type = typeof(T); if (type.IsEnum) { return((T)Enum.Parse( type, PreferenceStore.Default.GetString(Key, DefaultValue.ToString()), true)); } var typeCode = Type.GetTypeCode(type); switch (typeCode) { // Builtin IPreferenceStore types case TypeCode.Boolean: return((T)(object)PreferenceStore.Default.GetBoolean(Key, (bool)(object)DefaultValue)); case TypeCode.Int64: return((T)(object)PreferenceStore.Default.GetInt64(Key, (long)(object)DefaultValue)); case TypeCode.Double: return((T)(object)PreferenceStore.Default.GetDouble(Key, (double)(object)DefaultValue)); case TypeCode.String: return((T)(object)PreferenceStore.Default.GetString(Key, (string)(object)DefaultValue)); // Conversion types case TypeCode.Single: return((T)(object)unchecked ((float)PreferenceStore.Default.GetDouble( Key, unchecked ((float)(object)DefaultValue)))); case TypeCode.SByte: return((T)(object)unchecked ((sbyte)PreferenceStore.Default.GetInt64( Key, unchecked ((sbyte)(object)DefaultValue)))); case TypeCode.Byte: return((T)(object)unchecked ((byte)PreferenceStore.Default.GetInt64( Key, unchecked ((byte)(object)DefaultValue)))); case TypeCode.Int16: return((T)(object)unchecked ((short)PreferenceStore.Default.GetInt64( Key, unchecked ((short)(object)DefaultValue)))); case TypeCode.UInt16: return((T)(object)unchecked ((ushort)PreferenceStore.Default.GetInt64( Key, unchecked ((ushort)(object)DefaultValue)))); case TypeCode.Int32: return((T)(object)unchecked ((int)PreferenceStore.Default.GetInt64( Key, unchecked ((int)(object)DefaultValue)))); case TypeCode.UInt32: return((T)(object)unchecked ((uint)PreferenceStore.Default.GetInt64( Key, unchecked ((uint)(object)DefaultValue)))); case TypeCode.UInt64: return((T)(object)unchecked ((ulong)PreferenceStore.Default.GetInt64( Key, unchecked ((long)(ulong)(object)DefaultValue)))); case TypeCode.DateTime: return((T)(object)DateTime.Parse( PreferenceStore.Default.GetString( Key, "0001-01-01T00:00:00.0000000"), CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind)); } if (type == typeof(string [])) { return((T)(object)PreferenceStore.Default.GetStringArray( Key, (string [])(object)DefaultValue)); } throw new NotSupportedException($"preference type not supported: {type}"); }
public CancellationTokenSource CheckForUpdatesInBackground( bool userInitiated, Action <Task <UpdateItem> > updateHandler) { if (updateHandler == null) { throw new ArgumentNullException(nameof(updateHandler)); } MainThread.Ensure(); if (!userInitiated) { var skip = false; if (BuildInfo.IsLocalDebugBuild) { skip = true; Log.Info(TAG, "skipping update check since BuildInfo.IsLocalDebugBuild == true"); } else if (CommandLineTool.TestDriver.ShouldRun) { skip = true; Log.Info(TAG, "skipping automatic update check under the tests driver"); } if (skip) { updateHandler(Task.FromResult <UpdateItem> (null)); return(null); } } Log.Info(TAG, "checking for updates"); var cancellationTokenSource = new CancellationTokenSource(); CheckForUpdatesAsync(cancellationTokenSource.Token).ContinueWith(task => { if (task.IsCanceled) { Log.Error(TAG, "update check cancelled"); Telemetry.Events.UpdateEvent.Canceled().Post(); } else if (task.IsFaulted) { Log.Error(TAG, "update check failed", task.Exception); Telemetry.Events.UpdateEvent.CheckFailed().Post(); } else if (task.Result == null) { Log.Info(TAG, "no updates are available"); } else { Log.Info(TAG, $"update available: {task.Result.DownloadUrl}"); Telemetry.Events.UpdateEvent.Available(task.Result).Post(); } MainThread.Post(() => { try { updateHandler(task); } catch (Exception e) { Log.Error(TAG, "failed to run update handler", e); } }); }); return(cancellationTokenSource); }
public IDisposable Inhibit() { MainThread.Ensure(); inhibitions++; return(this); }
public void Reset() { MainThread.Ensure(); PreferenceStore.Default.Remove(Key); }
void ScheduleCheckForUpdatesPeriodicallyInBackground() { MainThread.Ensure(); // timer callbacks may still be invoked after the timer is // disposed, so track a generation to know if we should // bail early if that circumstance arises. checkTimerGeneration++; checkTimer?.Dispose(); TimeSpan frequency; switch (Prefs.Updater.QueryFrequency.GetValue()) { case QueryFrequency.Never: Log.Debug(TAG, "Skipping check (automatic update checking disabled)"); return; case QueryFrequency.Hourly: frequency = TimeSpan.FromHours(1); break; case QueryFrequency.Daily: frequency = TimeSpan.FromDays(1); break; case QueryFrequency.Weekly: frequency = TimeSpan.FromDays(7); break; case QueryFrequency.Startup: default: if (updateChecksPerformed == 0) { Log.Debug(TAG, "Performing single automatic startup update check"); CheckForUpdatesInBackground(false, periodicUpdateHandler); } Log.Debug(TAG, "Skipping check (already performed single automatic startup check)"); return; } var lastCheck = Prefs.Updater.LastQuery.GetValue(); var nextCheck = frequency - (DateTime.UtcNow - lastCheck); if (nextCheck < TimeSpan.Zero) { nextCheck = TimeSpan.Zero; } Log.Debug(TAG, $"Scheduling check. Last check @ {lastCheck}; next in {nextCheck}"); checkTimer = new Timer(state => MainThread.Post(() => { Log.Debug(TAG, "Update check timer expired"); if ((int)state != checkTimerGeneration) { Log.Debug(TAG, "Ignoring update check timer callback from previous generation"); return; } switch (Prefs.Updater.QueryFrequency.GetValue()) { case QueryFrequency.Never: checkTimer?.Dispose(); return; case QueryFrequency.Startup: if (updateChecksPerformed > 0) { checkTimer?.Dispose(); return; } break; } CheckForUpdatesInBackground(false, periodicUpdateHandler); }), checkTimerGeneration, nextCheck, frequency); }
public void SetValue(T value) { MainThread.Ensure(); var type = typeof(T); if (type.IsEnum) { PreferenceStore.Default.Set(Key, value.ToString()); return; } var typeCode = Type.GetTypeCode(type); switch (typeCode) { // Builtin IPreferenceStore types case TypeCode.Boolean: PreferenceStore.Default.Set(Key, (bool)(object)value); return; case TypeCode.Int64: PreferenceStore.Default.Set(Key, (long)(object)value); return; case TypeCode.Double: PreferenceStore.Default.Set(Key, (double)(object)value); return; case TypeCode.String: PreferenceStore.Default.Set(Key, (string)(object)value ?? String.Empty); return; // Conversion types case TypeCode.Single: PreferenceStore.Default.Set(Key, unchecked ((float)(object)value)); return; case TypeCode.SByte: PreferenceStore.Default.Set(Key, unchecked ((sbyte)(object)value)); return; case TypeCode.Byte: PreferenceStore.Default.Set(Key, unchecked ((byte)(object)value)); return; case TypeCode.Int16: PreferenceStore.Default.Set(Key, unchecked ((short)(object)value)); return; case TypeCode.UInt16: PreferenceStore.Default.Set(Key, unchecked ((ushort)(object)value)); return; case TypeCode.Int32: PreferenceStore.Default.Set(Key, unchecked ((int)(object)value)); return; case TypeCode.UInt32: PreferenceStore.Default.Set(Key, unchecked ((uint)(object)value)); return; case TypeCode.UInt64: PreferenceStore.Default.Set(Key, unchecked ((long)(ulong)(object)value)); return; case TypeCode.DateTime: PreferenceStore.Default.Set( Key, ((DateTime)(object)value).ToUniversalTime().ToString("O")); return; } if (type == typeof(string [])) { PreferenceStore.Default.Set(Key, (string [])(object)value); return; } throw new NotSupportedException($"preference type not supported: {type}"); }