update: use dockablepanel only

- single dockablepanel handle all stuff

Author: trgiangv

source/RevitDevTool/Application.cs

@@ -1,40 +1,61 @@
-using Nice3point.Revit.Toolkit.External;
-using RevitDevTool.Revit.Command;
-using RevitDevTool.Theme;
-using RevitDevTool.Utils;
-using RevitDevTool.View;
+using System.IO;
+using System.Reflection;
+using Autodesk.Revit.UI;
+using Autodesk.Revit.UI.Events;
+using RevitDevTool.Commands;
+using RevitDevTool.Extensions;
+using RevitDevTool.Handlers;
 
 namespace RevitDevTool;
 
-[UsedImplicitly]
-public class Application : ExternalApplication
+[PublicAPI]
+public class Application : IExternalApplication
 {
-    public const string Name = "RevitDevTool";
-    public const string Panel = "TraceLog";
-    
-    public override void OnStartup()
+    public static UIControlledApplication RevitUiControlledApplication { get; private set; } = null!;
+    public static UIApplication RevitUiApplication => new RibbonItemEventArgs().Application;
+    public static Autodesk.Revit.ApplicationServices.Application RevitApplication => RevitUiApplication.Application;
+    public static UIDocument? RevitActiveUiDocument => RevitUiApplication.ActiveUIDocument;
+    public static Document? RevitActiveDocument => RevitActiveUiDocument?.Document;
+    public static bool IsInRevitApiMode => RevitUiApplication.ActiveAddInId is not null;
+
+    public Result OnStartup(UIControlledApplication application)
     {
-        AddButton();
-        AddDockable();
+        ResolveAssemblies();
+        RevitUiControlledApplication = application;
+        ExternalEventController.Register();
+        AddButton(application);
+        AddDockable(application);
+        return Result.Succeeded;
     }
 
-    private void AddButton()
+    public Result OnShutdown(UIControlledApplication application)
+    {
+        return Result.Succeeded;
+    }
+    
+    private static void AddDockable(UIControlledApplication application)
+    {
+        TraceCommand.RegisterDockablePane(application);
+    }
+    
+    private static void AddButton(UIControlledApplication application)
     {
-        var panel = Application.CreatePanel(Panel, Name);
+        var panel = application.CreateRibbonPanel("DevTool");
 
         panel.AddPushButton<TraceCommand>("Trace\nPanel")
             .SetLargeImage("/RevitDevTool;component/Images/log.png")
             .SetLongDescription("Display trace data");
-        panel.AddPushButton<TraceGeometryCommand>("Trace\nGeometry")
-            .SetLargeImage("/RevitDevTool;component/Images/switch-off.png")
-            .SetLongDescription("Trace geometries data");
-        panel.AddPushButton<ClearTraceGeometryCommand>("Clear\nGeometry")
-            .SetLargeImage("/RevitDevTool;component/Images/eraser.png")
-            .SetLongDescription("Clear current document trace geometries data");
     }
 
-    private void AddDockable()
+    private static void ResolveAssemblies()
     {
-        DockablePaneRegisterUtils.Register<TraceLog>(Resource.TraceGuid, Application);
+        var currentAssemblyPath = Assembly.GetExecutingAssembly().Location;
+        var currentAssemblyDirectory = Path.GetDirectoryName(currentAssemblyPath);
+        if (currentAssemblyDirectory is null) return;
+        var assemblyFiles = Directory.GetFiles(currentAssemblyDirectory, "*.dll");
+        foreach (var assemblyFile in assemblyFiles)
+        {
+            Assembly.LoadFrom(assemblyFile);
+        }
     }
 }

source/RevitDevTool/Commands/TraceCommand.cs

@@ -0,0 +1,50 @@
+using Autodesk.Revit.Attributes;
+using Autodesk.Revit.UI;
+using RevitDevTool.View;
+using DockablePaneProvider = RevitDevTool.Utils.DockablePaneProvider;
+
+namespace RevitDevTool.Commands;
+
+[UsedImplicitly]
+[Transaction(TransactionMode.Manual)]
+public class TraceCommand : IExternalCommand
+{
+    private const string CommandName = "TraceLog";
+    private const string Guid = "43AE2B41-0BE6-425A-B27A-724B2CE17351";
+    
+    public static void RegisterDockablePane(UIControlledApplication application)
+    {
+        DockablePaneProvider
+            .Register(application, new Guid(Guid), CommandName)
+            .SetConfiguration(data =>
+            {
+                data.FrameworkElement = new TraceLog();
+                data.InitialState = new DockablePaneState
+                {
+                    MinimumWidth = 300,
+                    MinimumHeight = 400,
+                    DockPosition = DockPosition.Left,
+                    TabBehind = DockablePanes.BuiltInDockablePanes.PropertiesPalette
+                };
+            });
+    }
+
+    public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
+    {
+        try
+        {
+            var id = new DockablePaneId(new Guid(Guid));
+            var dockableWindow = commandData.Application.GetDockablePane(id);
+            if(!dockableWindow.IsShown())
+                dockableWindow.Show();
+            else
+                dockableWindow.Hide();
+            return Result.Succeeded;
+        }
+        catch (Exception e)
+        {
+            TaskDialog.Show("Error", e.ToString());
+            return Result.Failed;
+        }
+    }
+}

source/RevitDevTool/Geometry/TraceGeometry.cs

@@ -0,0 +1,76 @@
+using System.Diagnostics;
+using System.Reflection;
+using RevitDevTool.Handlers;
+
+namespace RevitDevTool.Geometry;
+
+public static class TraceGeometry
+{
+    public static readonly TraceListener TraceListener = new TraceGeometryListener();
+    public static readonly Dictionary<int, List<ElementId>> DocGeometries = new();
+    
+    private static MethodInfo? GenerateTransientDisplayMethod()
+    {
+        var geometryElementType = typeof(GeometryElement);
+        var geometryElementTypeMethods =
+            geometryElementType.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
+        var method = geometryElementTypeMethods.FirstOrDefault(x => x.Name == "SetForTransientDisplay");
+        return method;
+    }
+
+    private static void Trace(GeometryObject geometryObject)
+    {
+        Trace(new List<GeometryObject> { geometryObject });
+    }
+
+    private static void Trace(IEnumerable<GeometryObject> geometries)
+    {
+        ExternalEventController.ActionEventHandler.Raise(app =>
+        {
+            var method = GenerateTransientDisplayMethod();
+            var doc = app.ActiveUIDocument.Document;
+            var argsM = new object[4];
+            argsM[0] = doc;
+            argsM[1] = ElementId.InvalidElementId;
+            argsM[2] = geometries;
+            argsM[3] = ElementId.InvalidElementId;
+            var transientElementId = method?.Invoke(null, argsM) as ElementId;
+            
+            var hashKey = doc.GetHashCode();
+            if (DocGeometries.TryGetValue(hashKey, out var value))
+            {
+                if (transientElementId != null)
+                    value.Add(transientElementId);
+            }
+            else
+            {
+                if (transientElementId != null)
+                    DocGeometries[hashKey] = [transientElementId];
+            }
+        });
+    }
+
+    private class TraceGeometryListener : TraceListener
+    {
+        public override void Write(object? o)
+        {
+            if (o is GeometryObject go)
+            {
+                Trace(go);
+            }
+            if (o is IEnumerable<GeometryObject> geometries)
+            {
+                Trace(geometries);
+            }
+
+            base.Write(o);
+        }
+        public override void Write(string? message)
+        {
+        }
+
+        public override void WriteLine(string? message)
+        {
+        }
+    }
+}