public static void ExportDesign(FMSolids solids, List <SetupInfo> all_setups,
                                        string output_dirpath)
        {
            string        err_str = "";
            FMSolid       solid;
            List <string> exported_parts = new List <string>();

            try
            {
                /* Each setup has its own parts. So we save them per setup. */
                for (int si = 0; si < all_setups.Count; si++)
                {
                    if (all_setups[si].part != null)
                    {
                        for (int pi = 0; pi < all_setups[si].part.Count; pi++)
                        {
                            if (all_setups[si].part[pi] != null)
                            {
                                solid = (FMSolid)solids.Item(all_setups[si].part[pi].name);
                                if (solid != null)
                                {
                                    LogFile.Write(String.Format("Export design {0} for setup {1}", all_setups[si].part[pi].name, all_setups[si].name));
                                    all_setups[si].part[pi].fpath = Path.Combine(output_dirpath, "part_" + solid.Name + ".stl");
                                    if (!exported_parts.Contains(solid.Name)) //There is no need to reexport solid if we already exported it
                                    {
                                        solid.ExportToSTL(all_setups[si].part[pi].fpath, out err_str);
                                        if ((err_str == "" || err_str == null) && File.Exists(all_setups[si].part[pi].fpath))
                                        {
                                            LogFile.Write(String.Format("Created file {0}", all_setups[si].part[pi].fpath));
                                        }
                                        else
                                        {
                                            LogFile.Write(String.Format("Error occured while exporting solid to .stl file. {0}\n", err_str));
                                        }
                                        exported_parts.Add(solid.Name);
                                    }
                                    LogFile.Write("Design exported");
                                }
                            }
                        }
                    }
                    else
                    {
                        LogFile.Write(String.Format("Setup {0} doesn't have any design solids", all_setups[si].name));
                    }
                }
            }
            catch (Exception Ex)
            {
                LogFile.WriteException(Ex, "ExportDesign");
            }
            finally
            {
                solids = null;
                solid  = null;
                exported_parts.Clear();
                exported_parts = null;
            }
        }
        public static List <SolidInfo> InitializeAllSolids(FMSolids fm_solids)
        {
            List <SolidInfo> solids;
            List <string>    solid_names;

            try
            {
                LogFile.Write("Initialize part solids");

                if (fm_solids == null)
                {
                    return(null);
                }
                if (fm_solids.Count == 0)
                {
                    return(null);
                }
                solid_names = new List <string>();
                foreach (FeatureCAM.FMSolid solid in fm_solids)
                {
                    solid_names.Add(solid.Name);
                }
                solid_names.Sort();
                solids = new List <SolidInfo>();
                foreach (string solid_name in solid_names)
                {
                    solids.Add(new SolidInfo(solid_name));
                }
                return(solids);
            }
            catch
            {
                return(null);
            }
            finally
            {
                fm_solids = null;
            }
        }
        public static void ExportClamps(FMSolids solids, List <SetupInfo> all_setups,
                                        string output_dirpath)
        {
            string        err_str = "";
            FMSolid       clamp;
            List <string> exported_clamps = new List <string>();

            try
            {
                /* Each setup has its own clamps. So we save them per setup. */
                for (int si = 0; si < all_setups.Count; si++)
                {
                    if (all_setups[si].clamps != null)
                    {
                        if (!Directory.Exists(Path.Combine(output_dirpath, "Clamps")))
                        {
                            Directory.CreateDirectory(Path.Combine(output_dirpath, "Clamps"));
                        }
                        for (int ci = 0; ci < all_setups[si].clamps.Count; ci++)
                        {
                            LogFile.Write(String.Format("Export clamp {0} for setup {1}", all_setups[si].clamps[ci].name, all_setups[si].name));
                            all_setups[si].clamps[ci].fpath = Path.Combine(output_dirpath, "Clamps\\" + all_setups[si].clamps[ci].name + ".stl");

                            if (!exported_clamps.Contains(all_setups[si].clamps[ci].name)) //There is no need to reexport solid if we already exported it
                            {
                                clamp = (FMSolid)solids.Item(all_setups[si].clamps[ci].name);
                                if (clamp != null)
                                {
                                    clamp.ExportToSTL(all_setups[si].clamps[ci].fpath, out err_str);
                                    if ((err_str == "" || err_str == null) && File.Exists(all_setups[si].clamps[ci].fpath))
                                    {
                                        LogFile.Write(String.Format("Created file {0}", all_setups[si].clamps[ci].fpath));
                                    }
                                    else
                                    {
                                        LogFile.Write(String.Format("Error occured while exporting clamp solid to .stl file. {0}\n", err_str));
                                    }
                                    exported_clamps.Add(clamp.Name);
                                }
                            }
                            LogFile.Write("Clamp exported");
                        }
                    }
                    else
                    {
                        LogFile.Write(String.Format("Setup {0} doesn't have any clamps", all_setups[si].name));
                    }
                }
            }
            catch (Exception Ex)
            {
                LogFile.WriteException(Ex, "ExportClamps");
            }
            finally
            {
                solids = null;
                clamp  = null;
                exported_clamps.Clear();
                exported_clamps = null;
            }
        }
        public static List <SetupInfo> InitializeAllSetups(FMSetups fm_setups, FMSolids fm_solids, FMUcss fm_ucss,
                                                           List <UCS> doc_ucss, List <SetupOptions> all_options,
                                                           int combine_setups,
                                                           ref bool are_all_setups_milling)
        {
            List <SetupInfo> setups;
            SetupOptions     options;

            try
            {
                if (fm_setups == null)
                {
                    return(null);
                }
                if (fm_setups.Count == 0)
                {
                    return(null);
                }

                are_all_setups_milling = true;

                foreach (FMSetup setup in fm_setups)
                {
                    if (setup.Type != FeatureCAM.tagFMSetupType.eST_Milling)
                    {
                        are_all_setups_milling = false;
                    }
                }

                setups = new List <SetupInfo>();
                if (combine_setups == 1 && all_options != null)
                {
                    SetupInfo setup = new SetupInfo();
                    setup.name         = "Combined";
                    setup.options      = all_options[0];
                    setup.work_offsets = setup.options.offsets;
                    setup.part         = setup.options.parts;
                    if (setup.options.clamps != null)
                    {
                        foreach (SolidInfo clamp in setup.options.clamps)
                        {
                            if (fm_solids.Item(clamp.name) != null)
                            {
                                if (setup.clamps == null)
                                {
                                    setup.clamps = new List <SolidInfo>();
                                }
                                setup.clamps.Add(clamp);
                            }
                        }
                    }
                    //setup.clamps = setup.options.clamps;
                    setup.stock                      = new SolidInfo("", setup.options.attach_stock_to);
                    setup.sub_spindle                = setup.options.is_subspindle;
                    setup.attach_stock_to            = setup.options.attach_stock_to;
                    setup.attach_stock_to_subspindle = setup.options.attach_stock_to_subspindle;
                    if (setup.options.ucs_attach != "" && fm_ucss.Item(setup.options.ucs_attach) != null)
                    {
                        setup.attach_ucs = setup.options.ucs_attach;
                    }
                    if (setup.options.ucs_attach_subspindle != "" && fm_ucss.Item(setup.options.ucs_attach_subspindle) != null)
                    {
                        setup.attach_ucs_subspindle = setup.options.ucs_attach_subspindle;
                    }
                    setup.attach_ucss_to            = setup.options.attach_ucss_to;
                    setup.attach_ucss_to_subspindle = setup.options.attach_ucss_to_subspindle;
                    setup.enabled = true;
                    setup.ucss    = new List <UCS>();
                    foreach (FMUcs fm_ucs in fm_ucss)
                    {
                        setup.ucss.Add(new UCS(fm_ucs));
                    }

                    setups.Add(setup);
                }
                else
                {
                    foreach (FeatureCAM.FMSetup setup in fm_setups)
                    {
                        if (setup.Enabled)
                        {
                            LogFile.Write(String.Format("Initialize setup {0}", setup.Name));

                            options = FindSetupOptions(all_options, setup.Name);
                            setups.Add(new SetupInfo(options, setup, fm_solids, doc_ucss));
                        }
                        else
                        {
                            LogFile.Write(String.Format("Skip disabled setup {0}", setup.Name));
                        }
                    }
                    if (combine_setups == 1)
                    {
                        return(InitalizeCombinedSetup(setups));
                    }
                }
                return(setups);
            }
            catch
            {
                return(null);
            }
            finally
            {
                fm_setups   = null;
                fm_solids   = null;
                all_options = null;
            }
        }