public static NodeDataList Get(Type type)
{
type.ThrowIfNullArgument(nameof(type));
if (dict.TryGetValue(type, out NodeDataList list))
{
return(list);
}
try
{
Debug.Log($"Generating field configuration for type {type}");
NodeDataListBuilder builder = new NodeDataListBuilder(type);
list = builder.CreateList();
}
catch (Exception e)
{
Exception e2 = new Exception($"Fatal exception while generating field configuration for type {type}", e);
FatalErrorHandler.HandleFatalError(e2);
throw e2;
}
dict[type] = list;
return(list);
}
private static void UnhandledExceptionFancyHandler(Exception e)
{
if (System.Windows.Application.Current?.Windows.OfType <Window>().Any(x => x.IsLoaded && x.IsVisible) != true)
{
throw new Exception();
}
FatalErrorHandler.OnFatalError(e);
}
public void Run(Action mainWindowIsReadyCallback)
{
((Action)(async() => {
EventManager.RegisterClassHandler(typeof(Window), FrameworkElement.LoadedEvent, new RoutedEventHandler(OnWindowLoaded));
ContentInstallationManager.Instance.TaskAdded += OnTaskAdded;
try {
if ((!Superintendent.Instance.IsReady || AcRootDirectorySelector.IsReviewNeeded()) &&
new AcRootDirectorySelector().ShowDialog() != true)
{
Logging.Write("AC root selection cancelled, exit");
return;
}
if (!AppArguments.Values.Any() ||
await ArgumentsHandler.ProcessArguments(AppArguments.Values, false) != ArgumentsHandler.ShowMainWindow.No)
{
_showMainWindow = true;
}
if (_additionalProcessing > 0)
{
Logging.Write("Waiting for extra workers…");
await WaitForInProgress();
Logging.Write("Done");
}
if (_showMainWindow && !_mainWindowShown)
{
Logging.Write("Main window…");
_mainWindowShown = true;
mainWindowIsReadyCallback?.Invoke();
await(_mainWindowTask ?? ShowMainWindowAsync());
Logging.Write("Main window closed");
}
Logging.Write("Waiting for extra windows to close…");
do
{
await Task.Delay(100);
} while (await WaitForWindowToClose(_application.Windows.OfType <DpiAwareWindow>().FirstOrDefault(x => x.IsVisible)));
Logging.Write("No more windows");
} catch (Exception e) {
FatalErrorHandler.OnFatalError(e);
Logging.Error(e);
} finally {
Logging.Write("Shutdown…");
_timer.Stop();
_application.Shutdown();
System.Windows.Forms.Application.Exit();
}
Logging.Write("Main loop is finished");
})).InvokeInMainThreadAsync();
}
public void ShowCloseReason(ServerConnectionCloseReasonEvent e, Node node)
{
if ("DISABLED".Equals(e.Reason))
{
FatalErrorHandler.ShowFatalErrorScreen("clientlocal/ui/screen/error/technicalwork");
}
else if ("OVERLOADED".Equals(e.Reason))
{
FatalErrorHandler.ShowFatalErrorScreen("clientlocal/ui/screen/error/serveroverloaded");
}
}
private void Awake()
{
try
{
TooltipHelper.EnsurePrefabs();
}
catch (Exception ex)
{
FatalErrorHandler.HandleFatalError(ex);
Debug.LogException(ex);
}
Destroy(gameObject);
}
private void Awake()
{
try
{
TooltipHelper.EnsurePrefabs();
}
catch (Exception ex)
{
FatalErrorHandler.HandleFatalError(ex);
Log.error(ex, ex.Message);
}
Destroy(gameObject);
}
// Initialization code. Don't use any Avalonia, third-party APIs or any
// SynchronizationContext-reliant code before AppMain is called: things aren't initialized
// yet and stuff might break.
public static void Main(string[] args)
{
FixCurrentDirectory();
var app = BuildAvaloniaApp();
try
{
app.StartWithClassicDesktopLifetime(args);
}
catch (Exception e)
{
FatalErrorHandler.ExceptionOccured(e);
}
}
private void Awake()
{
Debug.Log("[B9PartSwitch.UI.PrefabManagerInstant] awake");
try
{
TooltipHelper.EnsurePrefabs();
}
catch (Exception ex)
{
FatalErrorHandler.HandleFatalError(ex);
Debug.LogException(ex);
}
Destroy(gameObject);
}
private void Start()
{
if (HighLogic.LoadedSceneIsEditor || HighLogic.LoadedSceneIsFlight)
{
try
{
UIPartActionSubtypeSelector.EnsurePrefab();
}
catch (Exception ex)
{
FatalErrorHandler.HandleFatalError(ex);
Debug.LogException(ex);
}
}
Destroy(gameObject);
}
// Initialization code. Don't use any Avalonia, third-party APIs or any
// SynchronizationContext-reliant code before AppMain is called: things aren't initialized
// yet and stuff might break.
public static void Main(string[] args)
{
FixCurrentDirectory();
if (ProgramBootstrap.TryLaunchUpdaterIfNeeded())
{
return;
}
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
var app = BuildAvaloniaApp();
try
{
app.StartWithClassicDesktopLifetime(args);
}
catch (Exception e)
{
FatalErrorHandler.ExceptionOccured(e);
}
}
// Initialization code. Don't use any Avalonia, third-party APIs or any
// SynchronizationContext-reliant code before AppMain is called: things aren't initialized
// yet and stuff might break.
public static void Main(string[] args)
{
FixCurrentDirectory();
if (ProgramBootstrap.TryLaunchUpdaterIfNeeded())
{
return;
}
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
SafeFireAndForgetExtensions.SetDefaultExceptionHandling(Console.WriteLine);
GlobalApplication.Arguments.Init(args);
var app = BuildAvaloniaApp();
try
{
app.StartWithClassicDesktopLifetime(args);
}
catch (Exception e)
{
FatalErrorHandler.ExceptionOccured(e);
}
}
public void Load(ConfigNode node, OperationContext context)
{
node.ThrowIfNullArgument(nameof(node));
context.ThrowIfNullArgument(nameof(context));
try
{
foreach (INodeDataField field in fields)
{
field.Load(node, context);
}
}
catch (HandledFatalException)
{
throw;
}
catch (Exception e)
{
FatalErrorHandler.HandleFatalError(new FatalException($"Fatal exception while attempting to load fields for {context.Subject?.GetType()}", e));
}
}
public void ShowErrorScreen(InvalidLocalConfigurationErrorEvent e, Node node)
{
FatalErrorHandler.ShowBrokenConfigsErrorScreen();
}
public void ShowErrorScreen(ClientUpdateErrorEvent e)
{
FatalErrorHandler.ShowFatalErrorScreen("clientlocal/ui/screen/error/clientupdateerror");
}
public void ShowErrorScreen(NotEnoughDiskSpaceForCacheErrorEvent e, Node node)
{
FatalErrorHandler.ShowFatalErrorScreen("clientlocal/ui/screen/error/notenoughdiskspaceforcache");
}
public void ShowErrorScreen(ServerDisconnectedEvent e, Node node)
{
FatalErrorHandler.ShowFatalErrorScreen("clientlocal/ui/screen/error/serverdisconnected");
}
public void ShowErrorScreen(GameDataLoadErrorEvent e, Node node)
{
FatalErrorHandler.ShowFatalErrorScreen("clientlocal/ui/screen/error/game_data_load_error");
}
public void ShowErrorScreen(DisconectUserFromBlockedCountryEvent e, Node node)
{
FatalErrorHandler.ShowFatalErrorScreen("clientlocal/ui/screen/error/notavailableinregion");
}
public void ShowErrorScreen(TechnicalWorkEvent e, Node node)
{
FatalErrorHandler.ShowFatalErrorScreen("clientlocal/ui/screen/error/technicalwork");
}
public void ShowErrorScreen(InvalidGameDataErrorEvent e, Node node)
{
FatalErrorHandler.ShowFatalErrorScreen("clientlocal/ui/screen/error/invalid_game_data");
}
internal IntPtr AllocNativeInitParams(IntPtr aCallbackPtr)
{
IntPtr nativeParams = OhNetInitParamsCreate();
if (LogOutput != null)
{
OhNetInitParamsSetLogOutput(nativeParams, LogOutput.Callback, LogOutput.Handle());
}
if (FatalErrorHandler != null)
{
OhNetInitParamsSetFatalErrorHandler(nativeParams, FatalErrorHandler.Callback, FatalErrorHandler.Handle());
}
if (AsyncBeginHandler != null)
{
OhNetInitParamsSetAsyncBeginHandler(nativeParams, AsyncBeginHandler.Callback, AsyncBeginHandler.Handle());
}
if (AsyncEndHandler != null)
{
OhNetInitParamsSetAsyncEndHandler(nativeParams, AsyncEndHandler.Callback, AsyncEndHandler.Handle());
}
if (AsyncErrorHandler != null)
{
OhNetInitParamsSetAsyncErrorHandler(nativeParams, AsyncErrorHandler.Callback, AsyncErrorHandler.Handle());
}
if (SubnetListChangedListener != null)
{
OhNetInitParamsSetSubnetListChangedListener(nativeParams, SubnetListChangedListener.Callback, SubnetListChangedListener.Handle());
}
if (SubnetAddedListener != null)
{
OhNetInitParamsSetSubnetAddedListener(nativeParams, SubnetAddedListener.Callback, SubnetAddedListener.Handle());
}
if (SubnetRemovedListener != null)
{
OhNetInitParamsSetSubnetRemovedListener(nativeParams, SubnetRemovedListener.Callback, SubnetRemovedListener.Handle());
}
if (NetworkAdapterChangedListener != null)
{
OhNetInitParamsSetNetworkAdapterChangedListener(nativeParams, NetworkAdapterChangedListener.Callback, NetworkAdapterChangedListener.Handle());
}
OhNetInitParamsSetTcpConnectTimeout(nativeParams, TcpConnectTimeoutMs);
OhNetInitParamsSetMsearchTime(nativeParams, MsearchTimeSecs);
OhNetInitParamsSetMsearchTtl(nativeParams, MsearchTtl);
OhNetInitParamsSetNumEventSessionThreads(nativeParams, NumEventSessionThreads);
OhNetInitParamsSetNumXmlFetcherThreads(nativeParams, NumXmlFetcherThreads);
OhNetInitParamsSetNumActionInvokerThreads(nativeParams, NumActionInvokerThreads);
OhNetInitParamsSetNumInvocations(nativeParams, NumInvocations);
OhNetInitParamsSetNumSubscriberThreads(nativeParams, NumSubscriberThreads);
OhNetInitParamsSetSubscriptionDuration(nativeParams, SubscriptionDurationSecs);
OhNetInitParamsSetPendingSubscriptionTimeout(nativeParams, PendingSubscriptionTimeoutMs);
OhNetInitParamsSetDvMaxUpdateTime(nativeParams, DvMaxUpdateTimeSecs);
OhNetInitParamsSetDvNumServerThreads(nativeParams, DvNumServerThreads);
OhNetInitParamsSetDvNumPublisherThreads(nativeParams, DvNumPublisherThreads);
OhNetInitParamsSetDvNumWebSocketThreads(nativeParams, DvNumWebSocketThreads);
OhNetInitParamsSetCpUpnpEventServerPort(nativeParams, CpUpnpEventPort);
OhNetInitParamsSetDvUpnpServerPort(nativeParams, DvUpnpWebServerPort);
OhNetInitParamsSetDvWebSocketPort(nativeParams, DvWebSocketPort);
if (DvEnableBonjour)
{
OhNetInitParamsSetDvEnableBonjour(nativeParams);
}
if (UseLoopbackNetworkAdapter)
{
OhNetInitParamsSetUseLoopbackNetworkAdapter(nativeParams);
}
return(nativeParams);
}
public void ShowErrorScreen(NoServerConnectionEvent e, Node node)
{
FatalErrorHandler.ShowFatalErrorScreen("clientlocal/ui/screen/error/noserverconnection");
}
