在窗体上显示实体（BlockPreviewManager）

 using System;
using System.IO;
using System.Drawing;
using System.Windows.Forms;
using System.Collections;
using System.Collections.Generic;
using Autodesk..GraphicsSystem;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.GraphicsInterface;
using Autodesk.AutoCAD.ApplicationServices;
using TlsCad.Utils;
using TlsCad.ExtendMethods;
namespace TlsCad.Trans
{
    public class BlockPreviewManager : IEnumerable,IDisposable
    {
        List[B] m_Previews = new List[B]();
        Color m_BackColor = Color.Empty;
        Database m_Database = null;
        private Autodesk.AutoCAD.GraphicsSystem.RenderMode m_RenderMode = Autodesk.AutoCAD.GraphicsSystem.RenderMode.Wireframe;
        private VisualStyleType m_VisualStyleType = VisualStyleType.Basic;
        bool m_AllowMouseEvents = false;
        bool m_DisplayByBlock = true;
        #region Properties
        public Autodesk.AutoCAD.GraphicsSystem.RenderMode RenderMode
        {
            set { m_RenderMode = value; }
            get { return m_RenderMode; }
        }
        public VisualStyleType ViewStyle
        {
            set { m_VisualStyleType = value; }
            get { return m_VisualStyleType; }
        }
        public Database Database
        {
            get { return m_Database; }
        }
        public Color BackColor
        {
            set { m_BackColor = value; }
            get { return m_BackColor; }
        }
        public bool AllowMouseEvents
        {
            set { m_AllowMouseEvents = true; }
            get { return m_AllowMouseEvents; }
        }
        public bool DisplayByBlock
        {
            get { return m_DisplayByBlock; }
            set { m_DisplayByBlock = value; }
        }
        public BlockPreview this[int index]
        {
            get
            {
                if (index >= 0 && index  ents = new List();
                        foreach (ObjectId id in btr)
                        {
                            ents.Add((Entity)tr.GetObject(id, OpenMode.ForRead).Clone());
                        }
                        return Add(panel, ents, ext3d);
                    }
                }
            }
            return null;
        }
        public BlockPreview Add(Panel panel, BlockTableRecord btr, Extents3d ext3d)
        {
            BlockPreview bp = 
                new BlockPreview(
                   this,
                   panel,
                   btr,
                   ext3d);
            m_Previews.Add(bp);
            return bp;
        }
        public BlockPreview Add(Panel panel, List ents, Extents3d ext3d)
        {
            BlockPreview bp =
               new BlockPreview(
                   this,
                   panel,
                   ents,
                   ext3d);
            m_Previews.Add(bp);
            return bp;
        }
        public BlockPreview Add(IEnumerable ents, Extents3d ext3d)
        {
            BlockPreview bp =
               new BlockPreview(
                   this,
                   ents,
                   ext3d);
            m_Previews.Add(bp);
            return bp;
        }
        public BlockPreview Add(IEnumerable ents)
        {
            BlockPreview bp =
               new BlockPreview(
                   this,
                   ents,
                   DbUtility.GetExtents(ents));
            m_Previews.Add(bp);
            return bp;
        }
        public void RemoveAt(int index)
        {
            if (index >= 0 && index = 0 && index  ents = new List();
                            
                            foreach (ObjectId id in btr)
                            {
                                ents.Add((Entity)tr.GetObject(id, OpenMode.ForRead).Clone());
                            }
                            Display(index, ents, ext3d);
                        }
                        return true;
                    }
                }
            }
            return false;
        }
        private void Display(int index, BlockTableRecord btr, Extents3d ext3d)
        {
            m_Previews[index].Display(btr, ext3d);
        }
        private void Display(int index, IEnumerable ents, Extents3d ext3d)
        {
            m_Previews[index].Display(ents, ext3d);
        }
        public void Refresh()
        {
            foreach (BlockPreview bp in m_Previews)
            {
                bp.Refresh();
            }
        }
        #endregion
        #region IEnumerable 成员
        IEnumerator IEnumerable.GetEnumerator()
        {
            return m_Previews.GetEnumerator();
        }
        #endregion
        #region IDispose
        public void Dispose()
        {
            foreach (BlockPreview bp in m_Previews)
            {
                bp.Dispose();
            }
        }
        #endregion
    }
}

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Collections.Generic;
using System.Drawing.Imaging;
using GSView = Autodesk.AutoCAD.GraphicsSystem.View;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.GraphicsSystem;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.GraphicsInterface;
using Autodesk.AutoCAD.ApplicationServices;
using TlsCad.Utils;
namespace TlsCad.Trans
{
    public class BlockPreview : IDisposable
    {
        public enum PreviewStatus
        {
            Nothing = 0,
            Orbiting = 1,
            Panning = 2,
        }
        private Panel m_Panel = null;
        // Gs specific
        private static Manager m_Manager = null;
        private Device m_Device = null;
        private Model m_Model = null;
        private GSView m_View = null;
        // flags
        private bool m_MouseDown = false;
        private PreviewStatus m_PreviewStatus;
        private System.Drawing.Point m_StartPoint;
        private System.Drawing.Point m_EndPoint;
        private BlockPreviewManager m_Owner;
        private bool m_DisplayByBlock;
        private BlockTableRecord m_BlockTableRecord;
        private List m_Entitys;        #region Property
        public Color BackColor
        {
            set
            {
                //update it
                m_Device.BackgroundColor = value;
                // finally set the logical palette
                m_Device.SetLogicalPalette(GsUtility.MyAcadColorPs);
                // now update the gs view
                Refresh();
            }
        }
        public static Manager Manager
        {
            get { return m_Manager; }
            set { m_Manager = value; }
        }
        public Device Device
        {
            get { return m_Device; }
            set { m_Device = value; }
        }
        public Model Model
        {
            get { return m_Model; }
            set { m_Model = value; }
        }
        public GSView View
        {
            get { return m_View; }
            set { m_View = value; }
        }
        public bool MouseDown
        {
            get { return m_MouseDown; }
            set { m_MouseDown = value; }
        }
        public Point StartPoint
        {
            get { return m_StartPoint; }
            set { m_StartPoint = value; }
        }
        public Point EndPoint
        {
            get { return m_EndPoint; }
            set { m_EndPoint = value; }
        }        public Entity this[int index]
        {
            get
            {
                if (index >= 0 && index  entitys, Extents3d ext)
        {
            Initialize(owner, DbUtility.GetSize(ext));
            Display(entitys, ext);
        } 
        
        internal BlockPreview(BlockPreviewManager owner, Panel panel, List entitys, Extents3d ext)
        {
            Initialize(owner, panel);
            Display(entitys, ext);
        }
        internal void Display(IEnumerable entitys, Extents3d ext)
        {
            if (m_View != null)
            {
                m_View.EraseAll();
                SetViewTo(ext);
                m_DisplayByBlock = false;
                m_Entitys = new List();
                AddEntity(entitys);
                Refresh();
            }
        }
        public void AddEntity(params Entity[] entitys)
        {
            foreach (Entity ent in entitys)
            {
                m_Entitys.Add(ent);
                m_View.Add(ent, m_Model);
            }
        }
        public void AddEntity(IEnumerable entitys)
        {
            foreach (Entity ent in entitys)
            {
                m_Entitys.Add(ent);
                m_View.Add(ent, m_Model);
            }
        }
        public void RemoveEntity(params Entity[] entitys)
        {
            foreach (Entity ent in entitys)
            {
                m_Entitys.Remove(ent);
                m_View.Erase(ent);
            }
        }
        public void RemoveEntity(IEnumerable entitys)
        {
            foreach (Entity ent in entitys)
            {
                m_Entitys.Remove(ent);
                m_View.Erase(ent);
            }
        }
        public void Update(params int[] indexs)
        {
            if (m_View != null)
            {
                if (!m_DisplayByBlock)
                {
                    foreach (int index in indexs)
                    {
                        Entity ent = this[index];
                        if (ent != null)
                        {
                            m_View.Erase(ent);
                            m_View.Add(ent, m_Model);
                        }
                    }
                }
            }
        }
        public void Update(IEnumerable[i] indexs)
        {
            if (m_View != null)
            {
                if (!m_DisplayByBlock)
                {
                    foreach (int index in indexs)
                    {
                        Entity ent = this[index];
                        if (ent != null)
                        {
                            m_View.Erase(ent);
                            m_View.Add(ent, m_Model);
                        }
                    }
                }
            }
        }
        public void Update(params Entity[] entitys)
        {
            if (m_View != null)
            {
                if (!m_DisplayByBlock)
                {
                    foreach (Entity ent in entitys)
                    {
                        m_View.Erase(ent);
                        m_View.Add(ent, m_Model);
                    }
                }
            }
        }
        public void Update(IEnumerable entitys)
        {
            if (m_View != null)
            {
                if (!m_DisplayByBlock)
                {
                    foreach (Entity ent in entitys)
                    {
                        m_View.Erase(ent);
                        m_View.Add(ent, m_Model);
                    }
                }
            }
        }
        #endregion
        #region Inage
        public void Save(string filename, ImageFormat format)
        {
            using (Bitmap bitmap = GetImage())
            {
                bitmap.Save(filename, format);
            }
        }
        public Bitmap GetImage()
        {
            return m_Device.GetSnapshot(m_View.Viewport);
        }
        public void Refresh()
        {
            m_View.Invalidate();
            m_View.Update();
        }        // draws the zoom window rectangle
        public void RubberRectangle(Point startPt, Point endPt)
        {
            // create a new instance of my GDI helper class, it seems too tricky to create simple XOR graphics
            // in .NET so let's resort to direct calls instead
            GsUtility.RubberbandRectangle rect = new GsUtility.RubberbandRectangle();
            System.Drawing.Graphics graphics = m_Panel.CreateGraphics();
            // draw the XOR rectangle 
            rect.DrawXORRectangle(graphics, startPt, endPt);
        }
        #endregion
        #region Events
        protected void OnPaint(object sender, PaintEventArgs e)
        {
            Refresh();
        }
        public void OnMouseWheel(object sender, MouseEventArgs e)
        {
            if (e.Delta  1.0)     // outside the radius
                            {
                                double x = last_vector.X / last_vector.Length;
                                double y = last_vector.Y / last_vector.Length;
                                double z = last_vector.Z / last_vector.Length;
                                last_vector = new Vector3d(x, y, z);
                            }
                            else
                            {
                                double x = last_vector.X;
                                double y = last_vector.Y;
                                double z = System.Math.Sqrt(1.0 - last_vector.X * last_vector.X - last_vector.Y * last_vector.Y);
                                last_vector = new Vector3d(x, y, z);
                            }
                            Vector3d new_vector = new Vector3d((e.Location.X - centerX) / radius, -(e.Location.Y - centerY) / radius, 0.0);
                            if (new_vector.LengthSqrd > 1.0)     // outside the radius
                            {
                                double x = new_vector.X / new_vector.Length;
                                double y = new_vector.Y / new_vector.Length;
                                double z = new_vector.Z / new_vector.Length;
                                new_vector = new Vector3d(x, y, z);
                            }
                            else
                            {
                                double x = new_vector.X;
                                double y = new_vector.Y;
                                double z = System.Math.Sqrt(1.0 - new_vector.X * new_vector.X - new_vector.Y * new_vector.Y);
                                new_vector = new Vector3d(x, y, z);
                            }
                            // determine angles for proper sequence of camera manipulations:
                            Vector3d rotation_vector = last_vector;
                            rotation_vector = rotation_vector.CrossProduct(new_vector);  // rotation_vector = last_vector x new_vector
                            Vector3d work_vector = rotation_vector;
                            work_vector = new Vector3d(work_vector.X, work_vector.Y, 0.0f);                      // projection of rotation_vector onto xy plane
                            double roll_angle = System.Math.Atan2(work_vector.X, work_vector.Y);        // assuming that the camera's up vector is "up",
                            // this computes the angle between the up vector 
                            // and the work vector, which is the roll required
                            // to make the up vector coincident with the rotation_vector
                            double length = rotation_vector.Length;
                            double orbit_y_angle = (length != 0.0) ? System.Math.Acos(rotation_vector.Z / length) + Half_Pi : Half_Pi;                   // represents inverse cosine of the dot product of the
                            if (length > 1.0f)                                              // rotation_vector and the up_vector divided by the
                                length = 1.0f;                                              // magnitude of both vectors.  We add pi/2 because we 
                            // are making the up-vector parallel to the the rotation
                            double rotation_angle = System.Math.Asin(length);                // vector ... up-vector is perpin. to the eye-vector.
                            // perform view manipulations
                            m_View.Roll(roll_angle);               // 1: roll camera to make up vector coincident with rotation vector
                            m_View.Orbit(0.0f, orbit_y_angle);     // 2: orbit along y to make up vector parallel with rotation vector
                            m_View.Orbit(rotation_angle, 0.0f);     // 3: orbit along x by rotation angle
                            m_View.Orbit(0.0f, -orbit_y_angle);     // 4: orbit along y by the negation of 2
                            m_View.Roll(-roll_angle);               // 5: roll camera by the negation of 1
                            break;
                    }
                    Refresh();
                    m_StartPoint = e.Location;
                }
            }
        }
        protected void OnMouseDown(object sender, MouseEventArgs e)
        {
            m_MouseDown = true;
            switch (e.Button)
            {
                case MouseButtons.Left:
                    m_PreviewStatus = PreviewStatus.Orbiting;
                    break;
                case MouseButtons.Right:
                    m_PreviewStatus = PreviewStatus.Panning;
                    break;
            }
            m_StartPoint = e.Location;
        }
        protected void OnMouseUp(object sender, MouseEventArgs e)
        {
            switch (e.Button)
            {
                case MouseButtons.Left:
                    m_PreviewStatus -= (int)PreviewStatus.Orbiting;
                    break;
                case MouseButtons.Right:
                    m_PreviewStatus -= (int)PreviewStatus.Panning;
                    break;
            }
            m_PreviewStatus = PreviewStatus.Nothing;
            m_MouseDown = false;
        }
        protected void OnSizeChanged(object sender, EventArgs e)
        {
            if (m_Device != null)
            {
                m_Device.OnSize(m_Panel.Size);
            }
        }
        #endregion
        #region IDispose
        public void Dispose()
        {
            if (m_Device != null)
            {
                bool b = m_Device.Erase(m_View);
            }
            if (m_View != null)
            {
                m_View.EraseAll();
                m_View.Dispose();
                m_View = null;
            }
            if (m_Manager != null)
            {
                if (m_Model != null)
                {
                    m_Model.Dispose();
                    m_Model = null;
                }
                if (m_Device != null)
                {
                    m_Device.Dispose();
                    m_Device = null;
                }
            }
        }
        #endregion
    }
}

        [CommandMethod("t1")]
        public void Test1()
        {
            PromptSelectionResult res = Helper.Editor.GetSelection();
            if (res.Status == PromptStatus.OK)
            {
                using (DBTransaction tr = new DBTransaction())
                {
                    List ents = new List();
                    foreach (ObjectId id in res.Value.GetObjectIds())
                    {
                        Entity ent = (Entity)tr.GetObject(id, OpenMode.ForRead);
                        ents.Add((Entity)ent.Clone());
                    }
                    using (BlockPreviewManager bps = new BlockPreviewManager())
                    {
                        BlockPreview bp = bps.Add(ents);
                        bp.Save("d:\\1.jpg", System.Drawing.Imaging.ImageFormat.Jpeg);
                    }
                }
            }
        }