/// <summary> /// Indicate that we are to enter a frame that will take up the specified amount of work. Completes any previous frames (potentially contributing to parent scopes' progress). /// </summary> /// <param name="expectedWorkThisFrame">The amount of work that will happen between now and the next frame, as a numerator of TotalAmountOfWork.</param> /// <param name="text">Optional text to describe this frame's purpose.</param> public void EnterProgressFrame(float expectedWorkThisFrame = 1.0f, string text = null) { using (FStringUnsafe textUnsafe = new FStringUnsafe(text)) { Native_FSlowTask.EnterProgressFrame(Address, expectedWorkThisFrame, ref textUnsafe.Array); } }
/// <summary> /// Construct this scope from an amount of work to do, and a message to display /// </summary> /// <param name="amountOfWork"> /// Arbitrary number of work units to perform (can be a percentage or number of steps). /// 0 indicates that no progress frames are to be entered in this scope (automatically enters a frame encompassing the entire scope) /// </param> /// <param name="defaultMessage">A message to display to the user to describe the purpose of the scope</param> /// <param name="enabled">When false, this scope will have no effect. Allows for proper scoped objects that are conditionally disabled.</param> public FScopedSlowTask(float amountOfWork, string defaultMessage = null, bool enabled = true) { using (FStringUnsafe defaultMessageUnsafe = new FStringUnsafe(defaultMessage)) { Address = Native_FSlowTask.New_FScopedSlowTask(amountOfWork, ref defaultMessageUnsafe.Array, enabled); } }
/// <summary> /// Get the frame message or default message if empty /// </summary> public string GetCurrentMessage() { using (FStringUnsafe resultUnsafe = new FStringUnsafe()) { Native_FSlowTask.GetCurrentMessage(Address, ref resultUnsafe.Array); return(resultUnsafe.Value); } }
/// <summary> /// True if the user has requested that the slow task be canceled /// </summary> public bool ShouldCancel() { return(Native_FSlowTask.ShouldCancel(Address)); }
/// <summary> /// Creates a new dialog for this slow task, if there is currently not one open /// </summary> /// <param name="showCancelButton">Whether to show a cancel button on the dialog or not</param> /// <param name="allowInPIE">Whether to allow this dialog in PIE. If false, this dialog will not appear during PIE sessions.</param> public void MakeDialog(bool showCancelButton = false, bool allowInPIE = false) { Native_FSlowTask.MakeDialog(Address, showCancelButton, allowInPIE); }
/// <summary> /// Creates a new dialog for this slow task after the given time threshold. If the task completes before this time, no dialog will be shown. /// </summary> /// <param name="threshold">Time in seconds before dialog will be shown.</param> /// <param name="showCancelButton">Whether to show a cancel button on the dialog or not</param> /// <param name="allowInPIE">Whether to allow this dialog in PIE. If false, this dialog will not appear during PIE sessions.</param> public void MakeDialogDelayed(float threshold, bool showCancelButton = false, bool allowInPIE = false) { Native_FSlowTask.MakeDialogDelayed(Address, threshold, showCancelButton, allowInPIE); }
/// <summary> /// Function that finishes any remaining work and removes itself from the global scope stack /// </summary> public void Destroy() { Native_FSlowTask.Destroy(Address); }
/// <summary> /// Function that initializes the scope by adding it to its context's stack /// </summary> public void Initialize() { Native_FSlowTask.Initialize(Address); }
public void Dispose() { Destroy();// Why do we need to call this? Shouldn't this be called by the dtor? (at least for FScopedSlowTask) Native_FSlowTask.Delete(Address); }