MARKUS

/////////////////////////////////////////////////////////////////////////////// 

// Copyright (C) 2002-2018, Open Design Alliance (the "Alliance"). 

// All rights reserved. 

// 

// This software and its documentation and related materials are owned by 

// the Alliance. The software may only be incorporated into application 

// programs owned by members of the Alliance, subject to a signed 

// Membership Agreement and Supplemental Software License Agreement with the

// Alliance. The structure and organization of this software are the valuable  

// trade secrets of the Alliance and its suppliers. The software is also 

// protected by copyright law and international treaty provisions. Application  

// programs incorporating this software must include the following statement 

// with their copyright notices:

//   

//   This application incorporates Teigha(R) software pursuant to a license 

//   agreement with Open Design Alliance.

//   Teigha(R) Copyright (C) 2002-2018 by Open Design Alliance. 

//   All rights reserved.

//

// By use of this software, its documentation or related materials, you 

// acknowledge and accept the above terms.

///////////////////////////////////////////////////////////////////////////////

///

using System;

using System.Windows.Interop;

using Teigha.Core;

using Teigha.TD;

using System.Windows;

using System.Diagnostics;

using System.Windows.Controls;

using System.Threading;

using Newtonsoft.Json;

using System.IO;

using System.Reflection;

using System.Windows.Input;

namespace KCOM.Controls

{

    internal class TeighaD3DImageResult : D3DImage

    {

        public static Size NewSize = new Size(0, 0);

        private static OdDbDatabase TDDatabase = null;

        public delegate void LoadFileDelegate(String fPath);

        public delegate void RunTestDelegate();

        public LoadFileDelegate loadFile = null;

        public OdRxObject odRxObjectSurface = null;

        public OdRxVariantValue surfaceVariantValue = null;

        class SystemServices : RxSystemServicesImpl

        {

            public SystemServices()

            {

                Teigha.Core.Globals.odActivate(ActivationData.userInfo, ActivationData.userSignature);

            }

        }

        public String FilePath

        {

            get { return pFilePath; }

            set

            {

                pFilePath = value;

                if (null != loadFile)

                {

                    loadFile(pFilePath);

                }

            }

        }

        public OdGeExtents3d extents { get; private set; }

        public String pFilePath = String.Empty;

        private SystemServices Serv = null;

        public ExHostAppServices HostApp = null;

        uint[] curPalette;

        public static OdGsView pView = null;

        OdGsModule pGs = null;

        public static OdGsDevice mDevice = null;

        public static OdGsLayoutHelper mHelper = null;

        public OdGePoint3d[] PointLoad()

        {

            OdGePoint3d[] pt = new OdGePoint3d[4];

            OdGePoint3d extMax = TDDatabase.getEXTMAX();

            OdGePoint3d extMin = TDDatabase.getEXTMIN();

            pt[0] = extMin; //left, bottom

            pt[1] = new OdGePoint3d(0.0, extMax.y, 0.0); //left, top

            pt[2] = extMax; //right, top

            pt[3] = new OdGePoint3d(extMax.x, 0.0, 0.0); //right, bottom            

            if (pView != null)

            {

                Lock();

                using (startPolyLine = OdDbPolyline.createObject())

                {

                    startPolyLine.addVertexAt(0, new OdGePoint2d(pt[1].x - 4, pt[1].y - 4));

                    startPolyLine.addVertexAt(1, new OdGePoint2d(pt[1].x - 4, pt[1].y + 4));

                    startPolyLine.addVertexAt(2, new OdGePoint2d(pt[1].x + 4, pt[1].y + 4));

                    startPolyLine.addVertexAt(3, new OdGePoint2d(pt[1].x + 4, pt[1].y - 4));

                    startPolyLine.setClosed(true);

                    startPolyLine.setLineWeight(LineWeight.kLnWt211);

                    startPolyLine.setColorIndex((ushort)(OdCmEntityColor.ACIcolorMethod.kACIGreen));

                    OdDbBlockTableRecord model = (OdDbBlockTableRecord)TDDatabase.getModelSpaceId().safeOpenObject(OpenMode.kForWrite);

                    startOdDbObjectId = model.appendOdDbEntity(startPolyLine);

                }

                using (endPolyLine = OdDbPolyline.createObject())

                {

                    endPolyLine.addVertexAt(0, new OdGePoint2d(pt[3].x - 4, pt[3].y - 4));

                    endPolyLine.addVertexAt(1, new OdGePoint2d(pt[3].x - 4, pt[3].y + 4));

                    endPolyLine.addVertexAt(2, new OdGePoint2d(pt[3].x + 4, pt[3].y + 4));

                    endPolyLine.addVertexAt(3, new OdGePoint2d(pt[3].x + 4, pt[3].y - 4));

                    endPolyLine.setClosed(true);

                    endPolyLine.setLineWeight(LineWeight.kLnWt211);

                    endPolyLine.setColorIndex((ushort)(OdCmEntityColor.ACIcolorMethod.kACIGreen));

                    OdDbBlockTableRecord model = (OdDbBlockTableRecord)TDDatabase.getModelSpaceId().safeOpenObject(OpenMode.kForWrite);

                    endOdDbObjectId = model.appendOdDbEntity(endPolyLine);

                }

                mDevice.invalidate();

                mDevice.update(new OdGsDCRect(0, (int)NewSize.Width, (int)NewSize.Height, 0));//mDevice.update();

                UpdateDirtyRect();

                Unlock();

            }

            return pt;

        }

        public HwndSource wndSource = null;

        public TeighaD3DImageResult()

        {

            Serv = new SystemServices();

            HostApp = new CustomServices();

            TD_Db.odInitialize(Serv);

            Globals.odgsInitialize();

            InitializeGDIModule();

            loadFile = new LoadFileDelegate(LoadDWGFile);

            if (String.Empty != pFilePath)

            {

                loadFile(pFilePath);

                //InitializeSurface();

            }

        }

        private static OdGePoint3d getWorldCoordinateByScreen(OdGsLayoutHelper hDevice, OdGePoint2d screenPoint)

        {

            pView = hDevice.activeView();

            //directions, origin, etc

            OdGePoint3d target = pView.target();

            OdGeVector3d direction = target - pView.position();

            OdGeVector3d yVector = pView.upVector();

            OdGeVector3d xVector = direction.crossProduct(yVector).normal();

            OdGePoint3d center, stepX, stepY;

            {

                center = new OdGePoint3d(target);

                stepX = target + xVector;

                stepY = target + yVector;

                OdGeMatrix3d matrix = pView.worldToDeviceMatrix();

                stepX.transformBy(matrix);

                stepY.transformBy(matrix);

                center.transformBy(matrix);

            }

            //make the calculation

            OdGePoint3d result;

            {

                double x, y;

                x = (screenPoint.x - center.x) / (stepX.x - center.x);

                y = (screenPoint.y - center.y) / (stepY.y - center.y);

                result = target + xVector * x + yVector * y;

            }

            return result;

        }

        public void OnMouseWheel(MouseWheelEventArgs e, Point cp)

        {

            if (mDevice == null)

                return;

            OdGePoint2d correctScreenPoint = new OdGePoint2d(cp.X, cp.Y);

            OdGePoint3d worldPoint = getWorldCoordinateByScreen(mHelper, correctScreenPoint);

            //OnZoom(e.Delta / 120);

            Zoom(e.Delta > 0);

            //shift back

            pView = mHelper.activeView();

            //get new screen point of the same world point

            OdGeMatrix3d worldToDevice = pView.worldToDeviceMatrix();

            OdGePoint3d newScreenPoint = worldToDevice * worldPoint;

            //get world points on the focal plane

            OdGePoint3d movingPoint = getWorldCoordinateByScreen(mHelper, new OdGePoint2d(newScreenPoint.x, newScreenPoint.y));

            OdGePoint3d destinationPoint = getWorldCoordinateByScreen(mHelper, correctScreenPoint);

            OdGePoint3d position = pView.position(), target = pView.target();

            OdGeVector3d upVector = pView.upVector();

            double width = pView.fieldWidth(), height = pView.fieldHeight();

            bool isPerspective = pView.isPerspective();

            //shift the camera so points coincide

            OdGeVector3d offset = destinationPoint - movingPoint;

            position -= offset;

            target -= offset;

            pView.setView(position, target, upVector, width, height, isPerspective ? OdGsView.Projection.kPerspective : OdGsView.Projection.kParallel);

        }

        public void LoadDWGFile(String filePath)

        {

            TDDatabase = HostApp.readFile(filePath);

            if (null == TDDatabase)

            {

                return;

            }

            // Create a new OdGsDevice object, and associate with the vectorization GsDevice

            mDevice = pGs.createDevice();

            // use the wndSource to set the WindowHWND parameter of device - we put the handle of auxiliary invisible window

            mDevice.properties().putAt("WindowHWND", new OdRxVariantValue(wndSource.Handle.ToInt32()));

            // Set the device background color and palette

            curPalette = AllPalettes.getLightPalette();

            mDevice.setBackgroundColor(curPalette[0]);

            mDevice.setLogicalPalette(curPalette, 256);

            OdGiContextForDbDatabase ctx1 = OdGiContextForDbDatabase.createObject();

            ctx1.enableGsModel(true);

            ctx1.setDatabase(TDDatabase);

            mDevice.setUserGiContext(ctx1);

            //   mDevice = (OdGsDevice)TD_Db.setupActiveLayoutViews(mDevice, ctx1);

            mHelper = CreateLayoutHelper(mDevice, ctx1);

            bool bModelSpace = TDDatabase.getTILEMODE();

            pView = mDevice.viewAt(0);

            OdAbstractViewPE pViewPe = OdAbstractViewPE.cast(pView);

            pViewPe.zoomExtents(pView);

            //  OdDbObject pView = TDDatabase.activeViewportId().openObject();

            //  OdDbAbstractViewportData pViewPE = OdDbAbstractViewportData.cast(pView);

            //   pViewPE.zoomExtents(pView);

            if ((NewSize.Width != 0) && (NewSize.Height != 0))

            {

                mDevice.onSize(new OdGsDCRect(0, (int)NewSize.Width, (int)NewSize.Height, 0));

            }

            else

            {

                mDevice.onSize(new OdGsDCRect(0, 300, 300, 0));

            }

            InitializeSurface();

            // call OnRnderSizeChanged to adjust drawing to size of control, not to size of invisible window

            OnRenderSizeChanged(NewSize);

        }

        public static OdGiContextForDbDatabase CreateContextForDbDatabase(OdDbDatabase db)

        {

            OdGiContextForDbDatabase ctx = OdGiContextForDbDatabase.createObject();

            ctx.enableGsModel(true);

            ctx.setDatabase(db);

            return ctx;

        }

        public static OdGsLayoutHelper CreateLayoutHelper(OdGsDevice pDevice, OdGiContextForDbDatabase ctx)

        {

            OdGsLayoutHelper hDevice = TD_Db.setupActiveLayoutViews(pDevice, ctx);

            OdDbDatabase db = ctx.getDatabase();

            // Set the device background color and palette

            uint[] CurPalette = Teigha.Core.AllPalettes.getLightPalette();

            hDevice.setBackgroundColor(CurPalette[0]);

            hDevice.setLogicalPalette(CurPalette, 256);

            // Return true if and only the current layout is a paper space layout

            bool bModelSpace = db.getTILEMODE();

            // Set the viewport border properties

            SetViewportBorderProperties(hDevice, !bModelSpace, CurPalette[7]);

            //Set render mode

            hDevice.activeView().setMode(OdGsView.RenderMode.kFlatShadedWithWireframe);

            return hDevice;

        }

        private static void SetViewportBorderProperties(OdGsLayoutHelper pDevice, bool bModel, uint color7)

        {

            int n = pDevice.numViews();

            if (n > 1)

            {

                for (int i = bModel ? 0 : 1; i < n; ++i)

                {

                    // Get the viewport

                    pView = pDevice.viewAt(i);

                    // Make it visible

                    pView.setViewportBorderVisibility(true);

                    // Set the color and width

                    pView.setViewportBorderProperties(color7, 1);

                }

            }

        }

        private static OdGsDCPoint[] SelectionPointsByPointOnScreen(OdGsLayoutHelper dev, OdDbDatabase db, int x, int y)

        {

            OdGePoint3d pt = ScreenPointToWorld(dev, x, y);

            pt = pt.transformBy(dev.activeView().worldToDeviceMatrix());

            short pb = db.getSysVar("PICKBOX").getInt16();

            OdGsDCPoint pt1 = new OdGsDCPoint((int)pt.x - pb, (int)pt.y - pb);

            OdGsDCPoint pt2 = new OdGsDCPoint((int)pt.x + pb, (int)pt.y + pb);

            OdGsDCPoint[] pts = new OdGsDCPoint[] { pt1, pt2 };

            return pts;

        }

        public static OdGePoint3d ScreenPointToWorld(OdGsLayoutHelper helperDevice, double x, double y)

        {

            MemoryTransaction tr = MemoryManager.GetMemoryManager().StartTransaction();

            OdGsView pView = helperDevice.activeView();

            OdGePoint3d wcsPt = new OdGePoint3d(x, y, 0.0);

            wcsPt = wcsPt.transformBy((pView.screenMatrix() * pView.projectionMatrix()).inverse());

            wcsPt = new OdGePoint3d(wcsPt.x, wcsPt.y, 0.0);

            OdAbstractViewPE pVpPE = OdAbstractViewPE.cast(pView);

            OdGePoint3d result = wcsPt.transformBy(pVpPE.eyeToWorld(pView));

            MemoryManager.GetMemoryManager().StopTransaction(tr);

            return result;

        }

        private void InitializeGDIModule()

        {

            try

            {

                pGs = (OdGsModule)Globals.odrxDynamicLinker().loadModule("WinDirectX.txv", false);

            }

            catch (Exception err)

            {

                MessageBox.Show(err.Message, "Error1");

                return;

            }

        }

        public void OnRenderSizeChanged(Size size)

        {

            NewSize = size;

            if (null != mDevice)

            {                

                {

                    Lock();

                    SetBackBuffer(D3DResourceType.IDirect3DSurface9, IntPtr.Zero);

                    Unlock();

                    OdRxObject.ReleasePointer(odRxObjectSurface);

                    mDevice.onSize(new OdGsDCRect(0, (int)NewSize.Width, (int)NewSize.Height, 0));

                    mDevice.update(new OdGsDCRect(0, (int)NewSize.Width, (int)NewSize.Height, 0));//mDevice.update();

                    odRxObjectSurface = mDevice.properties().getAt("D3DSurface");

                    surfaceVariantValue = new OdRxVariantValue(odRxObjectSurface);

                    IntPtr surface = IntPtr.Zero;

                    if (IntPtr.Size == 8)

                    {

                        surface = (IntPtr)surfaceVariantValue.AsInt64();

                    }

                    else

                    {

                        surface = (IntPtr)surfaceVariantValue.AsInt32();

                    }

                    if (IntPtr.Zero != surface)

                    {

                        Lock();

                        SetBackBuffer(D3DResourceType.IDirect3DSurface9, surface);

                        UpdateDirtyRect();

                        Unlock();

                    }

                }

            }

        }

        public void InitializeSurface()

        {

            if (IsFrontBufferAvailable)

            {

                if (null != mDevice)

                {

                    mDevice.update(new OdGsDCRect(0, (int)NewSize.Width, (int)NewSize.Height, 0));//mDevice.update();

                    if (mDevice.properties().has("D3DSurface"))

                    {

                        odRxObjectSurface = mDevice.properties().getAt("D3DSurface");

                        surfaceVariantValue = new OdRxVariantValue(odRxObjectSurface);

                        IntPtr surface = IntPtr.Zero;

                        if (IntPtr.Size == 8)

                        {

                            surface = (IntPtr)surfaceVariantValue.AsInt64();

                        }

                        else

                        {

                            surface = (IntPtr)surfaceVariantValue.AsInt32();

                        }

                        if (IntPtr.Zero != surface)

                        {

                            Lock();

                            SetBackBuffer(D3DResourceType.IDirect3DSurface9, surface);

                            UpdateDirtyRect();

                            Unlock();

                        }

                    }

                }

            }

        }

        void UpdateDirtyRect()

        {

            Int32Rect updateRect = new Int32Rect();

            updateRect.X = updateRect.Y = 0;

            updateRect.Width = this.PixelWidth;

            updateRect.Height = this.PixelHeight;

            this.AddDirtyRect(updateRect);

        }

        public void Zoom(bool IsZoomIn)

        {

            if (pView != null)

            {

                Lock();

                pView.zoom(IsZoomIn ? 1.0 / 0.9 : 0.9);

                mDevice.update(new OdGsDCRect(0, (int)NewSize.Width, (int)NewSize.Height, 0));//mDevice.update();

                UpdateDirtyRect();

                Unlock();

            }

        }

        public void Dolly(double x, double y, double z)

        {

            if (pView != null)

            {

                Lock();

                pView.dolly(x, y, z);

                mDevice.update(new OdGsDCRect(0, (int)NewSize.Width, (int)NewSize.Height, 0));//mDevice.update();

                UpdateDirtyRect();

                Unlock();

            }

        }

        public void OnMouseDolly(MouseEventArgs e, Point sp, Point cp)

        {

            if (mDevice == null)

                return;

            OdGePoint2d sScreenPoint = new OdGePoint2d(sp.X, sp.Y);

            OdGePoint2d cScreenPoint = new OdGePoint2d(cp.X, cp.Y);

            OdGePoint3d sPoint = getWorldCoordinateByScreen(mHelper, sScreenPoint);

            OdGePoint3d cPoint = getWorldCoordinateByScreen(mHelper, cScreenPoint);

            OdGePoint3d worldPoint = new OdGePoint3d(sPoint.x - cPoint.x, sPoint.y - cPoint.y, 0);

            Dolly(worldPoint.x, worldPoint.y, worldPoint.z);

        }

        private OdDbPolyline startPolyLine;

        private OdDbPolyline endPolyLine;

        private static OdDbObjectId startOdDbObjectId;

        private static OdDbObjectId endOdDbObjectId;

        public void DrawPoint(OdGePoint3d point, DrawType drawType)

        {

            if (pView != null)

            {

                Lock();

                if (drawType == DrawType.sp)

                {

                    //지우고

                    if (startOdDbObjectId != null)

                    {

                        OdDbObject obj = startOdDbObjectId.safeOpenObject(OpenMode.kForWrite);

                        obj.erase();

                        startOdDbObjectId = null;

                    }

                    //그리고

                    using (OdDbPolyline newStartPolyLine = OdDbPolyline.createObject())

                    {

                        newStartPolyLine.addVertexAt(0, new OdGePoint2d(point.x - 4, point.y - 4));

                        newStartPolyLine.addVertexAt(1, new OdGePoint2d(point.x - 4, point.y + 4));

                        newStartPolyLine.addVertexAt(2, new OdGePoint2d(point.x + 4, point.y + 4));

                        newStartPolyLine.addVertexAt(3, new OdGePoint2d(point.x + 4, point.y - 4));

                        newStartPolyLine.setClosed(true);

                        newStartPolyLine.setLineWeight(LineWeight.kLnWt211);

                        newStartPolyLine.setColorIndex((ushort)(OdCmEntityColor.ACIcolorMethod.kACIGreen));

                        OdDbBlockTableRecord model = (OdDbBlockTableRecord)TDDatabase.getModelSpaceId().safeOpenObject(OpenMode.kForWrite);

                        startOdDbObjectId = model.appendOdDbEntity(newStartPolyLine);

                    }

                }

                else if (drawType == DrawType.ep)

                {

                    //지우고

                    if (endOdDbObjectId != null)

                    {

                        OdDbObject obj = endOdDbObjectId.safeOpenObject(OpenMode.kForWrite);

                        obj.erase();

                        endOdDbObjectId = null;

                    }

                    //그리고

                    using (OdDbPolyline newEndPolyLine = OdDbPolyline.createObject())

                    {

                        newEndPolyLine.addVertexAt(0, new OdGePoint2d(point.x - 4, point.y - 4));

                        newEndPolyLine.addVertexAt(1, new OdGePoint2d(point.x - 4, point.y + 4));

                        newEndPolyLine.addVertexAt(2, new OdGePoint2d(point.x + 4, point.y + 4));

                        newEndPolyLine.addVertexAt(3, new OdGePoint2d(point.x + 4, point.y - 4));

                        newEndPolyLine.setClosed(true);

                        newEndPolyLine.setLineWeight(LineWeight.kLnWt211);

                        newEndPolyLine.setColorIndex((ushort)(OdCmEntityColor.ACIcolorMethod.kACIGreen));

                        OdDbBlockTableRecord model = (OdDbBlockTableRecord)TDDatabase.getModelSpaceId().safeOpenObject(OpenMode.kForWrite);

                        endOdDbObjectId = model.appendOdDbEntity(newEndPolyLine);

                    }

                }

                mDevice.invalidate();

                mDevice.update(new OdGsDCRect(0, (int)NewSize.Width, (int)NewSize.Height, 0));//mDevice.update();

                UpdateDirtyRect();

                Unlock();

            }

        }

        public void DeleteContext()

        {

            if (mDevice != null || mHelper != null)

            {

                mDevice.Dispose();

                mHelper.Dispose();                

                mDevice = null;

                mHelper = null;

                //TDDatabase = null;

                //loadFile = null;

                if(odRxObjectSurface != null)

                {

                    odRxObjectSurface.Dispose();

                    odRxObjectSurface = null;

                }

                if(TDDatabase != null)

                {

                    TDDatabase = null;

                }

                if(loadFile != null)

                {

                    loadFile = null;

                }

                //surfaceVariantValue = null;

    }

        }

        String toString(OdDbObjectId val)

        {

            if (val.isNull())

            {

                return "Null";

            }

            if (val.isErased())

            {

                return "Erased";

            }

            /**********************************************************************/

            /* Open the object                                                    */

            /**********************************************************************/

            OdDbObject pObject = val.safeOpenObject();

            /**********************************************************************/

            /* Return the name of an OdDbSymbolTableRecord                        */

            /**********************************************************************/

            if (pObject is OdDbSymbolTableRecord)

            {

                OdDbSymbolTableRecord pSTR = (OdDbSymbolTableRecord)pObject;

                return pSTR.getName();

            }

            /**********************************************************************/

            /* Return the name of an OdDbMlineStyle                               */

            /**********************************************************************/

            if (pObject is OdDbMlineStyle)

            {

                OdDbMlineStyle pStyle = (OdDbMlineStyle)pObject;

                return pStyle.name();

            }

            /**********************************************************************/

            /* Return the name of a PlotStyle                                      */

            /**********************************************************************/

            if (pObject is OdDbPlaceHolder)

            {

                OdDbDictionary pDictionary = (OdDbDictionary)val.database().getPlotStyleNameDictionaryId().safeOpenObject();

                String plotStyleName = pDictionary.nameAt(val);

                return plotStyleName;

            }

            /**********************************************************************/

            /* Return the name of an OdDbMaterial                                 */

            /**********************************************************************/

            if (pObject is OdDbMaterial)

            {

                OdDbMaterial pMaterial = (OdDbMaterial)pObject;

                return pMaterial.name();

            }

            /**********************************************************************/

            /* We don't know what it is, so return the description of the object  */

            /* object specified by the ObjectId                                   */

            /**********************************************************************/

            return pObject.isA().name();

        }

        public void DrawLine()

        {

            if (pView != null)

            {

                Lock();

                using (OdDbLine l = OdDbLine.createObject())

                {

                    l.setStartPoint(new OdGePoint3d(0, 0, 0));

                    l.setEndPoint(new OdGePoint3d(1000, 1000, 0));

                    l.setLineWeight(LineWeight.kLnWt200);

                    OdDbBlockTableRecord model = (OdDbBlockTableRecord)TDDatabase.getModelSpaceId().safeOpenObject(OpenMode.kForWrite);

                    model.appendOdDbEntity(l);

                }

                mDevice.invalidate();

                mDevice.update(new OdGsDCRect(0, (int)NewSize.Width, (int)NewSize.Height, 0));//mDevice.update();

                UpdateDirtyRect();

                Unlock();

            }

        }

        static OdDbPolygonMesh_Dumper m_polygonMesh = new OdDbPolygonMesh_Dumper();

        class OdDbPolygonMesh_Dumper : OdDbPropertiesOverrule

        {

            public override bool isApplicable(OdRxObject pOverruledSubject)

            {

                return true;

            }

            public override void list(OdDbEntity pEnt)

            {

                OdDbPolygonMesh pPoly = (OdDbPolygonMesh)pEnt;

                Console.WriteLine("<{0}> {1}", pPoly.isA().name(), pPoly.getDbHandle().ToString());

                Console.WriteLine("m Size = {0}", pPoly.mSize().ToString());

                Console.WriteLine("m-Closed = {0}", pPoly.isMClosed().ToString());

                Console.WriteLine("m Surface Density = {0}", pPoly.mSurfaceDensity().ToString());

                Console.WriteLine("n Size = {0}", pPoly.nSize().ToString());

                Console.WriteLine("n-Closed = {0}", pPoly.isNClosed().ToString());

                Console.WriteLine("n Surface Density = {0}", pPoly.nSurfaceDensity().ToString());

                /********************************************************************/

                /* dump vertices                                                    */

                /********************************************************************/

                OdDbObjectIterator pIter = pPoly.vertexIterator();

                int vertexCount = 0;

                for (; !pIter.done(); pIter.step())

                {

                    OdDbPolygonMeshVertex pVertex = pIter.entity() as OdDbPolygonMeshVertex;

                    if (pVertex != null)

                    {

                        Console.WriteLine("<{0}> {1}", pVertex.isA().name(), vertexCount++);

                        Console.WriteLine("Handle = {0}", pVertex.getDbHandle().ToString());

                        Console.WriteLine("Position = {0}", pVertex.position().ToString());

                        Console.WriteLine("Type = {0}", pVertex.vertexType().ToString());

                    }

                }

                dumpEntityData(pPoly);

            }

        };

        static void dumpEntityData(OdDbEntity pEnt)

        {

            OdGeExtents3d extents = new OdGeExtents3d();

            if (OdResult.eOk == pEnt.getGeomExtents(extents))

            {

                Console.WriteLine("Min Extents = {0}", extents.minPoint().ToString());

                Console.WriteLine("Max Extents = {0}", extents.maxPoint().ToString());

            }

            Console.WriteLine("Layer = {0}", pEnt.layer());

            Console.WriteLine("Color Index = {0}", pEnt.colorIndex());

            Console.WriteLine("Color = {0}", pEnt.color().ToString());

            Console.WriteLine("Linetype = {0}", pEnt.linetype());

            Console.WriteLine("LTscale = {0}", pEnt.linetypeScale());

            Console.WriteLine("Lineweight = {0}", pEnt.lineWeight());

            Console.WriteLine("Plot Style = {0}", pEnt.plotStyleName());

            Console.WriteLine("Transparency Method = {0}", pEnt.transparency().method().ToString());

            Console.WriteLine("Visibility = {0}", pEnt.visibility().ToString());

            Console.WriteLine("Planar = {0}", pEnt.isPlanar());

            OdGePlane plane = new OdGePlane();

            Planarity planarity = Planarity.kNonPlanar;

            pEnt.getPlane(plane, out planarity);

            Console.WriteLine("Planarity = {0}", planarity);

            if (pEnt.isPlanar())

            {

                OdGePoint3d origin = new OdGePoint3d();

                OdGeVector3d uAxis = new OdGeVector3d();

                OdGeVector3d vAxis = new OdGeVector3d();

                plane.get(origin, uAxis, vAxis);

                Console.WriteLine("Origin = {0}", origin.ToString());

                Console.WriteLine("u-Axis = {0}", uAxis.ToString());

                Console.WriteLine("v-Axis = {0}", vAxis.ToString());

            }

        }

        public static double OdaToRadian(double deg) { return (deg) * Math.PI / 180.0; }

        void dumpAbstractViewTableRecord(OdDbAbstractViewTableRecord pView)

        {

            MemoryTransaction mTr = MemoryManager.GetMemoryManager().StartTransaction();

            /*********************************************************************/

            /* Dump the AbstractViewTableRecord                                  */

            /*********************************************************************/

            Console.WriteLine("Back Clip Dist = {0}", (pView.backClipDistance()));

            Console.WriteLine("Back Clip Enabled = {0}", (pView.backClipEnabled()));

            Console.WriteLine("Front Clip Dist = {0}", (pView.frontClipDistance()));

            Console.WriteLine("Front Clip Enabled = {0}", (pView.frontClipEnabled()));

            Console.WriteLine("Front Clip at Eye = {0}", (pView.frontClipAtEye()));

            Console.WriteLine("Elevation = {0}", (pView.elevation()));

            Console.WriteLine("Height = {0}", (pView.height()));

            Console.WriteLine("Width = {0}", (pView.width()));

            Console.WriteLine("Lens Length = {0}", (pView.lensLength()));

            Console.WriteLine("Render Mode = {0}", (pView.renderMode()));

            Console.WriteLine("Perspective = {0}", (pView.perspectiveEnabled()));

            OrthographicView orthoUCS;

            Console.WriteLine("UCS Orthographic = {0}", (pView.isUcsOrthographic(out orthoUCS)));

            Console.WriteLine("Orthographic UCS = {0}", (orthoUCS));

            if (pView.isUcsOrthographic(out orthoUCS))

            {

                OdGePoint3d origin = new OdGePoint3d();

                OdGeVector3d xAxis = new OdGeVector3d();

                OdGeVector3d yAxis = new OdGeVector3d();

                pView.getUcs(origin, xAxis, yAxis);

                Console.WriteLine("UCS Origin = {0}", (origin));

                Console.WriteLine("UCS x-Axis = {0}", (xAxis));

                Console.WriteLine("UCS y-Axis = {0}", (yAxis));

            }

            Console.WriteLine("Target = {0}", (pView.target()));

            Console.WriteLine("View Direction = {0}", (pView.viewDirection()));

            MemoryManager.GetMemoryManager().StopTransaction(mTr);

        }

        public OdGePoint3d ScreenPointToWorld(Point point)

        {

            OdGePoint3d odaPoint = ScreenPointToWorld(mHelper, point.X, point.Y);

            return odaPoint;

        }

        public OdGePoint3d ScreenPointToWorldTest(Point point)

        {

            OdGePoint3d pt = ScreenPointToWorld(mHelper, point.X, point.Y);

            pt = pt.transformBy(mHelper.activeView().worldToDeviceMatrix());

            return pt;

        }

        public OdGePoint3d SelectionPointsByPointOnScreen(double x, double y)

        {

            OdGePoint3d pt = ScreenPointToWorld(mHelper, x, y);

            pt = pt.transformBy(mHelper.activeView().worldToDeviceMatrix());

            return pt;

        }

        public void DrawAreaTest(Image bb, Point startPoint, Point endPoint)

        {

            if (pView != null)

            {

                Lock();

                using (OdDbTrace l = OdDbTrace.createObject())

                {

                    /*

                    MemoryTransaction mTr = MemoryManager.GetMemoryManager().StartTransaction(Thread.CurrentThread.ManagedThreadId);

                    OdDbViewportTable pTable = (OdDbViewportTable)TDDatabase.getViewportTableId().safeOpenObject();

                    OdDbSymbolTableIterator pIter = pTable.newIterator();

                    for (pIter.start(); !pIter.done(); pIter.step())

                    {

                        OdDbViewportTableRecord pRecord = (OdDbViewportTableRecord)pIter.getRecordId().safeOpenObject();

                        dumpAbstractViewTableRecord(pRecord); 

                    }

                    MemoryManager.GetMemoryManager().StopTransaction(mTr);

                    */

                    OdGePoint3d ptS = ScreenPointToWorld(mHelper, startPoint.X, startPoint.Y);

                    OdGePoint3d ptS1 = ScreenPointToWorld(mHelper, startPoint.X, endPoint.Y);

                    OdGePoint3d ptE = ScreenPointToWorld(mHelper, endPoint.X, endPoint.Y);

                    OdGePoint3d ptE1 = ScreenPointToWorld(mHelper, endPoint.X, startPoint.Y);

                    l.setPointAt(0, ptS1);

                    l.setPointAt(1, ptS);

                    l.setPointAt(2, ptE);

                    l.setPointAt(3, ptE1);

                    OdDbBlockTableRecord model = (OdDbBlockTableRecord)TDDatabase.getModelSpaceId().safeOpenObject(OpenMode.kForWrite);

                    model.appendOdDbEntity(l);

                }

                mDevice.invalidate();

                mDevice.update(new OdGsDCRect(0, (int)NewSize.Width, (int)NewSize.Height, 0));//mDevice.update();

                UpdateDirtyRect();

                Unlock();

            }

        }

        private void Update1() // export to pdf

        {

            OdRxModule mod = Globals.odrxDynamicLinker().loadApp("TD_PdfExport");

            if (null == mod)

            {

                MessageBox.Show("Failed to load PDF export module", "Error");

            }

            Microsoft.Win32.SaveFileDialog dlgPdf = new Microsoft.Win32.SaveFileDialog();

            dlgPdf.DefaultExt = ".pdf";

            dlgPdf.Title = "PDF Export default";

            dlgPdf.Filter = "PDF files|*.pdf";

            // Display SaveFileDialog by calling ShowDialog method 

            if (dlgPdf.ShowDialog() != true)

            {

                return;

            }

            using (PDFExportParams Params = new PDFExportParams())

            {

                OdGsPageParams pParams = new OdGsPageParams();

                Params.setDatabase(TDDatabase);

                Params.setVersion(PDFExportParams.PDFExportVersions.kPDFv1_5);

                using (OdStreamBuf file = Globals.odrxSystemServices().createFile(dlgPdf.FileName, FileAccessMode.kFileWrite, FileShareMode.kShareDenyNo, FileCreationDisposition.kCreateAlways))

                {

                    Params.setOutput(file);

                    Params.setExportFlags(

                                 (PDFExportParams.PDFExportFlags.kEmbededTTF) |

                                 (PDFExportParams.PDFExportFlags.kSHXTextAsGeometry) | // no in sample

                                                                                       //(PDFExportParams.PDFExportFlags.kTTFTextAsGeometry) | // no in sample

                                 (PDFExportParams.PDFExportFlags.kSimpleGeomOptimization) |

                                 (PDFExportParams.PDFExportFlags.kZoomToExtentsMode) |

                                 (PDFExportParams.PDFExportFlags.kEnableLayers) | // under condition

                                 (PDFExportParams.PDFExportFlags.kIncludeOffLayers) | // under condition

                                    (PDFExportParams.PDFExportFlags.kUseHLR) |

                                    (PDFExportParams.PDFExportFlags.kFlateCompression) |

                                    (PDFExportParams.PDFExportFlags.kASCIIHexEncoding) |

                                    (PDFExportParams.PDFExportFlags.kExportHyperlinks));

                    Params.setTitle(dlgPdf.Title);

                    Params.setAuthor("WpfSample2");

                    Params.setSubject("WpfSample2");

                    Params.setKeywords("WpfSample2");

                    Params.setCreator("WpfSample2");

                    Params.setProducer("WpfSample2");

                    UInt32[] CurPalette = AllPalettes.getLightPalette();// OdDgColorTable.currentPalette(CurDb);

                    CurPalette[255] = 0x00ffffff; // the same as ODRGB(255, 255, 255); in the similar C++ code extract

                                                  //OdDbColorTable.correctPaletteForWhiteBackground(CurPalette);

                    Params.Palette = CurPalette;

                    Params.setBackground(CurPalette[0]);

                    /*if (dlgPdf.m_Layouts == 1) // all

                    {

                      OdDbModelTable pModelTable = TDDatabase.getModelTable();

                      if (null != pModelTable)

                      {

                        OdDgElementIterator pIter = pModelTable.createIterator();

                        for (; !pIter.done(); pIter.step())

                        {

                          OdDgModel pModel = OdDgModel.cast(pIter.item().openObject());

                          if (null != pModel)

                          {

                            Params.layouts.Add(pModel.getName());

                          }

                        }

                      }

                    }*/

                    /*Params.layouts.Add(TDDatabase.findActiveLayout(true));

                    UInt32 nPages = (UInt32)(1 > Params.layouts.Count ? 1 : Params.layouts.Count);

                    OdGsPageParams pageParams = new OdGsPageParams();

                    pageParams.set(210, 295);

                    Params.pageParams.resize(nPages);*/

                    PdfExportModule module = new PdfExportModule(OdRxModule.getCPtr(mod).Handle, false); //= PdfExportModule.cast();

                    OdPdfExport exporter = module.create();

                    UInt32 errCode = exporter.exportPdf(Params);

                    if (errCode != 0)

                    {

                        String errMes = exporter.exportPdfErrorCode(errCode);

                        String str;

                        str = string.Format("Error number : {0}. \n {1}", errCode, errMes);

                        if (errCode == 0x10008)

                        {

                            str += "\nPlease enable Zoom to extents check box or\ndefine page parameters for layout in page setup dialog.";

                        }

                        MessageBox.Show("PDF error", str);

                    }

                }

            }

        }

        private void Update2()

        {

            Lock();

            mDevice.update(new OdGsDCRect(0, (int)NewSize.Width, (int)NewSize.Height, 0));//mDevice.update();

            UpdateDirtyRect();

            Unlock();

        }

        private void Update3()

        {

            Lock();

            mDevice.invalidate();

            UpdateDirtyRect();

            Unlock();

        }

        public void ClearPoint()

        {

            if (pView != null)

            {

                Lock();

                if (startOdDbObjectId != null)

                {

                    OdDbObject obj = startOdDbObjectId.safeOpenObject(OpenMode.kForWrite);

                    obj.erase();

                    startOdDbObjectId = null;

                }

                if (endOdDbObjectId != null)

                {

                    OdDbObject obj = endOdDbObjectId.safeOpenObject(OpenMode.kForWrite);

                    obj.erase();

                    endOdDbObjectId = null;

                }

                //OdDbBlockTableRecord btr = (OdDbBlockTableRecord)TDDatabase.getModelSpaceId().safeOpenObject(OpenMode.kForWrite);

                //OdDbObjectIterator itr = btr.newIterator();

                //for (; !itr.done(); itr.step())

                //{

                //    OdDbEntity ent = (OdDbEntity)itr.objectId().openObject(OpenMode.kForWrite);

                //    if (ent.Equals(startPolyLine.objectId()))

                //    {

                //        ent.erase();

                //    }

                //    //if (itr.objectId().objectClass() is typeof(OdRxClass.SwigDelegateOdRxClass_1()))

                //    //if(itr.objectId().objectClass() is OdRxClass.(typeof(Circle))

                //    //if 라인

                //    //OdDbEntity ent = (OdDbEntity)itr.objectId().safeOpenObject();

                //    //itr.entity(OpenMode.kForWrite, true);

                //    //ent.erase();

                //}

            }

            mDevice.invalidate();

            mDevice.update(new OdGsDCRect(0, (int)NewSize.Width, (int)NewSize.Height, 0));//mDevice.update();

            //UpdateDirtyRect();

            Unlock();

        }

    }

}