Kean专题(9)—Object_Properties

Imports Autodesk.AutoCAD
Imports Autodesk.AutoCAD.Runtime
Imports Autodesk.AutoCAD.ApplicationServices
Imports Autodesk.AutoCAD.DatabaseServices
Imports Autodesk.AutoCAD.EditorInputNamespace SelectionTest
  Public Class PickfirstTestCmds    ' Must have UsePickSet specified
     _
    Public Shared Sub PickFirstTest()
      Dim doc As Document = _
        Application.DocumentManager.MdiActiveDocument
      Dim ed As Editor = doc.Editor
      Try
        Dim selectionRes As PromptSelectionResult
        selectionRes = ed.SelectImplied
        ' If there's no pickfirst set available...
        If (selectionRes.Status = PromptStatus.Error) Then
          ' ... ask the user to select entities
          Dim selectionOpts As PromptSelectionOptions
          selectionOpts = New PromptSelectionOptions
          selectionOpts.MessageForAdding = _
            vbLf & "Select objects to list: "
          selectionRes = ed.GetSelection(selectionOpts)
        Else
          ' If there was a pickfirst set, clear it
          ed.SetImpliedSelection(Nothing)
        End If
        ' If the user has not cancelled...
        If (selectionRes.Status = PromptStatus.OK) Then
          ' ... take the selected objects one by one
          Dim tr As Transaction = _
            doc.TransactionManager.StartTransaction
          Try
            Dim objIds() As ObjectId = _
              selectionRes.Value.GetObjectIds
            For Each objId As ObjectId In objIds
              Dim ent As Entity = _
                CType(tr.GetObject(objId, OpenMode.ForRead), Entity)
              ' This time access the properties directly
              ed.WriteMessage(vbLf + "Type:        " + _
                ent.GetType().ToString)
              ed.WriteMessage(vbLf + "  Handle:    " + _
                ent.Handle().ToString)
              ed.WriteMessage(vbLf + "  Layer:      " + _
                ent.Layer().ToString)
              ed.WriteMessage(vbLf + "  Linetype:  " + _
                ent.Linetype().ToString)
              ed.WriteMessage(vbLf + "  Lineweight: " + _
                ent.LineWeight().ToString)
              ed.WriteMessage(vbLf + "  ColorIndex: " + _
                ent.ColorIndex().ToString)
              ed.WriteMessage(vbLf + "  Color:      " + _
                ent.Color().ToString)
              ent.Dispose()
            Next
            ' Although no changes were made, use Commit()
            ' as this is much quicker than rolling back
            tr.Commit()
          Catch ex As Autodesk.AutoCAD.Runtime.Exception
            ed.WriteMessage(ex.Message)
            tr.Abort()
          End Try
        End If
      Catch ex As Autodesk.AutoCAD.Runtime.Exception
        ed.WriteMessage(ex.Message)
      End Try
    End Sub
  End Class
End Namespace

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Runtime;
using System.Reflection;
namespace PropertyChanger
{
  public class PropertyChangerCmds
  {
    [CommandMethod("CHPS",
      CommandFlags.Modal |
      CommandFlags.Redraw |
      CommandFlags.UsePickSet)
    ]
    public void ChangePropertyOnSelectedEntities()
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Editor ed = doc.Editor;
      try
      {
        PromptSelectionResult psr =
          ed.GetSelection();
        if (psr.Status == PromptStatus.OK)
        {
          System.Type objType;
          string propName;
          object newPropValue;
          bool recurse;
          if (SelectClassPropertyAndValue(
                out objType,
                out propName,
                out newPropValue,
                out recurse
              )
            )
          {
            int count =
              ChangePropertyOfEntitiesOfType(
                psr.Value.GetObjectIds(),
                objType,
                propName,
                newPropValue,
                recurse);
            // Update the display, and print the count
            ed.Regen();
            ed.WriteMessage(
              "\nChanged " +
              count + " object" +
              (count == 1 ? "" : "s") +
              " of type " +
              objType.Name +
              " to have a " +
              propName + " of " +
              newPropValue + "."
            );
          }
        }
      }
      catch (System.Exception ex)
      {
        ed.WriteMessage(
          "Exception: " + ex
        );
      }
    }
    [CommandMethod("CHPM")]
    public void ChangePropertyOnModelSpaceContents()
    {
      ChangePropertyOnSpaceContents(
        BlockTableRecord.ModelSpace
      );
    }
    [CommandMethod("CHPP")]
    public void ChangePropertyOnPaperSpaceContents()
    {
      ChangePropertyOnSpaceContents(
        BlockTableRecord.PaperSpace
      );
    }
    private void ChangePropertyOnSpaceContents(
      string spaceName
    )
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Editor ed = doc.Editor;
      try
      {
        System.Type objType;
        string propName;
        object newPropValue;
        bool recurse;
        if (SelectClassPropertyAndValue(
              out objType,
              out propName,
              out newPropValue,
              out recurse
            )
          )
        {
          ObjectId spaceId;
          Transaction tr =
            doc.TransactionManager.StartTransaction();
          using (tr)
          {
            BlockTable bt =
              (BlockTable)tr.GetObject(
                doc.Database.BlockTableId,
                OpenMode.ForRead
              );
            spaceId = bt[spaceName];
            // Not needed, but quicker than aborting
            tr.Commit();
          }
          // Call our recursive function to set the new
          // value in our nested objects
          int count =
            ChangePropertyOfEntitiesOfType(
              spaceId,
              objType,
              propName,
              newPropValue,
              recurse);
          // Update the display, and print the count
          ed.Regen();
          ed.WriteMessage(
            "\nChanged " +
            count + " object" +
            (count == 1 ? "" : "s") +
            " of type " +
            objType.Name +
            " to have a " +
            propName + " of " +
            newPropValue + "."
          );
        }
      }
      catch (System.Exception ex)
      {
        ed.WriteMessage(
          "Exception: " + ex
        );
      }
    }
    private bool SelectClassPropertyAndValue(
      out System.Type objType,
      out string propName,
      out object newPropValue,
      out bool recurse)
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Editor ed = doc.Editor;
      objType = null;
      propName = "";
      newPropValue = null;
      recurse = true;
      // Let's first get the class to query for
      PromptResult ps =
        ed.GetString(
          "\nEnter type of objects to look for: "
        );
      if (ps.Status == PromptStatus.OK)
      {
        string typeName = ps.StringResult;
        // Use reflection to get the type from the string
        objType =
          System.Type.GetType(
            typeName,
            false,        // Do not throw an exception
            true          // Case-insensitive search
          );
        // If we didn't find it, try prefixing with
        // "Autodesk.AutoCAD.DatabaseServices."
        if (objType == null)
        {
          objType =
            System.Type.GetType(
              "Autodesk.AutoCAD.DatabaseServices." +
              typeName + ", acdbmgd",
              false,      // Do not throw an exception
              true        // Case-insensitive search
            );
        }
        if (objType == null)
        {
          ed.WriteMessage(
            "\nType " + typeName + " not found."
          );
        }
        else
        {
          // If we have a valid type then let's
          // first list its writable properties
          ListProperties(objType);
          // Prompt for a property
          ps = ed.GetString(
            "\nEnter property to modify: "
          );
          if (ps.Status == PromptStatus.OK)
          {
            propName = ps.StringResult;
            // Make sure the property exists...
            System.Reflection.PropertyInfo propInfo =
              objType.GetProperty(propName);
            if (propInfo == null)
            {
              ed.WriteMessage(
                "\nProperty " +
                propName +
                " for type " +
                typeName +
                " not found."
              );
            }
            else
            {
              if (!propInfo.CanWrite)
              {
                ed.WriteMessage(
                  "\nProperty " +
                  propName +
                  " of type " +
                  typeName +
                  " is not writable."
                );
              }
              else
              {
                // If the property is writable...
                // ask for the new value
                System.Type propType = propInfo.PropertyType;
                string prompt =
                      "\nEnter new value of " +
                      propName +
                      " property for all objects of type " +
                      typeName +
                      ": ";
                // Only certain property types are currently
                // supported: Int32, Double, String, Boolean
                switch (propType.ToString())
                {
                  case "System.Int32":
                    PromptIntegerResult pir =
                      ed.GetInteger(prompt);
                    if (pir.Status == PromptStatus.OK)
                      newPropValue = pir.Value;
                    break;
                  case "System.Double":
                    PromptDoubleResult pdr =
                      ed.GetDouble(prompt);
                    if (pdr.Status == PromptStatus.OK)
                      newPropValue = pdr.Value;
                    break;
                  case "System.String":
                    PromptResult psr =
                      ed.GetString(prompt);
                    if (psr.Status == PromptStatus.OK)
                      newPropValue = psr.StringResult;
                    break;
                  case "System.Boolean":
                    PromptKeywordOptions pko =
                      new PromptKeywordOptions(
                      prompt);
                    pko.Keywords.Add("True");
                    pko.Keywords.Add("False");
                    PromptResult pkr =
                      ed.GetKeywords(pko);
                    if (pkr.Status == PromptStatus.OK)
                    {
                      if (pkr.StringResult == "True")
                        newPropValue = true;
                      else
                        newPropValue = false;
                    }
                    break;
                  default:
                    ed.WriteMessage(
                      "\nProperties of type " +
                      propType.ToString() +
                      " are not currently supported."
                    );
                    break;
                }
                if (newPropValue != null)
                {
                  PromptKeywordOptions pko =
                    new PromptKeywordOptions(
                      "\nChange properties in nested blocks: "
                    );
                  pko.AllowNone = true;
                  pko.Keywords.Add("Yes");
                  pko.Keywords.Add("No");
                  pko.Keywords.Default = "Yes";
                  PromptResult pkr =
                    ed.GetKeywords(pko);
                  if (pkr.Status == PromptStatus.None |
                      pkr.Status == PromptStatus.OK)
                  {
                    if (pkr.Status == PromptStatus.None |
                        pkr.StringResult == "Yes")
                      recurse = true;
                    else
                      recurse = false;
                    return true;
                  }
                }
              }
            }
          }
        }
      }
      return false;
    }
    private void ListProperties(System.Type objType)
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Editor ed = doc.Editor;
      ed.WriteMessage(
        "\nWritable properties for " +
        objType.Name +
        ": "
      );
      PropertyInfo[] propInfos =
        objType.GetProperties();
      foreach (PropertyInfo propInfo in propInfos)
      {
        if (propInfo.CanWrite)
        {
          ed.WriteMessage(
            "\n  " +
            propInfo.Name +
            " : " +
            propInfo.PropertyType
          );
        }
      }
      ed.WriteMessage("\n");
    }
    // Version of the function that takes a container ID
    private int ChangePropertyOfEntitiesOfType(
      ObjectId btrId,
      System.Type objType,
      string propName,
      object newValue,
      bool recurse
    )
    {
      // We simply open the container, extract the IDs
      // and pass them to another version of the function...
      // If efficiency is an issue, then this could be
      // streamlined (i.e. duplicated, rather than factored)
      ObjectIdCollection btrContents =
        new ObjectIdCollection();
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Transaction tr =
        doc.TransactionManager.StartTransaction();
      using (tr)
      {
        BlockTableRecord btr =
          (BlockTableRecord)tr.GetObject(
            btrId,
            OpenMode.ForRead
          );
        foreach (ObjectId entId in btr)
        {
          btrContents.Add(entId);
        }
        tr.Commit();
      }
      ObjectId[] ids = new ObjectId[btrContents.Count];
      btrContents.CopyTo(ids, 0);
      // Call the other version of this function
      return ChangePropertyOfEntitiesOfType(
        ids,
        objType,
        propName,
        newValue,
        recurse
      );
    }
    // Version of the function that takes a list of ents
    private int ChangePropertyOfEntitiesOfType(
      ObjectId[] objIds,
      System.Type objType,
      string propName,
      object newValue,
      bool recurse
    )
    {
      int changedCount = 0;
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Transaction tr =
        doc.TransactionManager.StartTransaction();
      using (tr)
      {
        foreach (ObjectId entId in objIds)
        {
          Entity ent =
            tr.GetObject(entId, OpenMode.ForRead)
            as Entity;
          // Change each entity, one by one
          if (ent != null)
          {
            changedCount +=
              ChangeSingleProperty(
                ent,
                objType,
                propName,
                newValue
              );
          }
          // If we are to recurse and it's a blockref...
          if (recurse)
          {
            BlockReference br = ent as BlockReference;
            if (br != null)
            {
              // ...then recurse
              changedCount +=
                ChangePropertyOfEntitiesOfType(
                  br.BlockTableRecord,
                  objType,
                  propName,
                  newValue,
                  recurse
                );
            }
          }
        }
        tr.Commit();
      }
      return changedCount;
    }
    // Function to change an individual entity's property
    private int ChangeSingleProperty(
      Entity ent,
      System.Type objType,
      string propName,
      object newValue)
    {
      int changedCount = 0;
      // Are we dealing with an entity we care about?
      if (objType.IsInstanceOfType(ent))
      {
        // Check the existing value
        object res =
          objType.InvokeMember(
            propName,
            BindingFlags.GetProperty,
            null,
            ent,
            new object[0]
          );
        // If it is not the same then change it
        if (!res.Equals(newValue))
        {
          // Entity is only open for read
          ent.UpgradeOpen();
          object[] args = new object[1];
          args[0] = newValue;
          res =
            objType.InvokeMember(
              propName,
              BindingFlags.SetProperty,
              null,
              ent,
              args
            );
          changedCount++;
          ent.DowngradeOpen();
        }
      }
      return changedCount;
    }
  }
}

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.Interop;
using System.Runtime.InteropServices;
namespace HatchQuery
{
  public class HatchQueryCommands
  {
    [CommandMethod("QH")
    ]
    public void QueryHatchOrigin()
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Editor ed = doc.Editor;
      try
      {
        PromptEntityResult per =
          ed.GetEntity("\nSelect hatch object: ");
        if (per.Status == PromptStatus.OK)
        {
          Transaction tr =
            doc.TransactionManager.StartTransaction();
          using (tr)
          {
            // Open up the object
            DBObject obj =
              tr.GetObject(per.ObjectId, OpenMode.ForRead);
            // Make sure we have a managed hatch object
            Hatch hat = obj as Hatch;
            if (hat != null)
            {
              // a COM hatch
              Autodesk.AutoCAD.Interop.Common.AcadHatch oHat =
                obj.AcadObject as
                Autodesk.AutoCAD.Interop.Common.AcadHatch;
              if (oHat != null)
              {
                // Now let's get the Origin as an array
                // of doubles, and print the contents
                double[] orig = (double[])oHat.Origin;
                ed.WriteMessage(
                  "\nHere's the hatch origin: X: " +
                  orig[0] + ", Y: " + orig[1]
                );
              }
            }
          }
        }
      }
      catch (System.Exception ex)
      {
        ed.WriteMessage(
          "Exception: " + ex
        );
      }
    }
  }
} 

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Runtime;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace CustomDialogs
{
  public partial class TypeViewerForm : Form
  {
    public TypeViewerForm()
    {
      InitializeComponent();
    }
    public void SetObjectText(string text)
    {
      typeTextBox.Text = text;
    }
    public void SetObjectId(ObjectId id)
    {
      if (id == ObjectId.Null)
      {
        SetObjectText("");
      }
      else
      {
        Document doc =
          Autodesk.AutoCAD.ApplicationServices.
            Application.DocumentManager.MdiActiveDocument;
        Transaction tr =
          doc.TransactionManager.StartTransaction();
        using (tr)
        {
          DBObject obj = tr.GetObject(id, OpenMode.ForRead);
          SetObjectText(obj.GetType().ToString());
          tr.Commit();
        }
      }
    }
    private void closeButton_Click(object sender, EventArgs e)
    {
      this.Close();
    }
    private void browseButton_Click(object sender, EventArgs e)
    {
      DocumentCollection dm =
        Autodesk.AutoCAD.ApplicationServices.
          Application.DocumentManager;
      Editor ed =
        dm.MdiActiveDocument.Editor;
      Hide();
      PromptEntityResult per =
        ed.GetEntity("\nSelect entity: ");
      if (per.Status == PromptStatus.OK)
      {
        SetObjectId(per.ObjectId);
      }
      else
      {
        SetObjectId(ObjectId.Null);
      }
      Show();
    }
  }
}

0h3thnfl0k5.png