Eyeshot/conversion/MainForm.cs

Refer to the Eyeshot Conversion Example.

using System;
using System.Collections.Generic;
using System.Windows.Forms;
 
using cadex;
 
using devDept.Eyeshot;
using devDept.Eyeshot.Translators;
using devDept.Eyeshot.Entities;
using devDept.Geometry;
 
namespace conversion
{
    public partial class MainForm : Form
    {
        private IList<devDept.WorkUnit> workUnits;
 
        public MainForm()
        {
            workUnits = new List<devDept.WorkUnit>();
 
            InitializeComponent();
 
            design1.ProgressChanged += design1_ProgressChanged;
            design1.WorkCancelled += design1_WorkCancelled;
            design1.WorkCompleted += design1_WorkCompleted;
        }
 
        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);
 
            // Hides the Eyeshot progressBar because in this sample the progess is shown with a WinForms ProgressBar
            design1.ProgressBar.Visible = false;
        }
 
        private bool startWork()
        {
            bool aHasWorks = workUnits.Count > 0;
            if (aHasWorks)
            {
                design1.StartWork(workUnits[0]);
            }
            return aHasWorks;
        }
 
        private bool startWork(devDept.WorkUnit theWorker)
        {
            bool aHasWorks = workUnits.Count > 0;
            workUnits.Add(theWorker);
            if (!aHasWorks)
                startWork();
            return true;
        }
 
        void design1_ProgressChanged(object theSender, devDept.WorkUnit.ProgressChangedEventArgs theEventArgs)
        {
            labelProgressBar.Text = design1.ProgressBar.Text;
            progressBar1.Value = theEventArgs.Progress;
        }
 
        private void design1_WorkCancelled(object theSender, EventArgs theEventArgs)
        {
            Text = TitleName(Text);
            labelProgressBar.Text = "Canceled";
            progressBar1.Value = 0;
        }
 
        void design1_WorkCompleted(object theSender, devDept.WorkCompletedEventArgs theEventArgs)
        {
            workUnits.Remove(theEventArgs.WorkUnit);
 
            if (!startWork())
            {
                ReadFileAsync aReadAsync = theEventArgs.WorkUnit as ReadFileAsync;
                if (aReadAsync != null)
                {
                    aReadAsync.AddTo(design1);
                    foreach (Material aMaterial in design1.Materials)
                    {
                        aMaterial.LoadTexture(design1.RenderContext);
                    }
                }
                design1.ZoomFit();
 
                if (design1.Entities.Count > 0)
                {
                    labelProgressBar.Text = "Completed";
                    labelProgressBar.ForeColor = System.Drawing.Color.Black;
                }
                else // Error: nothing imported
                {
                    Text = TitleName(Text);
                    labelProgressBar.Text = "Failed";
                    labelProgressBar.ForeColor = System.Drawing.Color.Red;
                }
            }
        }
 
        private void buttonCancel_Click(object theSender, EventArgs theEventArgs)
        {
            design1.CancelWork();
        }
 
        private void buttonBRep_Click(object theSender, EventArgs theEventArgs)
        {
            Import(ModelData_RepresentationMask.ModelData_RM_BRep);
        }
 
        private void buttonPoly_Click(object theSender, EventArgs theEventArgs)
        {
            Import(ModelData_RepresentationMask.ModelData_RM_CoarseLOD);
        }
 
        private void Import(ModelData_RepresentationMask theMask)
        {
            OpenFileDialog aDialog = new OpenFileDialog();
            aDialog.CheckFileExists = true;
            aDialog.Multiselect = false;
            aDialog.Filter = ImportFilter();
 
            if (aDialog.ShowDialog() != DialogResult.OK)
            {
                return;
            }
 
            string aFilePath = aDialog.FileName;
 
            design1.Clear();
            startWork(new ReadFileCadEx(aFilePath, theMask));
 
            Text = TitleName(Text) + " - " + aFilePath;
        }
 
        private string TitleName(string theFormTitle)
        {
            return theFormTitle.Split('-')[0].Trim(' ');
        }
 
        private string ImportFilter()
        {
            return "All files (*.*)|*.*";
        }
 
        public class ReadFileCadEx : ReadFileAsync
        {
            private Eyeshot_EntityFactory myFactory = null;
            private ModelData_RepresentationMask myMask = ModelData_RepresentationMask.ModelData_RM_Any;
 
            public ReadFileCadEx(string fileName, ModelData_RepresentationMask theMask)
                : base(fileName)
            {
                myMask = theMask;
            }
 
            public override supportedLinearUnitsType SupportedLinearUnitsType
            {
                get
                {
                    return supportedLinearUnitsType.Millimeters;
                }
            }
 
            public override void DoWork(System.ComponentModel.BackgroundWorker theWorker, System.ComponentModel.DoWorkEventArgs theDoWorkEventArgs)
            {
                string aFileName = FileName;
 
                BlockReference aRoot = Process(aFileName, myMask);
                if (aRoot != null)
                {
                    Entities = new Entity[] { aRoot };
                }
 
                UpdateProgress(1, 1, "Convert the model", theWorker);
            }
 
            public override void AddTo(DesignDocument theDoc, RegenOptions theRegenOptions = null)
            {
                if (myFactory != null && theDoc != null && Entities.Length > 0)
                {
                    myFactory.AddTo(theDoc);
                    theDoc.Entities.AddRange(Entities);
                }
            }
 
            private BlockReference Process(string theFileName,
                                           ModelData_RepresentationMask theMask,
                                           Eyeshot_EntityMapping theMap = null)
            {
                Base_Settings.Default().SetValue(Base_Settings.Id.SubprocessMode, false);
 
                ModelData_Model aModel = new ModelData_Model();
 
                ModelData_ModelReader aReader = new ModelData_ModelReader();
                if (!aReader.Read(new Base_UTF16String(theFileName), aModel))
                {
                    Console.WriteLine("Failed to open and convert the file");
                    return null;
                }
 
                myFactory = new Eyeshot_EntityFactory();
                myFactory.Parameters().SetRepSelector(theMask);
 
                return myFactory.Create(aModel, theMap);
            }
        }
    }
}