AEC DevBlog

Close Revit from the API

By Augusto Goncalves

This is possible using SendMessage with WM_CLOSE parameter. There are two tricks here: first, DLLImport the method from user32.dll, second get Revit windows handle.

For the first, there is a good source of those methods at PInvike.NET website. For this case, we need the SendMessage header. For the second, there is a good post at The Builder Coder blog.

Finally, the code will look like:

[Transaction(TransactionMode.Manual)]

public class AdskCommand : IExternalCommand

{

  public Result Execute(

      ExternalCommandData commandData,

      ref string message,

      ElementSet elements)

  {

    // send the message to close

    SendMessage(RevitWndHandle,

      WM_CLOSE,

      IntPtr.Zero, IntPtr.Zero);

 

    return Result.Succeeded;

  }

 

  // the value for close

  static uint WM_CLOSE = 0x10;

 

  // Use P/Invoke to DLLImport

  [DllImport("user32.dll",

    CharSet = CharSet.Auto,

    SetLastError = false)]

  static extern IntPtr SendMessage(

    IntPtr hWnd, UInt32 Msg,

    IntPtr wParam, IntPtr lParam);

 

  // singleton to store Revit handle

  static IntPtr _hWndRevit = IntPtr.Zero;

 

  // get Revit handle

  private static IntPtr RevitWndHandle

  {

    get

    {

      if (_hWndRevit == IntPtr.Zero)

      {

        System.Diagnostics.Process[] processes

          = System.Diagnostics.Process.

          GetCurrentProcess();

 

        if (0 < processes.Length)

        {

          _hWndRevit = processes[0].MainWindowHandle;

        }

      }

      return _hWndRevit;

    }

  }

}

Quick Tip to set Class Name parameter of Ribbon Items

By Augusto Goncalves

When we create new Ribbon items to execute a class that implements IExternalCommand, we need to specify this class name on the constructor of the  item (e.g. PushButtonData). The thing is that parameter is a String and if we use a constant text, if the class name changes, then we need to remember to adjust this value.

So how can we make this more efficient? Simply using GetType (VB.NET) or typeof (C#). The benefit is the value adjust automatically (Visual Studio renaming mechanism will update it properly) or at least we get and compiler error to help. Of course, this will not be applicable if we’re pointing to a class on a different and not referenced assembly.

VB.NET

Dim pbdNewButton As New PushButtonData( _

  "BTN_NEW_BUTTON", _

  "New Button Text", _

  System.Reflection.Assembly.GetExecutingAssembly().Location, _

  GetType(ClassName).FullName)

C#

PushButtonData pbdNewButton = new PushButtonData(

  "BTN_NEW_BUTTON",

  "New Button Text",

  System.Reflection.Assembly.GetExecutingAssembly().Location,

  typeof(ClassName).FullName);

Inserting a Revit Link file

By Augusto Goncalves

Starting on release 2013 it is possible create a RevitLinkType, which defines the link to a .rvt file, and then insert a new RevitLinkInstance on the project.

// Ask for the file name

System.Windows.Forms.OpenFileDialog

  openFileDlg = new OpenFileDialog();

if (openFileDlg.ShowDialog() != DialogResult.OK)

  return Result.Cancelled;

string rvtFileName = openFileDlg.FileName;

 

// Get the active document

UIDocument uiDoc = commandData.

  Application.ActiveUIDocument;

Document doc = uiDoc.Document;

 

// Create the Revit Link Type

FilePath mp = new FilePath(rvtFileName);

RevitLinkOptions lnkOp = new RevitLinkOptions(false);

RevitLinkLoadResult loadedLnkType =

  RevitLinkType.Create(doc, mp, lnkOp);

 

// Create the Revit Link Instance

RevitLinkInstance lnkInstance =

  RevitLinkInstance.Create(doc, loadedLnkType.ElementId);

Create a text element

By Augusto Goncalves

The method Create.NewTextNote of the Document class is the key to create a text node element. This sample code additionally gets the curve information of elements to align the text.

// Get the active document and view

UIDocument uiDoc = commandData.Application.ActiveUIDocument;

Document doc = uiDoc.Document;

View view = uiDoc.ActiveView;

 

foreach (Element elem in uiDoc.Selection.Elements)

{

  // skip elements without curve

  if (!(elem.Location is LocationCurve)) continue;

 

  // get the curve of the element

  Curve curve = ((LocationCurve)elem.Location).Curve;

 

  // Calculate necessary auguments

  XYZ origin = curve.get_EndPoint(0);

  XYZ baseVec = XYZ.BasisX;

  XYZ upVec = XYZ.BasisZ;

  double textSize = curve.Length / 10;

  double lineWidth = curve.Length / 50;

  string strText = "This is " + elem.Name;

 

  // Create the text

  TextNote text = doc.Create.NewTextNote(view, origin,

    baseVec,

    upVec,

    lineWidth,

    TextAlignFlags.TEF_ALIGN_CENTER |

    TextAlignFlags.TEF_ALIGN_MIDDLE, strText);

  text.Width = curve.Length * 10; // set the width of the text

}

Tips and Tricks learned during Chamfer Fillet for Revit PIOTM development

By Augusto Goncalves

Here is a collection of lessons learned during this plug-in development. You can see all of that in action with the source code available at Autodesk Labs.

Intersection points between walls

Both Chamfer and Fillet uses a key method for this plug-in: Curve.Intersect. Basically, for a given wall, the command must access its underlying geometry, a curve (e.g. line), and through the Intersect method find the intersection point with another curve. It is very important to notice that LineSegment objects (i.e. finite lines) usually do not intersect each other, so it’s required to use the method Curve.MakeUnbound to create a Line object (i.e. infinite line). Note that this plug-in was designed to work on linear walls with one intersection point between them.

Organize the underlying geometry to if necessary create the third wall with the correct orientation

After access the curves of both walls (e.g. LineSegments), the command store XYZ directional vectors for both walls. All calculations are performed with vectors, which is more consistent. Notice that walls are created following that orientation, which affects the internal/external sides, which ultimately affects hosted elements (e.g. doors, windows).

Chamfer

As a chamfered intersection of walls consist in resizing two walls from its (projected) intersection point, this PIOTM created XYZ vectors from the intersection point to the closest point on the wall, which is used to find the next end point of the walls. Once resized, the new wall is created connecting them.

Fillet

This was the changeling one. To create a fillet with a previously defined radius, the command must calculate the deflection angle formed between the walls. This deflection angle is important because is used to obtain the tangent distance T in the image below. This external tangent length represents the necessary distance between the intersection point and the end point of the selected walls, used to create a curve with the desired radius.

Image adapted from Civil Engineering Terms blog

To find the deflection angle, the command creates two concurrent XYZ vectors, from the farthest point of the walls to the intersection point, and then the Vector.AngleTo method gets the deflection angle. On important trick: the AngleTo method considers the vector orientation and, inside Revit API, is always counterclockwise, that’s why this plug-in recreates the concurrent vectors, which obeys the image above.

Resizing connects/joined walls

Revit does not accept changes on walls curves when the wall end is connected to another wall, so the trick here was call WallUtils.IsWallJoinAllowedAtEnd to check if that end was connected, then, if required, disconnect with a call to WallUtils.DisallowWallJoinAtEnd, followed by a call to connect them back with WallUtils.AllowWallJoinAtEnd.

Accessing the Workset of an element

By Augusto Goncalves

It is possible access the Workset, which resides on the document WorksetTable collection, from the element property or from the parameter.

The code sample below shows how access using both approaches and use it. Notice that this code accesses WorksetId, different form the regular ElementId.

Selection sel = commandData.Application.ActiveUIDocument.Selection;

Document doc = commandData.Application.ActiveUIDocument.Document;

 

// select an element

Element elem = doc.GetElement(sel.PickObject(ObjectType.Element));

 

// the table of worksets

WorksetTable worksetTable = doc.GetWorksetTable();

 

// 1. direct way

// access the workset from element ID

WorksetId worksetIdByElement = doc.GetWorksetId(elem.Id);

if (worksetIdByElement != WorksetId.InvalidWorksetId)

{

  // now the workset

  Workset worksetByElement =

    worksetTable.GetWorkset(worksetIdByElement);

}

 

// 2. indirect way (from parameter value)

// access the workset from the param value

// first access the param value

Parameter param = elem.get_Parameter

  (BuiltInParameter.ELEM_PARTITION_PARAM);

int paramValue = param.AsInteger();

WorksetId elemWorksetId = new WorksetId(paramValue);

if (worksetIdByElement != WorksetId.InvalidWorksetId)

{

  // now the workset

  Workset worksetByParam = worksetTable.GetWorkset(elemWorksetId);

}