///<summary>Non-blocking call. FormProgressExtended is an extremely tailored version of FormProgressStatus. ///It is a progress window that can have multiple progress bars showing at the same time with pause and cancel functionality. ///This "extended" progress window is exactly like the "Show()" progress window in that the close action that is returned must be invoked ///by the calling method in order to programmatically close.</summary> ///<param name="odEventType">Causes the progress window to only process ODEvents of this ODEventType. Undefined will process all types.</param> ///<param name="eventType">Causes the progress window to only process ODEvents of this Type. Null defaults to typeof(ODEvent).</param> ///<param name="currentForm">The form to activate once the progress is done. If you cannot possibly pass in a form, it is okay to pass in null.</param> ///<param name="tag">Optionally set tag to an object that should be sent as the first "event arg" to the new progress window. ///This will typically be a ProgressBarHelper or a string.</param> ///<param name="progCanceled">Optionally pass in a delegate that will get invoked when the user clicks Cancel.</param> ///<param name="progPaused">Optionally pass in a delegate that will get invoked when the user clicks Pause.</param> ///<returns>An action that will close the progress window. Invoke this action whenever long computations are finished.</returns> public static Action ShowExtended(ODEventType odEventType, Type eventType, Form currentForm, object tag = null, ProgressCanceledHandler progCanceled = null, ProgressPausedHandler progPaused = null, string cancelButtonText = null) { Action actionCloseProgressWindow = ShowProgressBase( () => { FormProgressExtended FormPE = new FormProgressExtended(odEventType, eventType, cancelButtonText: cancelButtonText); if (progCanceled != null) { FormPE.ProgressCanceled += progCanceled; } if (progPaused != null) { FormPE.ProgressPaused += progPaused; } //FormProgressExtended should NOT be the top most form. Other windows might be popping up requiring attention from the user. //FormPE.TopMost=true;//Make this window show on top of ALL other windows. if (tag != null) { FormPE.ODEvent_Fired(new ODEventArgs(odEventType, tag)); } return(FormPE); }, "Thread_ODProgress_ShowExtended_" + DateTime.Now.Ticks); return(() => { actionCloseProgressWindow(); //Make sure the progress window is closed first. //If a form was passed in, activate it so that it blinks or gets focus. if (currentForm != null && !currentForm.IsDisposed) { currentForm.Activate(); } }); }
///<summary>Do not instatiate this class. It is not meant for public use. Use ODProgress.ShowProgressExtended() instead. ///Launches a progress window that will constantly spin and display status updates for global ODEvents with corresponding name. ///eventType must be a Type that contains an event called Fired.</summary> public FormProgressExtended(ODEventType odEventType, Type eventType, bool hasHistory = false, string cancelButtonText = null) : base(odEventType, eventType) { InitializeComponent(); if (!string.IsNullOrEmpty(cancelButtonText)) { butCancel.Text = cancelButtonText; } }
///<summary>Non-blocking call. Shows a progress window that will listen for ODEvents in order to update the label and progress bar. ///The progress window that is shown to the user is owned by a separate thread so that the main thread can continue to execute. ///This type of progress window is good for showing progress when manipulating UI elements on the main thread (filling grids). ///It is up to the calling method to let notify this progress window when it should close by invoking the action returned.</summary> ///<param name="odEventType">Causes the progress window to only process ODEvents of this ODEventType. Undefined will process all types.</param> ///<param name="eventType">Causes the progress window to only process ODEvents of this Type. Null defaults to typeof(ODEvent).</param> ///<param name="startingMessage">Sets the label of the progress window to the value passed in. Defaults to "Please Wait..." ///It is always up to the calling method to translate this message before passing it in. This is to avoid translating multiple times.</param> ///<param name="hasHistory">Set to true if the progress window should show a history of events that it has processed. ///This will cause the UI of the progress window to change slightly and will also make it so the user has to click a Close button.</param> ///<param name="hasMinimize">Set to true if the progress window should allow minimizing. False by default.</param> ///<param name="progStyle">Sets the style of the progress bar within the progress window that is going to be shown to the user.</param> ///<returns>An action that will close the progress window. Invoke this action whenever long computations are finished.</returns> public static Action Show(ODEventType odEventType = ODEventType.Undefined, Type eventType = null, string startingMessage = "Please Wait...", bool hasHistory = false, bool hasMinimize = false, ProgressBarStyle progStyle = ProgressBarStyle.Marquee) { return(ShowProgressBase( () => { return new FormProgressStatus(odEventType, eventType, hasHistory, hasMinimize, startingMessage, progStyle) { TopMost = true, //Make this window show on top of ALL other windows. }; }, "Thread_ODProgress_Show_" + DateTime.Now.Ticks)); }
///<param name="currentForm">The form to activate once the progress is done. If you cannot possibly pass in a form, it is okay to pass in null. ///</param> public ODProgressExtended(ODEventType odEventType, IODEvent odEvent, Form currentForm, object tag = null, ProgBarStyle progBarStyle = ProgBarStyle.Blocks, string lanThis = "ProgressExtended", string cancelButtonText = null) { _actionCloser = ODProgress.ShowExtended(odEventType, odEvent.GetType(), currentForm, tag, new ProgressCanceledHandler((object sender, EventArgs e) => { IsCanceled = true; }), new ProgressPausedHandler((object sender, ProgressPausedArgs e) => { IsPaused = e.IsPaused; }), cancelButtonText); _event = odEvent; _progBarStyle = progBarStyle; _odEventType = odEventType; LanThis = lanThis; }
///<summary>Do not instatiate this class. It is not meant for public use. Use ODProgress.ShowProgressStatus() instead. ///Launches a progress window that will constantly spin and display status updates for global ODEvents with corresponding name. ///eventType must be a Type that contains an event called Fired.</summary> public FormProgressStatus(ODEventType odEventType = ODEventType.Undefined, Type eventType = null, bool hasHistory = false, bool hasMinimize = true, string startingMessage = "", ProgressBarStyle progStyle = ProgressBarStyle.Marquee) : base(odEventType, eventType) { InitializeComponent(); labelMsg.Text = startingMessage; progressBar.Style = progStyle; if (!hasMinimize) { panelMinimize.Visible = false; } this.ControlBox = false; _hasHistory = hasHistory; if (_hasHistory) { this.Height += 120; this.Width += 60; _dateTimeLastEvent = DateTime.MinValue; labelMsg.Visible = false; textHistoryMsg.Visible = true; } _dateTimeInit = DateTime.Now; }
///<summary>funcShouldWindowClose should return a boolean indicating if this window should close or not. ///Optionally set errorMessage to override the label text that is displayed to the user. ///Optionally set a custom eventType in order to listen for specific types of ODEvent.Fired events. Defaults to DataConnectionEvent.</summary> public FormConnectionLost(Func <bool> funcShouldWindowClose, ODEventType odEventType = ODEventType.Undefined, string errorMessage = "" , Type eventType = null) { InitializeComponent(); labelErrMsg.Text = errorMessage; _funcShouldWindowClose = funcShouldWindowClose; _odEventType = odEventType; if (eventType == null) { eventType = typeof(DataConnectionEvent); } //Make sure that the event type passed in has a "Fired" event to listen to. ODException.SwallowAnyException(() => _eventInfoFired = eventType.GetEvent("Fired")); if (_eventInfoFired == null) { throw new ApplicationException("The 'eventType' passed into FormConnectionLost does not have a 'Fired' event.\r\n" + "Type passed in: " + eventType.GetType()); } Delegate delegateFired = GetDelegateFired(_eventInfoFired.EventHandlerType); MethodInfo methodAddHandler = _eventInfoFired.GetAddMethod(); methodAddHandler.Invoke(this, new object[] { delegateFired }); }
public FormProgressBase(ODEventType odEventType, Type eventType) { this.FormClosing += new FormClosingEventHandler(this.FormProgressStatus_FormClosing); this.FormClosed += new FormClosedEventHandler(this.FormProgressStatus_FormClosed); this.Shown += new EventHandler(this.FormProgressStatus_Shown); if (eventType == null) { eventType = typeof(ODEvent); } _eventType = eventType; _odEventType = odEventType; //Registers this form for any progress status updates that happen throughout the entire program. ODException.SwallowAnyException(() => _eventInfoFired = _eventType.GetEvent("Fired")); if (_eventInfoFired == null) { throw new ApplicationException("The 'eventType' passed into FormProgressStatus does not have a 'Fired' event.\r\n" + "Type passed in: " + eventType.GetType()); } //Register the "Fired" event to the ODEvent_Fired delegate. Delegate delegateFired = Delegate.CreateDelegate(_eventInfoFired.EventHandlerType, this, "ODEvent_Fired"); MethodInfo methodAddHandler = _eventInfoFired.GetAddMethod(); methodAddHandler.Invoke(this, new object[] { delegateFired }); }
public static void Fire(ODEventType odEventType, object tag) { Fired?.Invoke(new ODEventArgs(odEventType, tag)); }
///<summary>Creates an ODEventArg with the specified ODEventType and Tag passed in that is designed to be Fired to a progress window.</summary> ///<param name="eventType">Progress windows registered to this ODEventType will consume this event arg and act upon the tag accordingly. ///An event type of Undefined will be treated as a generic ODEvent.</param> ///<param name="tag">Tag can be set to anything that the consumer may need. E.g. a string for FormProgressStatus to show to users.</param> public ODEventArgs(ODEventType eventType, object tag) { _tag = tag; _eventType = eventType; }
///<summary>Used when an ODEvent is needed but no object is needed in the consuming class.</summary> public ODEventArgs(ODEventType eventType) : this(eventType, null) { }
///<summary>This is a blocking call. Runs the action on the main thread and displays a progress window on another thread. ///Once the long computation has completed, then the progress window will automatically be closed. ///Throws any exceptions that occurred within the action if no exception delegate was provided.</summary> ///<param name="actionComputation">Any long computation. Returns and does nothing if null.</param> ///<param name="startingMessage">Sets the label of the progress window to the value passed in. Defaults to "Please Wait..." ///It is always up to the calling method to translate this message before passing it in. This is to avoid translating multiple times.</param> ///<param name="actionException">A custom UE handler for the worker thread. Null will cause this method to rethrow any exceptions.</param> ///<param name="eventType">Causes the progress window to only process ODEvents of this Type. Null defaults to typeof(ODEvent).</param> ///<param name="odEventType">Causes the progress window to only process ODEvents of this ODEventType. Undefined will process all types.</param> ///<param name="progStyle">Sets the style of the progress bar within the progress window that is going to be shown to the user.</param> ///<param name="hasMinimize">Set to true if the progress window should allow minimizing. False by default.</param> ///<param name="hasHistory">Set to true if the progress window should show a history of events that it has processed. ///This will cause the UI of the progress window to change slightly and will also make it so the user has to click a Close button.</param> public static void ShowAction(Action actionComputation, string startingMessage = "Please Wait...", Action <Exception> actionException = null, Type eventType = null, ODEventType odEventType = ODEventType.Undefined, ProgressBarStyle progStyle = ProgressBarStyle.Marquee, bool hasMinimize = true, bool hasHistory = false) { if (actionComputation == null) { return; //No work to be done. Simply return. } Action actionCloseProgressWindow = Show(odEventType, eventType, startingMessage, hasHistory, hasMinimize, progStyle); //Invoke the action on the main thread that was passed in. try { actionComputation(); } catch (Exception e) { if (actionException == null) { throw; } else { actionException(e); } } finally { actionCloseProgressWindow(); } }
public void Fire(ODEventType odEventType, object tag) { Fire(new ODEventArgs(odEventType, tag)); }