TaskDialog with progress bar

csharp

TaskDialog with progress bar                         By Adam Nagy
I found the ShowProgressBar property of TaskDialog, but it's not clear how I could make use of it. Any samples?
Solution
You need to assign a callback function to the TaskDialog that can be called continously so you can do parts of the lengthy process you want to show a progress bar for. Here is a sample that shows how you can do it.
As you can see it from the comments below there are issues with this on 64 bit OS. My colleague Dianne Phillips looked into it and it turned out to be some issue with assigning your own data to the TaskDialog like so:
td.CallbackData = new MyData();
Her modified code circumvents the issue in two ways: either by using a global variable or assigning your data as an IntPtr. Both ways seem to work fine on 64 bit OS as well.

using System;

using Autodesk.Windows;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Windows;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.Geometry;

using acApp = Autodesk.AutoCAD.ApplicationServices.Application;

using System.Threading;

using System.Globalization;

using System.Runtime.InteropServices;

using WinForms = System.Windows.Forms;

[assembly: CommandClass(typeof(TaskDialogTest.Commands))]

[assembly: ExtensionApplication(typeof(TaskDialogTest.Module))]

namespace TaskDialogTest

{

  // to make the AutoCAD managed runtime happy

  public class Module : IExtensionApplication

  {

    public void Initialize()

    {

    }

    public void Terminate()

    {

    }

  }

  public class Commands

  {

    public class MyVarOverride : IDisposable

    {

      object oldValue;

      string varName;

      public MyVarOverride(string name, object value)

      {

        varName = name;

        oldValue = acApp.GetSystemVariable(name);

        acApp.SetSystemVariable(name, value);

      }

      public void Dispose()

      {

        acApp.SetSystemVariable(varName, oldValue);

      }

    }

    public class MyData

    {

      public int counter = 0;

      public bool delay = true;

      // since the callback data can be reused, be sure

      // to reset it before invoking the task dialog

      public void Reset()

      {

        counter = 0;

        delay = true;

      }

    }

    #region HELPER METHODS

    // helper method for processing the callback both in the

    // data-member case and the callback argument case

    private bool handleCallback(ActiveTaskDialog taskDialog,

                                TaskDialogCallbackArgs args,

                                MyData callbackData)

    {

      // This gets called continuously until we finished completely

      if (args.Notification == TaskDialogNotification.Timer)

      {

        // To make it longer we do some delay in every second call

        if (callbackData.delay)

        {

          System.Threading.Thread.Sleep(1000);

        }

        else

        {

          callbackData.counter += 10;

          taskDialog.SetProgressBarRange(0, 100);

          taskDialog.SetProgressBarPosition(

              callbackData.counter);

          // This is the main action - adding 100 lines 1 by 1

          Database db = HostApplicationServices.WorkingDatabase;

          Transaction tr = db.TransactionManager.TopTransaction;

          BlockTable bt = (BlockTable)tr.GetObject(

            db.BlockTableId, OpenMode.ForRead);

          BlockTableRecord ms = (BlockTableRecord)tr.GetObject(

            bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);

          Line ln = new Line(

            new Point3d(0, callbackData.counter, 0),

            new Point3d(10, callbackData.counter, 0));

          ms.AppendEntity(ln);

          tr.AddNewlyCreatedDBObject(ln, true);

          // To make it appear on the screen - might be a bit costly

          tr.TransactionManager.QueueForGraphicsFlush();

          acApp.DocumentManager.MdiActiveDocument.Editor.Regen();

          // We are finished

          if (callbackData.counter >= 100)

          {

            // We only have a cancel button,

            // so this is what we can press

            taskDialog.ClickButton(

              (int)WinForms.DialogResult.Cancel);

            return true;

          }

        }

        callbackData.delay = !callbackData.delay;

      }

      else if (

        args.Notification == TaskDialogNotification.ButtonClicked)

      {

        // we only have a cancel button

        if (args.ButtonId == (int)WinForms.DialogResult.Cancel)

        {

          return false;

        }

      }

      return true;

    }

    private TaskDialog CreateTaskDialog()

    {

      TaskDialog td = new TaskDialog();

      td.WindowTitle = "Adding lines";

      td.ContentText = "This operation adds 10 lines one at a " +

                      "time and might take a bit of time.";

      td.EnableHyperlinks = true;

      td.ExpandedText = "This operation might be lengthy.";

      td.ExpandFooterArea = true;

      td.AllowDialogCancellation = true;

      td.ShowProgressBar = true;

      td.CallbackTimer = true;

      td.CommonButtons = TaskDialogCommonButtons.Cancel;

      return td;

    }

    #endregion

    #region TASK DIALOG USING CALLBACK DATA ARGUMENT

    /////////////////////////////////////////////////////////////////

    // This sample uses a local instance of the callback data.

    // Since the TaskDialog class needs to convert the callback data

    // to an IntPtr to pass it across the managed-unmanaged divide,

    // be sure to convert it to an IntPtr before passing it off

    // to the TaskDialog instance.

    //

    // This case requires more code than the member-based sample

    // below, but is useful when a callback is shared

    // between multiple task dialogs.

    /////////////////////////////////////////////////////////////////

    // task dialog callback that uses the mpCallbackData argument

    public bool TaskDialogCallback(ActiveTaskDialog taskDialog,

                                    TaskDialogCallbackArgs args,

                                    object mpCallbackData)

    {

      // convert the callback data from an IntPtr to the actual

      // object using GCHandle

      GCHandle callbackDataHandle =

        GCHandle.FromIntPtr((IntPtr)mpCallbackData);

      MyData callbackData = (MyData)callbackDataHandle.Target;

      // use the helper method to do the actual processing

      return handleCallback(taskDialog, args, callbackData);

    }

    [CommandMethod("ShowTaskDialog")]

    public void ShowTaskDialog()

    {

      Database db = HostApplicationServices.WorkingDatabase;

      using (

        Transaction tr = db.TransactionManager.StartTransaction())

      {

        // create the task dialog and initialize the callback method

        TaskDialog td = CreateTaskDialog();

        td.Callback = new TaskDialogCallback(TaskDialogCallback);

        // create the callback data and convert it to an IntPtr

        // using GCHandle

        MyData cbData = new MyData();

        GCHandle cbDataHandle = GCHandle.Alloc(cbData);

        td.CallbackData = GCHandle.ToIntPtr(cbDataHandle);

        // Just to minimize the "Regenerating model" messages

        using (new MyVarOverride("NOMUTT", 1))

        {

          td.Show(Application.MainWindow.Handle);

        }

        // If the dialog was not cancelled before it finished

        // adding the lines then commit transaction

        if (memberCallbackData.counter >= 100)

          tr.Commit();

        // be sure to clean up the gc handle before returning

        cbDataHandle.Free();

      }

    }

    #endregion

    #region TASK DIALOG USING DATA-MEMBER-BASED CALLBACK DATA

    /////////////////////////////////////////////////////////////////

    // This sample uses a data member for the callback data.

    // This avoids having to pass the callback data as an IntPtr.

    /////////////////////////////////////////////////////////////////

    // member-based callback data -

    // used with MemberTaskDialogCallback

    MyData memberCallbackData = new MyData();

    // task dialog callback that uses the callback data member;

    // does not use mpCallbackData

    public bool TaskDialogCallbackUsingMemberData(

      ActiveTaskDialog taskDialog,

      TaskDialogCallbackArgs args,

      object mpCallbackData)

    {

      // use the helper method to do the actual processing

      return handleCallback(taskDialog, args, memberCallbackData);

    }

    [CommandMethod("ShowTaskDialogWithDataMember")]

    public void ShowTaskDialogWithDataMember()

    {

      Database db = HostApplicationServices.WorkingDatabase;

      using (

        Transaction tr = db.TransactionManager.StartTransaction())

      {

        // create the task dialog and initialize the callback method

        TaskDialog td = CreateTaskDialog();

        td.Callback =

          new TaskDialogCallback(TaskDialogCallbackUsingMemberData);

        // make sure the callback data is initialized before

        // invoking the task dialog

        memberCallbackData.Reset();

        // Just to minimize the "Regenerating model" messages

        using (new MyVarOverride("NOMUTT", 1))

        {

          td.Show(Application.MainWindow.Handle);

        }

        // If the dialog was not cancelled before it finished

        // adding the lines then commit transaction

        if (memberCallbackData.counter >= 100)

          tr.Commit();

      }

    }

    #endregion

  }

}