Esempio n. 1
0
 public SimpleProcessor(ProcessorWrapper processor)
 {
     if (processor.DebugProcessor != null)
     {
         Name        = processor.DebugProcessor.ProcessorName;
         ProcessorId = processor.DebugProcessor.Id;
     }
     else
     {
         Name = processor.CoreProcessor.Name;
     }
 }
Esempio n. 2
0
        private void ShowDescription(ComponentWrapper processor)
        {
            ProcessorWrapper PW = PK.Wrapper.FindProcessor(processor.Guid);

            DescriptionTB.Clear();
            if (PW != null)
            {
                DescriptionTB.AppendText("Name: " + PW.Name + "\r\n\r\n");
                DescriptionTB.AppendText("Project Path:\r\n");
                DescriptionTB.AppendText(PW.ProjectPath + "\r\n\r\n");
                DescriptionTB.AppendText("Description:\r\n");
                DescriptionTB.AppendText(PW.Description + "\r\n\r\n");
            }
        }
Esempio n. 3
0
        public override void BeforeShow()
        {
            RefreshDialog();

            if (config.Processor != null)
            {
                SelectedProc = config.Processor;
                TreeNode DeviceNode = GetDeviceNode(SelectedProc.Device);
                DeviceNode.EnsureVisible();
                treeView1.SelectedNode = DeviceNode;
            }
            else
            {
                ProcessorWrapper proc       = PK.Wrapper.FindProcessor(sol.Processor.Guid);
                TreeNode         DeviceNode = GetDeviceNode(proc.Name);
                if (DeviceNode != null)
                {
                    DeviceNode.EnsureVisible();
                    treeView1.SelectedNode = DeviceNode;
                }
            }

            base.BeforeShow();
        }
Esempio n. 4
0
        private void CheckComponent(ComponentWrapper OwnerComponent, string text, ComponentWrapper component)
        {
            ComponentMessageObject CMO = new ComponentMessageObject();

            CMO.Component = OwnerComponent;

            ComponentsChecked++;
            switch (component.ComponentType)
            {
                #region Library
            case ComponentTypeWrapper.Library:
                if (!CheckComponentGUID(component, text, CMO))
                {
                    return;
                }

                LibraryWrapper LW = PK.Wrapper.FindLibrary(component.Guid);
                if (LW == null)
                {
                    CanTFindComponentsReference(component, text, CMO);
                    return;
                }
                CompareComponentName(component, LW.Name, text, CMO);
                CompareComponentProjectPath(component, LW.ProjectPath, text, CMO);
                break;

                #endregion
                #region Feature
            case ComponentTypeWrapper.Feature:
                if (!CheckComponentGUID(component, text, CMO))
                {
                    return;
                }

                FeatureWrapper FW = PK.Wrapper.FindFeature(component.Guid);
                if (FW == null)
                {
                    CanTFindComponentsReference(component, text, CMO);
                    return;
                }
                CompareComponentName(component, FW.Name, text, CMO);
                CompareComponentProjectPath(component, FW.ProjectPath, text, CMO);
                break;

                #endregion
                #region Assembly
            case ComponentTypeWrapper.MFAssembly:
                if (!CheckComponentGUID(component, text, CMO))
                {
                    return;
                }

                AssemblyWrapper AW = PK.Wrapper.FindAssembly(component.Guid);
                if (AW == null)
                {
                    CanTFindComponentsReference(component, text, CMO);
                    return;
                }
                CompareComponentName(component, AW.Name, text, CMO);
                CompareComponentProjectPath(component, AW.ProjectPath, text, CMO);
                break;

                #endregion
            case ComponentTypeWrapper.MFSolution:
                break;

                #region Processors
            case ComponentTypeWrapper.Processor:
                if (!CheckComponentGUID(component, text, CMO))
                {
                    return;
                }

                ProcessorWrapper PW = PK.Wrapper.FindProcessor(component.Guid);
                if (PW == null)
                {
                    CanTFindComponentsReference(component, text, CMO);
                    return;
                }
                CompareComponentName(component, PW.Name, text, CMO);
                CompareComponentProjectPath(component, PW.ProjectPath, text, CMO);
                break;

                #endregion
            case ComponentTypeWrapper.OperatingSystem:
                break;

            case ComponentTypeWrapper.BuildTool:
                break;

                #region ISA
            case ComponentTypeWrapper.ISA:
                if (!CheckComponentGUID(component, text, CMO))
                {
                    return;
                }

                ISAWrapper IW = PK.Wrapper.FindISA(component.Guid);
                if (IW == null)
                {
                    CanTFindComponentsReference(component, text, CMO);
                    return;
                }
                CompareComponentName(component, IW.Name, text, CMO);
                break;

                #endregion
            case ComponentTypeWrapper.BuildParameter:
                break;

                #region LibraryCategory
            case ComponentTypeWrapper.LibraryCategory:
                if (!CheckComponentGUID(component, text, CMO))
                {
                    return;
                }

                LibraryCategoryWrapper LCW = PK.Wrapper.FindLibraryCategory(component.Guid);
                if (LCW == null)
                {
                    CanTFindComponentsReference(component, text, CMO);
                    return;
                }

                CompareComponentName(component, LCW.Name, text, CMO);

                CompareComponentProjectPath(component, LCW.ProjectPath, text, CMO);
                break;

                #endregion
                #region Unknown
            case ComponentTypeWrapper.Unknown:
                WEMessage UMessage = new WEMessage();
                UMessage.Message       = text + "Component with \"Type\": " + GetStringByComponentType(component.ComponentType);
                UMessage.MessageObject = CMO;
                this.OnWarning(UMessage);
                break;

                #endregion
            default:
                break;
            }
        }