Through the Interface

    };

    private Document _doc;

    private FullSubentityPath _path;

    private ObjectId _entId;

    private ObjectId _selId;

    private ObjectId[] _objIds = null;

    public ObjectId LastSelected

    {

      get { return _selId; }

    }

    public SubEntityHighlighter(Document doc)

    {

      _doc = doc;

      _entId = ObjectId.Null;

      _path = FullSubentityPath.Null;

    }

    internal void Unhighlight()

    {

      if (

        _selId.ObjectClass.IsDerivedFrom(

          RXClass.GetClass(typeof(AttributeReference))

        )

      )

      {

        // For attributes we need to use acedRedraw to unhighlight

        var ename = new ads_name();

        acdbGetAdsName(ref ename, _selId);

        acedRedraw(ref ename, 4);

        return;

      }

      if (!_path.IsNull)

      {

        var tr =

          _doc.TransactionManager.StartOpenCloseTransaction();

        using (tr)

        {

          var ent = (Entity)tr.GetObject(_entId, OpenMode.ForRead);

          // ... and highlight the nested entity

          ent.Unhighlight(_path, false);

          tr.Commit();

          _path = FullSubentityPath.Null;

          _entId = ObjectId.Null;

          _selId = ObjectId.Null;

        }

      }

    }

    internal void Highlight(

      FullSubentityPath path, ObjectId entId, ObjectId selId

    )

    {

      Unhighlight();

      if (

        selId.ObjectClass.IsDerivedFrom(

          RXClass.GetClass(typeof(AttributeReference))

        )

      )

      {

        // For attributes we need to use acedRedraw to highlight

        var ename = new ads_name();

        acdbGetAdsName(ref ename, selId);

        acedRedraw(ref ename, 3);

      }

      else

      {

        var tr =

          _doc.TransactionManager.StartOpenCloseTransaction();

        using (tr)

        {

          var ent = (Entity)tr.GetObject(entId, OpenMode.ForRead);

          // Highlight the nested entity

          ent.Highlight(path, false);

          tr.Commit();

        }

      }

      _path = path;

      _entId = entId;

      _selId = selId;

    }

    internal FullSubentityPath BuildSubEntityPath(

      PromptNestedEntityResult rs,

      out ObjectId outer

    )

    {

      // Get the "containers" list. We store this as member data

      // to save getting it twice. This is the only reason this

      // method is not static...

      _objIds = rs.GetContainers();

      var ensel = rs.ObjectId;

      int len = _objIds.Length;

      ObjectId[] revIds;

      // Reverse the "containers" list

      revIds = new ObjectId[len + 1];

      for (int i = 0; i < len; i++)

      {

        var id = (ObjectId)_objIds.GetValue(len - i - 1);

        revIds.SetValue(id, i);

      }

      // Now add the selected entity to the end

      revIds.SetValue(ensel, len);

      outer = revIds[0];

      // Retrieve the sub-entity path for this entity

      var subEnt =

        new SubentityId(SubentityType.Null, System.IntPtr.Zero);

      return new FullSubentityPath(revIds, subEnt);

    }

    internal ObjectId[] GetContainers()

    {

      return _objIds;

    }

  }

  public class Commands3

  {

    [CommandMethod("MTIBJIGHL")]

    public void MoveTextInBlock()

    {

   
0;  var doc = Application.DocumentManager.MdiActiveDocument;

      var db = doc.Database;

      var ed = doc.Editor;

      // Start by getting the text (or other) object in the block

      var sehl = new SubEntityHighlighter(doc);

      PointMonitorEventHandler handler =

        delegate(object s, PointMonitorEventArgs e)

        {

          // Programmatically select the nested entity under

          // the cursor

          var pneo = new PromptNestedEntityOptions("");

          pneo.NonInteractivePickPoint = e.Context.ComputedPoint;

          pneo.UseNonInteractivePickPoint = true;

          var rs = ed.GetNestedEntity(pneo);

          if (rs.Status != PromptStatus.OK)

          {

            // If there wasn't anything there (very common)

            // we'll unhighlight anything highlighted

            sehl.Unhighlight();

            return;

          }

          // So we have something under the cursor: get the path

          // to it as well as the outermost entity ID

          ObjectId outer;

          var path = sehl.BuildSubEntityPath(rs, out outer);

          // Highlight the sub-entity

          sehl.Highlight(path, outer, rs.ObjectId);

        };

      // Set the object snap mode to 0, to be reset afterwards

      var os = (short)Application.GetSystemVariable("OSMODE");

      Application.SetSystemVariable("OSMODE", 0);

      // Ask for a point to be selected: we'll manually worry about

      // the pseudo-selection process

      var ppo = new PromptPointOptions("\nSelect text inside block");

      // Add our PointMonitor around the point selection call

      ed.PointMonitor += handler;

      var ppr = ed.GetPoint(ppo);

      ed.PointMonitor -= handler;

      // Reset the object snap mode right away

      Application.SetSystemVariable("OSMODE", os);

      // Get the last entity selected (Null if nothing)

      var selId = sehl.LastSelected;

      // If we don't have a valid ObjectId, don't continue

      if (ppr.Status != PromptStatus.OK || selId == ObjectId.Null)

      {

        sehl.Unhighlight();

        return;

      }

      // Check the type of object we're dealing with

      var oc = selId.ObjectClass;

      if (

        !oc.IsDerivedFrom(

          RXClass.GetClass(typeof(DBText))

        ) &&

        !oc.IsDerivedFrom(

          RXClass.GetClass(typeof(MText))

        )

      )

      {

        // Isn't a text object - ask whether we continue

        ed.WriteMessage(

          "\nObject is not text, it is a {0}.", oc.Name

        );

        var pko =

          new PromptKeywordOptions(

            "\nDo you want to continue? [Yes/No]", "Yes No"

          );

        pko.AppendKeywordsToMessage = true;

        pko.AllowNone = true;

        pko.Keywords.Default = "No";

        var pkr = ed.GetKeywords(pko);

        if (

          pkr.Status != PromptStatus.OK || pkr.StringResult == "No"

        )

        {

          sehl.Unhighlight();

          return;

        }

      }

      // Start a transaction to modify the object

      using (var tr = doc.TransactionManager.StartTransaction())

      {

        // Unless we get a block reference container, use the

        // identity matrix as the block transform

        var brMat = Matrix3d.Identity;

        // Get the containers around the nested entity

        var conts = sehl.GetContainers();

        foreach (var brId in conts)

        {

          var br =

            tr.GetObject(brId, OpenMode.ForRead) as BlockReference;

          if (br != null)

          {

            brMat = brMat.PreMultiplyBy(br.BlockTransform);

          }

        }

        // Transform the entity

        var ent = (Entity)tr.GetObject(selId, OpenMode.ForWrite);

        // Before we run the jig, transform the object by the

        // aggregate transform of the containers

        ent.TransformBy(brMat);

        // Run the jig to displace the object

        var dj = new DisplacementJig2(ent, ppr.Value);

        var pr2 = ed.Drag(dj);

        sehl.Unhighlight();

        if (pr2.Status == PromptStatus.OK)

        {

          // We can transform the entity back, now (at least in

          // terms of the containers: the displacement remains)

          ent.TransformBy(brMat.Inverse());

          // Open each of the containers and set a property so that

          // they each get regenerated

          foreach (var id in conts)

          {

            var ent2 = tr.GetObject(id, OpenMode.ForWrite) as Entity;

            if (ent2 != null)

            {

              // We might also have called this method:

              // ent2.RecordGraphicsModified(true);

              // but setting a property works better with undo

              ent2.Visible = ent2.Visible;

            }

          }

          tr.Commit();

        }

      }

    }

  }

}