private void btn_OK_Click(object sender, EventArgs e)
        {
            if (cb_solids.CheckedItems.Count == 0)
            {
                return;
            }

            if (cb_export_as.SelectedItem == null)
            {
                MessageDisplay.ShowError(
                    LanguageSupport.Translate("You have to select whether to export selected solids as clamps or design."));
                return;
            }
            if (cb_attach_to.SelectedItem == null)
            {
                MessageDisplay.ShowError(
                    LanguageSupport.Translate("You have to select attach component."));
                return;
            }

            selected_solids = new List <string>();
            for (int i = 0; i < cb_solids.CheckedItems.Count; i++)
            {
                selected_solids.Add(cb_solids.CheckedItems[i].ToString());
            }
            attach_to       = cb_attach_to.SelectedItem.ToString();
            export_as_clamp = (cb_export_as.SelectedIndex == 0);

            fm_doc = null;
            this.Close();
        }
Example #2
0
        private void StartVericut()
        {
            try
            {
                if (!File.Exists(Variables.vericut_fpath))
                {
                    MessageDisplay.ShowError(
                        LanguageSupport.Translate("Vericut path {0} is invalid. The file doesn't exist."), Variables.vericut_fpath);
                    return;
                }
                if (!File.Exists(Variables.vcproj_fpath))
                {
                    MessageDisplay.ShowError(
                        LanguageSupport.Translate("Vericut project {0} doesn't exist. Can't open it in VERICUT."), Variables.vcproj_fpath);
                    return;
                }

                using (Process proc = new Process())
                {
                    proc.StartInfo.FileName    = Variables.vericut_fpath;
                    proc.StartInfo.Arguments   = String.Format("\"{0}\"", Variables.vcproj_fpath);
                    proc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
                    proc.Start();
                    proc.WaitForExit(0);
                    if (proc != null)
                    {
                        proc.Dispose();
                    }
                }
            }
            catch (Exception Ex)
            {
                LogFile.WriteException(Ex, "StartVericut");
            }
        }
Example #3
0
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        static public void FeatureCAMToVericut()
        {
            LanguageSupport.InitializeTranslation(fc.CurrentLanguage, @"Localization");
            CheckTLBCompatibility();
            if (!IsLicensedProperly())
            {
                return;
            }

            Variables.doc = (FeatureCAM.FMDocument)fc.ActiveDocument;
            if (Variables.doc == null)
            {
                MessageDisplay.ShowError(
                    LanguageSupport.Translate("No files are open"));
                return;
            }

            if (File.Exists(@"C:\ProgramData\FeatureCAM\vericut_addin.ini"))
            {
                Variables.vericut_fpath = File.ReadAllText(@"C:\ProgramData\FeatureCAM\vericut_addin.ini").Replace("VERICUT_PATH=", "").Trim();
            }

            if (Variables.doc.path != "")
            {
                Variables.doc_ini_fpath = Variables.doc.FullName + ".fcvini";
                LogFile.SetLogFilePath(Variables.doc.FullName + ".log");
                if (File.Exists(Variables.doc_ini_fpath))
                {
                    Variables.doc_options = GetSavedOptions("", Variables.doc_ini_fpath);
                    Variables.doc_options.read_from_file = true;
                }
            }

            Init.InitializeVariables();

            // helper function to force a single instance of plugin form
            if (main_form != null)
            {
                main_form.BringToFront();
            }
            else
            {
                LogFile.Write("Initialize form");
                main_form = new MainForm();
                LogFile.Write("Display form");
                main_form.Show();
                main_form.TopLevel = true;
                main_form.TopMost  = true;
                System.Windows.Forms.Application.Run(main_form);
            }
        }
        public static void Export()
        {
            try
            {
                if (!Directory.Exists(Variables.doc_options.output_dirpath))
                {
                    Directory.CreateDirectory(Variables.doc_options.output_dirpath);
                }

                if (!FCExporter.SaveNCCode(FCToVericut.Application, Variables.doc,
                                           Variables.fname_no_ext, ".mcd", Variables.doc_options.output_dirpath,
                                           Variables.setups_info, Variables.GetSaveNCForAllSetups(),
                                           Variables.is_single_program, Variables.doc_options.combine_setups))
                {
                    LogFile.Write("Failed to save nc code");
                    MessageDisplay.ShowError(
                        LanguageSupport.Translate("Abort export: Failed to save NC code. Check for errors in the Op List."));
                    return;
                }

                Variables.doc.InvalidateToolpaths();
                ExportTools(FCToVericut.Application, Variables.doc);

                FCExporter.ExportStock((FMStock)Variables.doc.Stock, Variables.setups_info,
                                       Variables.doc_options.output_dirpath);

                /* Each setup has it's own clamps and possibly part solid. So we save them per setup. */
                FCExporter.ExportClamps((FMSolids)Variables.doc.Solids, Variables.setups_info,
                                        Variables.doc_options.output_dirpath);

                FCExporter.ExportDesign((FMSolids)Variables.doc.Solids, Variables.setups_info,
                                        Variables.doc_options.output_dirpath);

                /* If we need to update projects file, do it now */
                if (Variables.doc_options.is_export_project)
                {
                    VcProject_Manager.ConstructNewVCProjectFile(
                        Variables.setups_info.Count);
                }
                MessageDisplay.ShowMessage(LanguageSupport.Translate("Export completed."));
            }
            catch (Exception Ex)
            {
                LogFile.WriteException(Ex, "Export");
            }
            finally
            {
            }
        }
        public static void SaveOptions(ProjectOptions options, string addin_ini_fpath)
        {
            if (Variables.doc.path == "")
            {
                MessageDisplay.ShowError(
                    LanguageSupport.Translate("Cannot save selected options to the file. File needs to be saved first."));
                LogFile.Write("Cannot save selected options to the file. File needs to be saved first.");
                return;
            }

            File.WriteAllText(@"C:\ProgramData\FeatureCAM\vericut_addin.ini",
                              string.Format("VERICUT_PATH={0}", Variables.vericut_fpath));

            /* This function will save shared options to addin ini file
             * and
             * project specific options to doc ini file
             */
            if (options.all_setup_options == null)
            {
                options.all_setup_options = new List <FeatureCAMExporter.SetupOptions>();
            }
            else
            {
                options.all_setup_options.Clear();
            }
            for (int i = 0; i < Variables.setups_info.Count; i++)
            {
                Variables.setups_info[i].options.clamps        = Variables.setups_info[i].clamps;
                Variables.setups_info[i].options.parts         = Variables.setups_info[i].part;
                Variables.setups_info[i].options.fixture       = Variables.setups_info[i].fixture_id;
                Variables.setups_info[i].options.offsets       = Variables.setups_info[i].work_offsets;
                Variables.setups_info[i].options.is_subspindle = Variables.setups_info[i].sub_spindle;

                options.all_setup_options.Add(Variables.setups_info[i].options);
            }
            System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(options.GetType());
            System.Xml.XmlWriterSettings           settings   = new System.Xml.XmlWriterSettings();
            settings.NewLineChars        = Environment.NewLine;
            settings.NewLineOnAttributes = true;
            settings.Indent             = true;
            settings.NewLineHandling    = System.Xml.NewLineHandling.Replace;
            settings.OmitXmlDeclaration = true;
            settings.CloseOutput        = true;
            System.Xml.XmlWriter writer = System.Xml.XmlWriter.Create(Variables.doc_ini_fpath, settings);
            serializer.Serialize(writer, options);
            writer.Close();
        }
Example #6
0
        public static List <string> GetMachineSubsystems(string template_proj_fpath)
        {
            List <string> subsystems  = new List <string>();
            String        machineFile = MR_extract_machine_file_name_CPP(template_proj_fpath);

            if (String.IsNullOrEmpty(machineFile))
            {
                MessageDisplay.ShowError(FeatureCAMExporter.LanguageSupport.Translate("Failed to read the Machine File from the Project file."));
                return(subsystems);
            }

            IntPtr unManagedSlist = IntPtr.Zero;
            int    scount         = MR_extract_subsystems_CPP(machineFile, out unManagedSlist);

            if (scount > 0)
            {
                // Convert unmanaged strings received from C++ side to C# format and release memory
                // allocated on C++ side.
                UnmananagedStrings2ManagedStringList(unManagedSlist, scount, out subsystems);
            }
            return(subsystems);
        }
Example #7
0
        private void b_select_part_solid_Click(object sender, EventArgs e)
        {
            FeatureCAM.FMSolid selected_solid = null;

            if (Variables.doc.Solids.Count > 0)
            {
                foreach (FeatureCAM.FMSolid solid in Variables.doc.Solids)
                {
                    if (solid.Selected)
                    {
                        if (selected_solid == null)
                        {
                            selected_solid = solid;
                        }
                        else
                        {
                            MessageDisplay.ShowError(
                                LanguageSupport.Translate("More than one solid is selected in the part. Please select only one solid and try again."));
                            return;
                        }
                    }
                }
            }
        }
Example #8
0
        private void GetDataFromFormAndExport()
        {
            Variables.doc_options.is_export_project = (tb_proj_template_fpath.Text != "");

            if (Variables.doc_options.output_dirpath == "")
            {
                MessageDisplay.ShowError(
                    LanguageSupport.Translate("Output directory path must be set. Please fix it and try again."));
                return;
            }
            else
            {
                Variables.doc_options.output_dirpath = tb_output_dir.Text;
            }
            if (Variables.fname_no_ext == "")
            {
                MessageDisplay.ShowError(
                    LanguageSupport.Translate("Output file name must be set. Please fix it and try again."));
                return;
            }
            if (Variables.doc_options.is_export_project && Variables.doc_options.vc_template_proj_fpath == "")
            {
                MessageDisplay.ShowError(
                    LanguageSupport.Translate("If exporting VERICUT project file, template file path must be set. Please fix it and try again."));
                return;
            }
            if (Variables.doc_options.is_export_project && !File.Exists(Variables.doc_options.vc_template_proj_fpath))
            {
                MessageDisplay.ShowError(
                    LanguageSupport.Translate("If exporting VERICUT project file, template file path must exist. File {0} doesn't exist. Please select existing file and try again."), Variables.doc_options.vc_template_proj_fpath);
                return;
            }

            FeatureCAM.FMSetup world = Variables.doc.Setups.Item("STOCK");
            if (Variables.setups_info[cb_setups.SelectedIndex].attach_ucs == null ||
                Variables.setups_info[cb_setups.SelectedIndex].attach_ucs == "")
            {
                MessageDisplay.ShowError(
                    LanguageSupport.Translate("If using UCS for specifying the location of the bottom most clamp, UCS has to be selected. Please select existing UCS and try again."));
                return;
            }
            for (int si = 0; si < Variables.setups_info.Count; si++)
            {
                if (!Variables.setups_info[si].enabled)
                {
                    continue;
                }
                /* Main spindle */
                FeatureCAM.FMUcs ucs = Variables.doc.UCSs.Item(Variables.setups_info[si].attach_ucs);
                Variables.setups_info[si].options.ucs_attach = ucs.Name;
                if (ucs != null)
                {
                    FeatureCAM.FMSetup temp_setup = Variables.doc.AddSetup(ucs.Name + "_temp_setup", FeatureCAM.tagFMSetupType.eST_Milling, null, ucs.Name, Type.Missing);
                    temp_setup.Enabled = false;
                    Variables.all_ucss[0].ComputeCoordinatesInRelationToSetup(temp_setup,
                                                                              out Variables.setups_info[si].setup_solid_x, out Variables.setups_info[si].setup_solid_y, out Variables.setups_info[si].setup_solid_z,
                                                                              out Variables.setups_info[si].setup_solid_i, out Variables.setups_info[si].setup_solid_j, out Variables.setups_info[si].setup_solid_k);
                    FeatureCAM.FMUcs temp_setup_ucs = temp_setup.ucs;
                    temp_setup.Delete();
                    temp_setup_ucs.Delete();
                }
                if (world != null && ucs != null)
                {
                    double ucs_x, ucs_y, ucs_z;
                    ucs.GetLocation(out ucs_x, out ucs_y, out ucs_z);
                    world.MapWorldToSetup(ref ucs_x, ref ucs_y, ref ucs_z);
                }
                /* Subspindle */
                if (!String.IsNullOrEmpty(Variables.setups_info[si].attach_ucs_subspindle))
                {
                    ucs = Variables.doc.UCSs.Item(Variables.setups_info[si].attach_ucs_subspindle);
                    Variables.setups_info[si].options.ucs_attach_subspindle = ucs.Name;
                    if (ucs != null)
                    {
                        FeatureCAM.FMSetup temp_setup = Variables.doc.AddSetup(ucs.Name + "_temp_setup_sub", FeatureCAM.tagFMSetupType.eST_Milling, null, ucs.Name, Type.Missing);
                        temp_setup.Enabled = false;
                        Variables.all_ucss[0].ComputeCoordinatesInRelationToSetup(temp_setup,
                                                                                  out Variables.setups_info[si].sub_setup_solid_x, out Variables.setups_info[si].sub_setup_solid_y, out Variables.setups_info[si].sub_setup_solid_z,
                                                                                  out Variables.setups_info[si].sub_setup_solid_i, out Variables.setups_info[si].sub_setup_solid_j, out Variables.setups_info[si].sub_setup_solid_k);
                        FeatureCAM.FMUcs temp_setup_ucs = temp_setup.ucs;
                        temp_setup.Delete();
                        temp_setup_ucs.Delete();
                    }
                }
            }
            Close();
            Exporter.Export();
        }
        private static void ExportTools(FeatureCAM.Application app, FMDocument doc)
        {
            StringBuilder tool_info    = new StringBuilder(),
                          tls_fcontent = new StringBuilder(),
                          tool_list    = new StringBuilder();
            int nc_prog          = 1,
                init_num         = 1;
            string crib_pos      = "",
                   nc_prog_fpath = "";

            try
            {
                /* At the moment we construct full tool list, which can be time consuming.
                 * So if we have a lot of setups that don't get exported, we do have a pointless delay
                 */
                FCExporter.ToolsToList(app, doc, Variables.setups_info, Variables.GetSaveToolsForAllSetups(),
                                       (Variables.doc_options.combine_setups == 1), Variables.doc_options.output_dirpath, Variables.doc.Metric);
                if (Variables.doc_options.combine_setups == 0)
                {
                    for (int si = 0; si < Variables.setups_info.Count; si++)
                    {
                        if (Variables.setups_info[si].options.is_export_tools)
                        {
                            Variables.setups_info[si].tool_fpath = Path.Combine(Variables.doc_options.output_dirpath,
                                                                                Variables.fname_no_ext + "_" + (string)Variables.setups_info[si].name + ".tls");
                            tool_info    = new StringBuilder();
                            tls_fcontent = new StringBuilder();
                            tool_list    = new StringBuilder();
                            for (int i = 0; i < Variables.setups_info[si].tools.Count; i++)
                            {
                                if (Variables.setups_info[si].tools[i].cutter_geom.Count == 0)
                                {
                                    continue;
                                }
                                if (tool_info.Length > 0)
                                {
                                    tool_info.AppendLine("");
                                }
                                tool_info.Append(
                                    VericutTool.ToXML(Variables.setups_info[si].tools[i], doc.Metric));
                                nc_prog       = Convert.ToInt32(Convert.ToString(Variables.setups_info[si].tools[i].turr_type).Replace("eTT_TURRET", ""));
                                nc_prog_fpath = Variables.setups_info[si].nc_fpaths[nc_prog - 1];
                                crib_pos      = String.Format("{0}:{1}",
                                                              Convert.ToString(Variables.setups_info[si].tools[i].turr_type).Replace("eTT_TURRET", ""),
                                                              Convert.ToInt32(Variables.setups_info[si].tools[i].id));
                                AppendToToolList(tool_list, nc_prog, init_num, crib_pos, nc_prog_fpath, Variables.setups_info[si].tools[i].optional_id);
                            }
                            Variables.setups_info[si].tool_list = "<ToolChange>" + Environment.NewLine +
                                                                  Utilities.Indent(tool_list.ToString(), 1) +
                                                                  "</ToolChange>";
                            tls_fcontent.AppendLine("<?xml version=\"1.0\"?>");
                            tls_fcontent.AppendLine("<CGTechToolLibrary>");
                            tls_fcontent.AppendLine(Utilities.Indent("<Tools>", 1));
                            tls_fcontent.AppendLine(Utilities.Indent(tool_info.ToString(), 2));
                            tls_fcontent.AppendLine(Utilities.Indent("</Tools>", 1));
                            tls_fcontent.Append("</CGTechToolLibrary>");
                            File.WriteAllText(Variables.setups_info[si].tool_fpath, tls_fcontent.ToString());
                            LogFile.Write(String.Format("Tool info was written to {0}", Variables.setups_info[si].tool_fpath));
                        }
                    }
                }
                else
                {
                    if (Variables.setups_info[0].options.is_export_tools)
                    {
                        for (int si = 0; si < Variables.setups_info.Count; si++)
                        {
                            if (Variables.setups_info[si].options.is_export_tools)
                            {
                                Variables.setups_info[si].tool_fpath = Path.Combine(Variables.doc_options.output_dirpath,
                                                                                    Variables.fname_no_ext + ".tls");
                            }
                        }
                        for (int i = 0; i < Variables.setups_info[0].tools.Count; i++)
                        {
                            if (Variables.setups_info[0].tools[i].cutter_geom.Count == 0)
                            {
                                continue;
                            }
                            tool_info.Append(tool_info.Length > 0 ? "\n" : "");
                            tool_info.Append(
                                VericutTool.ToXML(Variables.setups_info[0].tools[i], Variables.doc.Metric));
                            nc_prog       = Convert.ToInt32(Convert.ToString(Variables.setups_info[0].tools[i].turr_type).Replace("eTT_TURRET", ""));
                            nc_prog_fpath = Variables.setups_info[0].nc_fpaths[nc_prog - 1];
                            crib_pos      = String.Format("{0}:{1}",
                                                          Convert.ToString(Variables.setups_info[0].tools[i].turr_type).Replace("eTT_TURRET", ""),
                                                          Convert.ToInt32(Variables.setups_info[0].tools[i].id));
                            AppendToToolList(tool_list, nc_prog, init_num, crib_pos, nc_prog_fpath, Variables.setups_info[0].tools[i].optional_id);
                        }
                        Variables.setups_info[0].tool_list = "<ToolChange>" + Environment.NewLine +
                                                             Utilities.Indent(tool_list.ToString(), 1) +
                                                             "</ToolChange>";
                        tls_fcontent.AppendLine("<?xml version=\"1.0\"?>");
                        tls_fcontent.AppendLine("<CGTechToolLibrary>");
                        tls_fcontent.AppendLine(Utilities.Indent("<Tools>", 1));
                        tls_fcontent.AppendLine(Utilities.Indent(tool_info.ToString(), 2));
                        tls_fcontent.AppendLine(Utilities.Indent("</Tools>", 1));
                        tls_fcontent.Append("</CGTechToolLibrary>");
                        File.WriteAllText(Variables.setups_info[0].tool_fpath, tls_fcontent.ToString());
                        LogFile.Write(String.Format("Tool info was written to {0}", Variables.setups_info[0].tool_fpath));
                    }
                }
            }
            catch (Exception Ex)
            {
                LogFile.Write(String.Format("Exception occured during tool export. Exception details: {0}\n", Ex.Message));
                MessageDisplay.ShowError(
                    LanguageSupport.Translate("Failed to export tools"));
            }
        }