コード例 #1
0
 /// <summary>
 /// Create a new monitor changed event arguments object.
 /// </summary>
 /// <param name="progressMonitors">The monitor stack that changed</param>
 /// <param name="statusMessage">A user display message for the current status</param>
 /// <param name="completedSteps">The current progress step (between zero and the maximum number of steps)</param>
 /// <param name="maximumSteps">The current maximum number of steps</param>
 public ProgressMonitorStackEventArgs(ProgressMonitorStack progressMonitors, string statusMessage, int completedSteps, int maximumSteps)
 {
     m_ProgressMonitors = progressMonitors;
     m_StatusMessage    = statusMessage;
     m_CompletedSteps   = completedSteps;
     m_MaximumSteps     = maximumSteps;
 }
コード例 #2
0
        internal ProgressMonitor(ProgressMonitorStack progressMonitors, object owner, string status, int maxSteps)
        {
            m_Owner            = owner;
            m_ProgressMonitors = progressMonitors;
            m_PercentComplete  = 0.0;
            m_CompletedSteps   = 0;
            m_MaxSteps         = maxSteps;

            StatusMessage          = status;
            m_PercentCompleteValid = true;
            m_Complete             = false;
            m_ReadOnly             = false;
        }
コード例 #3
0
        private bool m_ReadOnly; //prevents subsequent events from displaying if they come after our canceled or complete event.

        #region Public Properties and Methods

        /// <summary>
        /// Execute the requested delegate asynchronously with the specified arguments.
        /// </summary>
        /// <remarks>A progress dialog is displayed after a few moments and updated asynchronously as the task continues.  If the user
        /// elects ot cancel the task, execution attempts to stop immediately and True is returned indicating the user canceled.</remarks>
        /// <param name="callBack">The method to be executed asynchronously</param>
        /// <param name="title">An end-user display title for this task.</param>
        /// <param name="state">Arguments to pass to the callBack delegate</param>
        public void Execute(WaitCallback callBack, string title, object state)
        {
            AsyncTaskArguments arguments = new AsyncTaskArguments(title, state);

            m_ProgressMonitors = arguments.ProgressMonitors;

            //and initialize our different UI elements
            m_ProgressMonitors.Canceled  += Monitors_Canceled;
            m_ProgressMonitors.Completed += Monitors_Completed;

            //we are going to have the thread pool asynchronously execute our async interface.

            ThreadPool.QueueUserWorkItem(AsyncTaskExec, new object[] { callBack, arguments });

            //and we return right away.  The whole point is that the caller can check status as they wish.
        }
コード例 #4
0
 /// <summary>
 /// Create a new monitor changed event arguments object.
 /// </summary>
 /// <param name="progressMonitors">The monitor stack that changed.</param>
 /// <param name="progressMonitor">The monitor object (if any) affected by the change.</param>
 public ProgressMonitorEventArgs(ProgressMonitorStack progressMonitors, ProgressMonitor progressMonitor)
 {
     m_ProgressMonitors = progressMonitors;
     m_ProgressMonitor  = progressMonitor;
 }
コード例 #5
0
 /// <summary>
 /// Create a new asynchronous execution task
 /// </summary>
 /// <param name="title"></param>
 /// <param name="state"></param>
 /// <remarks>Creates its own progress monitor stack</remarks>
 public AsyncTaskArguments(string title, object state)
 {
     m_Title            = title;
     m_State            = state;
     m_ProgressMonitors = new ProgressMonitorStack(title);
 }