Field

[CadFrank]

Bonjour,

 

J'essai de changer la valeur text d'un attribut qui contient un Field.

 

Par contre, quand ma commande terminer j'obtien un field "####"

 

 

 

public class Class
   {
       private const string BLOCKNAME = "SOL PL";
       private const string TAG_COUNT = "LONG";
       private const string TAG_SPACING = "ESPACEMENT";

       private const string PREFIX = "%<\\AcObjProp Object(%<\\_ObjId ";
       private const string SUFFIX = ">%).Parameter(39).lookupString>%";
       private string id;

       //private string textString;
       private int joistCount;
       private int spacing;

       enum DrawingUnit { Imperial, Metrique }

       [CommandMethod("CS", CommandFlags.UsePickSet)]
       public void CalculSolives()
       {
           Document document = Active.Document;
           Database database = Active.Database;
           Editor editor = Active.Editor;

           PromptSelectionResult psResults = editor.SelectImplied();
           if (psResults.Status == PromptStatus.Error)
           {
               // Adds options to the Results.
               PromptSelectionOptions psOptions = new PromptSelectionOptions();

               psOptions.MessageForAdding = "\nSélectionner les solives à calculer : ";

               // this captures the prompt values of the selected object
               psResults = editor.GetSelection(psOptions);
           }

           if (psResults.Status == PromptStatus.OK)
           {
               PromptDoubleResult pdResult = editor.GetDistance("Pour la distance utilisé par la/les solive(s). Choisir deux point. :");

               double distance = pdResult.Value;

               using (var transaction = database.TransactionManager.StartTransaction())
               {
                   ObjectId[] objIDs = psResults.Value.GetObjectIds();
                   foreach (ObjectId objID in objIDs)
                   {
                       RXClass attClass = RXClass.GetClass(typeof(BlockReference));
                       if (objID.ObjectClass.IsDerivedFrom(attClass))
                       {
                           BlockReference blockReference = transaction.GetObject(objID, OpenMode.ForRead) as BlockReference;

                           AttributeCollection attCollection = blockReference.AttributeCollection;

                           foreach (ObjectId attId in attCollection)
                           {
                               AttributeReference attReference = transaction.GetObject(attId, OpenMode.ForRead) as AttributeReference;

                               if (attReference.Tag == TAG_SPACING)
                               {
                                   spacing = getSpacing(attReference);
                               }

                               if (attReference.Tag == TAG_COUNT || attReference.HasFields == true)
                               {
                                   ObjectId fieldId = attReference.GetField();

                                   attReference.UpgradeOpen();

                                   id = fieldId.ToString();

                                   id = id.TrimStart('(');
                                   id = id.TrimEnd(')');


                                   joistCount = CalculerSolives(spacing, distance);

                                   string newString = {:content:}quot;({joistCount}) P.ALU {PREFIX}{id}{SUFFIX}";
                                   attReference.TextString = newString;
                               }
                           }
                       }
                   }
                   transaction.Commit();
                   editor.Regen();
               }
           }
       }

       private int getSpacing(AttributeReference attReference)
       {
           int spacing = 0;
           string textString = attReference.TextString;

           int index = textString.IndexOf('"');

           textString = textString.Substring(2, index - 2);

           textString = @textString.Trim('"', 'c', '/');

           try
           {
               spacing = Convert.ToInt32(textString);
           }
           catch (Exception)
           {
               Active.WriteMessage("Couldn't convert to int...");
           }

           if (CheckDrawingUnit() == DrawingUnit.Metrique)
           {
               switch (spacing)
               {
                   case 8:
                       spacing = 200;
                       break;
                   case 10:
                       spacing = 250;
                       break;
                   case 12:
                       spacing = 300;
                       break;
                   case 16:
                       spacing = 400;
                       break;
                   case 19:
                       spacing = 490;
                       break;
               }
           }
           return spacing;
       }

       private DrawingUnit CheckDrawingUnit()
       {
           if (Application.GetSystemVariable("DIMLUNIT").Equals(4))
           {
               return DrawingUnit.Imperial;
           }
           else
           {
               return DrawingUnit.Metrique;
           }
       }

       public int CalculerSolives(int espacement, double distance)
       {
           double nombreSolives = distance / espacement;

           Math.Round(nombreSolives, 0, MidpointRounding.ToEven);
           return Convert.ToInt32(nombreSolives);
       }

       public Field getField(Transaction tr, AttributeReference attReference)
       {
           if (attReference.HasFields)
           {
               Field field = Active.Database.TransactionManager.GetObject(attReference.GetField(), OpenMode.ForRead) as Field;

               return field;
           }
           return null;
       }
   }

   public static class Active
   {
       /// <summary>
       /// Returns the active Editor object.
       /// </summary>
       public static Document Document => Application.DocumentManager.MdiActiveDocument;


       /// <summary>
       /// Returns the active Database object.
       /// </summary>
       public static Database Database => Document.Database;

       /// <summary>
       /// Returns the active Editor object.
       /// </summary>
       public static Editor Editor => Document.Editor;


       /// <summary>
       /// Sends a string to the command line in the active Editor
       /// </summary>
       /// <param name="message">The message to send.</param>
       public static void WriteMessage(string message) => Editor.WriteMessage(message);

       /// <summary>
       /// Sends a string to the command line in the active Editor using String.Format.
       /// </summary>
       /// <param name="message">The message containing format specifications.</param>
       /// <param name="parameter">The variables to substitute into the format string.</param>
       public static void WriteMessage(string message, params object[] parameter) => Editor.WriteMessage(message, parameter);    }

[CadFrank]

Je ne suis pas capable d'y ajouter mon block malheureusement.

[x_all]

Je ne suis pas capable d'y ajouter mon block malheureusement.

 

Il faut faire par wetransfert ou grosfichiers.com ...

 

pour confirmer... un field, c'est un champ?

[CadFrank]

Il faut faire par wetransfert ou grosfichiers.com ...

 

pour confirmer... un field, c'est un champ?

 

Oui un Field est un champ, dsl mon AutoCAD est en anglais

 

 

Mon block

[CadFrank]

Finalement, j'avais pas a toucher au Field.

 

AttReference.TextString = NewString + AttReference.TextString

 

 

Sa marche sans défaire mon field...

 

Merci quand meme.