Esempio n. 1
0
        private void ShowAdvancedCalibration()
        {
            this.tbPrinterSettings.TabPages.Remove(this.Calibration);

            if (!this.tbPrinterSettings.TabPages.Contains(this.AdvancedCalibration))
            {
                this.tbPrinterSettings.TabPages.Add(this.AdvancedCalibration);
            }

            this.tbPrinterSettings.SelectedTab = this.AdvancedCalibration;
            this.lensWarpCorrectionItemsBindingSource.DataSource = LensWarpCorrectionItems.FromPrinterSettings(this._dataSource);

            this._dataSource.LensWarpingCorrection.Enabled = true;

            var materialCatalog = new MaterialsCatalog();

            foreach (var supplier in MaterialManager.Catalog)
            {
                var materialSupplier = new MaterialsBySupplier();
                //filter on printer type

                //un filtered
                foreach (var material in supplier.Materials.Where(m => string.IsNullOrEmpty(m.PrinterHardwareType)))
                {
                    materialSupplier.Materials.Add(material);
                }

                if (materialSupplier.Materials.Count > 0)
                {
                    materialSupplier.Supplier = supplier.Supplier;
                    materialCatalog.Add(materialSupplier);
                }
            }

            this.cbAdvancedCalibrationMaterialSupplier.DataSource = materialCatalog;

            cbMaterialManufacturer_SelectedIndexChanged(null, null);
        }
Esempio n. 2
0
        public static void Start(bool addHandlers)
        {
            //bind manufacturer comboxbox
            var serializer = new System.Xml.Serialization.XmlSerializer(typeof(MaterialsBySupplier));

            _materialCatalog = new MaterialsCatalog();

            //if no material catalog is found then save default items
            try
            {
                //                var hasLocalWriteAccess = FileSystemManager.HasWriteAccess(Settings.BasePath);
                //                if (hasLocalWriteAccess)
                //                {
                //                    LoggingManager.WriteToLog("Material Manager", "Base Path", Settings.MaterialsPath);

                //                    if (!Directory.Exists(Settings.MaterialsPath))
                //                    {
                //                        LoggingManager.WriteToLog("Material Manager", "Creating Base Path", Settings.MaterialsPath);

                //                        Directory.CreateDirectory(Settings.MaterialsPath);

                //                        LoggingManager.WriteToLog("Material Manager", "Created Base Path", Settings.MaterialsPath);

                //                        //add default materials
                //                        LoggingManager.WriteToLog("Material Manager", "Saving default materials", Settings.MaterialsPath);

                //#if LOCTITE
                //                        var defaultMaterialFilePath = Path.Combine(Settings.MaterialsPath, "Henkel.xml");
                //                        File.WriteAllBytes(defaultMaterialFilePath, Properties.Resources.Material_Henkel_xml);
                //#else
                //                        var defaultMaterialFilePath = Path.Combine(Settings.MaterialsPath, "3DMaterials.xml");
                //                        File.WriteAllBytes(defaultMaterialFilePath, Properties.Resources.Material_3DMaterials_xml);
                //#endif

                //                        LoggingManager.WriteToLog("Material Manager", "Saved default materials", Settings.MaterialsPath);
                //                    }
                //                }
                //                else
                {
                    LoggingManager.WriteToLog("Material Manager", "Base Path", Settings.RoamingMaterialsPath);

                    if (!Directory.Exists(Settings.RoamingMaterialsPath))
                    {
                        LoggingManager.WriteToLog("Material Manager", "Creating Base Path", Settings.RoamingMaterialsPath);

                        Directory.CreateDirectory(Settings.RoamingMaterialsPath);

                        LoggingManager.WriteToLog("Material Manager", "Created Base Path", Settings.RoamingMaterialsPath);
                    }
                    //add default materials
                    if ((!Directory.Exists(Settings.MaterialsPath) && Directory.GetFiles(Settings.RoamingMaterialsPath).Length == 0))
                    {
                        LoggingManager.WriteToLog("Material Manager", "Saving default materials", Settings.RoamingMaterialsPath);

#if LOCTITE
                        File.WriteAllBytes(Path.Combine(Settings.RoamingMaterialsPath, "Henkel.xml"), Properties.Resources.Material_Henkel_xml);
#else
                        File.WriteAllBytes(Path.Combine(Settings.RoamingMaterialsPath, "3D-Materials.xml"), Properties.Resources.Material_3DMaterials_xml);
#endif


                        LoggingManager.WriteToLog("Material Manager", "Saved default materials", Settings.RoamingMaterialsPath);
                    }
                    else if ((Directory.Exists(Settings.MaterialsPath) && Directory.GetFiles(Settings.MaterialsPath).Length == 0))
                    {
                        try
                        {
                            LoggingManager.WriteToLog("Material Manager", "Saving default materials", Settings.MaterialsPath);

#if LOCTITE
                            File.WriteAllBytes(Path.Combine(Settings.MaterialsPath, "Henkel.xml"), Properties.Resources.Material_Henkel_xml);
#else
                            File.WriteAllBytes(Path.Combine(Settings.MaterialsPath, "3D-Materials.xml"), Properties.Resources.Material_3DMaterials_xml);
#endif

                            LoggingManager.WriteToLog("Material Manager", "Saved default materials", Settings.RoamingMaterialsPath);
                        }
                        catch
                        {
                        }
                    }
                }

                if (Directory.Exists(Settings.MaterialsPath))
                {
                    foreach (var supplierXML in Directory.GetFiles(Settings.MaterialsPath))
                    {
                        LoggingManager.WriteToLog("Material Manager", "Loading material", supplierXML);

                        var updateMaterialFile = false;
                        MaterialsBySupplier updateSupplierMaterials = null;
                        using (var materialReader = new StreamReader(supplierXML))
                        {
                            var supplierMaterials = (MaterialsBySupplier)serializer.Deserialize(materialReader);
                            supplierMaterials.FilePath = supplierXML.Replace("/", "\\");

                            LoggingManager.WriteToLog("Material Manager", "Loaded material", supplierXML);
                            _materialCatalog.Add(supplierMaterials);

                            foreach (var material in supplierMaterials.Materials)
                            {
                                if (material.Id == Guid.Empty)
                                {
                                    material.Id        = Guid.NewGuid();
                                    updateMaterialFile = true;
                                }

                                //material.TransitionLayers.Add(new DAL.Catalogs.MaterialTransitionLayer() { CT = 100, LI = 15 });

                                if (material.SupportProfiles == null || material.SupportProfiles.Count == 0)
                                {
                                    material.SupportProfiles.Add(new SupportProfile());
                                    material.SupportProfiles[0].Selected = true;
                                    material.SupportProfiles[0].Default  = true;
                                }
                            }

                            updateSupplierMaterials = supplierMaterials;

                            materialReader.Close();
                        }

                        if (updateMaterialFile)
                        {
                            updateSupplierMaterials.SaveToFile();
                        }
                    }

                    if (addHandlers)
                    {
                        AddMaterialWatcher(Settings.MaterialsPath.Replace("/", "\\"));
                    }
                }

                else if (Directory.Exists(Settings.RoamingMaterialsPath))
                {
                    foreach (var supplierXML in Directory.GetFiles(Settings.RoamingMaterialsPath))
                    {
                        LoggingManager.WriteToLog("Material Manager", "Loading material", supplierXML);

                        var updateMaterialFile = false;
                        MaterialsBySupplier updateSupplierMaterials = null;
                        using (var materialReader = new StreamReader(supplierXML))
                        {
                            var supplierMaterials = (MaterialsBySupplier)serializer.Deserialize(materialReader);
                            supplierMaterials.FilePath = supplierXML.Replace("/", "\\");;

                            LoggingManager.WriteToLog("Material Manager", "Loaded material", supplierXML);

                            var supplierNameFound = false;
                            foreach (var supplier in _materialCatalog)
                            {
                                if (!string.IsNullOrEmpty(supplier.Supplier))
                                {
                                    if (supplier.Supplier.ToLower().Trim() == supplierMaterials.Supplier.ToLower().Trim())
                                    {
                                        supplierNameFound = true;
                                        break;
                                    }
                                }
                            }

                            if (!supplierNameFound)
                            {
                                foreach (var material in supplierMaterials.Materials)
                                {
                                    if (material.Id == Guid.Empty)
                                    {
                                        material.Id        = Guid.NewGuid();
                                        updateMaterialFile = true;
                                    }
                                    // material.TransitionLayers.Add(new DAL.Catalogs.MaterialTransitionLayer() { CT = 100, LI = 15 });

                                    if (material.SupportProfiles == null || material.SupportProfiles.Count == 0)
                                    {
                                        material.SupportProfiles.Add(SupportProfile.CreateDefault());
                                    }
                                }
                                _materialCatalog.Add(supplierMaterials);
                            }

                            updateSupplierMaterials = supplierMaterials;

                            materialReader.Close();

                            if (updateMaterialFile)
                            {
                                updateSupplierMaterials.SaveToFile();
                            }
                        }
                    }

                    if (addHandlers)
                    {
                        AddMaterialWatcher(Settings.RoamingMaterialsPath.Replace("/", "\\"));
                    }
                }
            }
            catch (Exception exc)
            {
                new frmMessageBox("Material Manager", exc.ToString(), MessageBoxButtons.OK, MessageBoxDefaultButton.Button2).ShowDialog();
                LoggingManager.WriteToLog("Material Manager", "Exception", exc);
            }
        }