Beispiel #1
0
        public void Initialize(ITypesContainer container)
        {
            container.Register <IDeviceConnection, Model.ModBusRtuConnection>(StringKeys.MODBUS_RTU_CONNECTION);
            container.Register <IModbusRtuConnection, Model.ModBusRtuConnection>();
            container.Register <IDeviceConnectionViewModel, ModBusConnectionViewModel>(StringKeys.MODBUS_RTU_CONNECTION + ApplicationGlobalNames.CommonInjectionStrings.VIEW_MODEL);

            //регистрация фабрики
            container.Register <IDeviceConnectionFactory, ModBusRtuConnectionFactory>(StringKeys.MODBUSRTU_CONNECTION_FACTORY_NAME);

            container.Register <IComPortConfigurationFactory, ComPortConfigurationFactory>();
            container.Register <IComPortConfigurationViewModelFactory, ComPortConfigurationViewModelFactory>();
            container.Register <IComPortConfiguration, ComPortConfiguration>();
            container.Register <IComPortConfigurationViewModel, ComPortConfigurationViewModel>();
            container.Register <IComPortInterrogationViewModel, ComPortInterrogationViewModel>();
            container.Register <IModBusConnectionViewModel, ModBusConnectionViewModel>();

            //регистрация менеджера подключений
            container.Register <IComConnectionManager, ComConnectionManager>(true);

            //регистрация известных для сериализации типов
            //ISerializerService serializerService = container.Resolve<ISerializerService>();
            //serializerService.AddKnownTypeForSerialization(typeof(Model.ModBusRtuConnection));
            //serializerService.AddKnownTypeForSerialization(typeof(ComPortConfiguration));
            //serializerService.AddNamespaceAttribute("modBusRtuConnection", "ModBusRtuConnectionNS");
            //serializerService.AddNamespaceAttribute("comPortConfiguration", "ComPortConfigurationNS");

            //регистрация ресурсов
            IXamlResourcesService xamlResourcesService = container.Resolve <IXamlResourcesService>();

            xamlResourcesService.AddResourceAsGlobal("Resources/ModBusRtuConnectionResources.xaml", GetType().Assembly);
            xamlResourcesService.AddResourceAsGlobal("Resources/ComPortConfigurationResources.xaml", GetType().Assembly);
        }
        public void Initialize(ITypesContainer container)
        {
            container.Register <DeviceEditorViewModel>();
            container.Register <object, DeviceEditorView>(ApplicationGlobalNames.ViewNames.DEVICEEDITOR_VIEW_NAME);

            container.Register(typeof(IResultingDeviceViewModel), typeof(ResultingDeviceViewModel));
            container.Register(typeof(ISharedResourcesGlobalViewModel), typeof(DeviceSharedResourcesViewModel), true);
            container.Register(typeof(IDeviceSharedResourcesViewModel), typeof(DeviceSharedResourcesViewModel));
            container.Register(typeof(IResourcesAddingViewModel), typeof(ResourcesAddingViewModel));
            container.Register(typeof(IResourceViewModel), typeof(ResourceViewModel));
            container.Register(typeof(ISharedResourcesEditorFactory), typeof(SharedResourcesEditorFactory));
            container.Register(typeof(IResourceEditingViewModel), typeof(ResourceEditingViewModel));
            container.Register(typeof(IConnectionStateViewModelFactory), typeof(ConnectionStateViewModelFactory));
            container.Register(typeof(IConnectionStateViewModel), typeof(ConnectionStateViewModel));

            container.Register <IDeviceEditorViewModelValidator, DeviceEditorViewModelValidator>(true);
        }
Beispiel #3
0
 public void Initialize(ITypesContainer container)
 {
     container.Register <DeviceEditingViewModel>();
     container.Register <object, DeviceEditingView>(ApplicationGlobalNames.ViewNames.DEVICEEDITING_VIEW_NAME);
 }
 public void Initialize(ITypesContainer containerRegistry)
 {
     containerRegistry.Register(typeof(IFragmentEditorViewModel), typeof(FileBrowserEditorViewModel),
                                FileOperationsKeys.FILE_BROWSER + ApplicationGlobalNames.CommonInjectionStrings.EDITOR_VIEWMODEL);
     containerRegistry.Resolve <IXamlResourcesService>().AddResourceAsGlobal("Resources/FileOperationsTemplates.xaml", this.GetType().Assembly);
 }
Beispiel #5
0
        public void Initialize(ITypesContainer container)
        {
            container.Register <IDeviceFragment, OscilloscopeModel>(OscilloscopeKeys.OSCILLOSCOPE);
            container.Register <IFragmentViewModel, OscilloscopeViewModel>(OscilloscopeKeys.OSCILLOSCOPE +
                                                                           ApplicationGlobalNames.CommonInjectionStrings
                                                                           .VIEW_MODEL);

            container
            .Register <IOscilloscopeLoadingSequenceInitializingParameters,
                       OscilloscopeLoadingSequenceInitializingParameters>();
            container.Register <IOscilloscopeModel, OscilloscopeModel>();

            container.Register <IOscilloscopeJournalViewModel, OscilloscopeJournalViewModel>();
            container.Register <IOscilloscopeViewModel, OscilloscopeViewModel>();
            container.Register <IOscillogramLoadingParameters, OscillogramLoadingParameters>();
            container.Register <IOscilloscopeTag, OscilloscopeTag>();
            container.Register <ICountingTemplate, CountingTemplate>();
            container.Register <IJournalLoadingSequence, OscilloscopeJournalLoadingSequence>(OscilloscopeKeys
                                                                                             .OSCILLOSCOPE_JOURNAL_LOADING_SEQUENCE);
            container.Register <OscillogramLoader>();

            /*ISerializerService serializerService = container.Resolve<ISerializerService>();
             * serializerService.AddKnownTypeForSerialization(typeof(OscilloscopeModel));
             * serializerService.AddNamespaceAttribute("oscilloscopeModel", "OscilloscopeModelNS");
             * serializerService.AddNamespaceAttribute("oscillogram", "OscillogramNS");
             * serializerService.AddKnownTypeForSerialization(typeof(OscilloscopeJournalLoadingSequence));
             * serializerService.AddNamespaceAttribute("oscilloscopeJournalLoadingSequence", "OscilloscopeJournalLoadingSequenceNS");
             * serializerService.AddKnownTypeForSerialization(typeof(OscillogramLoadingParameters));
             * serializerService.AddNamespaceAttribute("oscillogramLoadingParameters", "OscillogramLoadingParametersNS");
             * serializerService.AddKnownTypeForSerialization(typeof(OscilloscopeTag));
             * serializerService.AddNamespaceAttribute("oscilloscopeTag", "OscilloscopeTagNS");
             * serializerService.AddKnownTypeForSerialization(typeof(CountingTemplate));
             * serializerService.AddNamespaceAttribute("countingTemplate", "CountingTemplateNS");*/

            container.Resolve <IXamlResourcesService>().AddResourceAsGlobal("Resources/OscilloscopeDataTemplates.xaml",
                                                                            this.GetType().Assembly);

            container.Resolve <ILoadingSequenceLoaderRegistry>().AddLoader <OscilloscopeJournalLoadingSequence>((context, sequence) =>
                                                                                                                new OscilloscopeJournalSequenceLoader(sequence as OscilloscopeJournalLoadingSequence, context.DataProviderContainer));
        }
Beispiel #6
0
        public void Initialize(ITypesContainer container)
        {
            container.Register <IFormattedValueViewModel, BoolValueViewModel>(nameof(BoolValueViewModel));
            container.Register <IFormattedValueViewModel, NumericValueViewModel>(nameof(NumericValueViewModel));
            container.Register <INumericValueViewModel, NumericValueViewModel>();
            container.Register <IFormattedValueViewModel, BitMaskValueViewModel>(
                PresentationKeys.BIT_MASK_VALUE + ApplicationGlobalNames.CommonInjectionStrings.VIEW_MODEL);
            container.Register <IDeviceEventsDispatcher, FragmentLevelEventsDispatcher>();

            container.Register <IFormattedValueViewModel, ChosenFromListValueViewModel>(
                PresentationKeys.CHOSEN_FROM_LIST_VALUE_KEY + ApplicationGlobalNames.CommonInjectionStrings.VIEW_MODEL);
            container.Register <IFormattedValueViewModel, StringValueViewModel>(
                PresentationKeys.STRING_VALUE_KEY + ApplicationGlobalNames.CommonInjectionStrings.VIEW_MODEL);
            container.Register <IFormattedValueViewModel, ErrorValueViewModel>(nameof(ErrorValueViewModel));
            container.Register <ToolBarViewModel>(true);
            container.Register <IFormattedValueViewModel, EditableChosenFromListValueViewModel>(
                ApplicationGlobalNames.CommonInjectionStrings.EDITABLE + PresentationKeys.CHOSEN_FROM_LIST_VALUE_KEY +
                ApplicationGlobalNames.CommonInjectionStrings.VIEW_MODEL);
            container.Register(typeof(IFormattedValueViewModel), typeof(EditableNumericValueViewModel),
                               ApplicationGlobalNames.CommonInjectionStrings.EDITABLE + PresentationKeys.NUMERIC_VALUE_KEY +
                               ApplicationGlobalNames.CommonInjectionStrings.VIEW_MODEL);
            container.Register(typeof(IFormattedValueViewModel), typeof(EditableBoolValueViewModel),
                               ApplicationGlobalNames.CommonInjectionStrings.EDITABLE + PresentationKeys.BOOL_VALUE_KEY +
                               ApplicationGlobalNames.CommonInjectionStrings.VIEW_MODEL);
            container.Register(typeof(IStringValueViewModel), typeof(StringValueViewModel));
            container.Register(typeof(IDeviceEventsDispatcher), typeof(FragmentLevelEventsDispatcher));

            container.Register(typeof(IBoolValueViewModel), typeof(BoolValueViewModel));
            container.Register(typeof(IBitMaskValueViewModel), typeof(BitMaskValueViewModel));
            container.Register(typeof(IValueViewModelFactory), typeof(ValueViewModelFactory));
            container.Register(typeof(ICommandStackService), typeof(CommandStackService), true);

            container.Register(typeof(IFragmentOptionCommandViewModel), typeof(DefaultFragmentOptionCommandViewModel));
            container.Register(typeof(IFragmentOptionGroupViewModel), typeof(DefaultFragmentOptionGroupViewModel));
            container.Register(typeof(IFragmentOptionsViewModel), typeof(DefaultFragmentOptionsViewModel));

            container.Register(typeof(IFragmentSettingViewModel), typeof(QuickAccessMemorySettingViewModel),
                               ApplicationGlobalNames.QUICK_ACCESS_MEMORY_CONFIGURATION_SETTING +
                               ApplicationGlobalNames.CommonInjectionStrings.VIEW_MODEL);

            container.Register(typeof(IFragmentPaneViewModelFactory), typeof(FragmentPaneViewModelFactory));
            container.Register(typeof(IFragmentPaneViewModel), typeof(FragmentPaneViewModel));

            container.Register(typeof(IDeviceViewModelFactory), typeof(DeviceViewModelFactory));
            container.Register(typeof(IDeviceViewModel), typeof(DeviceViewModel));
            container.Register(typeof(IRangeViewModel), typeof(RangeViewModel));
            container.Register(typeof(IConnectionStateViewModel), typeof(ConnectionStateViewModel));
            container.Register(typeof(IDeviceLoggerViewModel), typeof(DeviceLoggerViewModel));
            container.Register(typeof(IDependenciesService), typeof(DependenciesService));
            container.Register <DependenciesViewModel>();
            container.Register(typeof(ILogServiceViewModel), typeof(LogServiceViewModel), true);
            container.Register(typeof(IProjectBrowserViewModel), typeof(ProjectBrowserViewModel), true);
            container.Register(typeof(ILoadAllService), typeof(LoadAllService), true);

            container.Register(typeof(IFragmentEditorViewModelFactory), typeof(FragmentEditorViewModelFactory));
            container.Register(typeof(IFragmentSettingsViewModel), typeof(FragmentSettingsViewModel));
            container.Register(typeof(IEditableValueFetchingFromViewModelVisitor),
                               typeof(EditableValueFetchingFromViewModelVisitor));
            container.Register <IConnectionService, ConnectionService>();
            container.Register <IExcelImporter, ExcelExportService>();
            container.Register <IExcelExporter, ExcelExportService>();
        }
Beispiel #7
0
        public void Initialize(ITypesContainer container)
        {
            container.Register <IUniconJournal, UniconJournal>();
            container.Register <IJournalRecord, JournalRecord>();
            container.Register <IJournalParameter, JournalParameter>();
            container.Register <IComplexJournalParameter, ComplexJournalParameter>();
            container.Register <ISubJournalParameter, SubJournalParameter>();
            container.Register <IDependentJournalParameter, DependentJournalParameter>();
            container.Register <IJournalCondition, JournalParameterDependancyCondition>();
            container.Register <IJournalLoaderProvider, JournalLoaderProvider>();

            container.Register <IRecordTemplate, RecordTemplate>();
            container.Register <ILoadingSequenceLoaderRegistry, LoadingSequenceLoaderRegistry>(true);

            container.Register <IFragmentViewModel, UniconJournalViewModel>(
                JournalKeys.UNICON_JOURNAL + ApplicationGlobalNames.CommonInjectionStrings.VIEW_MODEL);
            container.Register <IJournalRecordViewModel, JournalRecordViewModel>();
            container.Register <IJournalRecordFactory, JournalRecordFactory>();
            container.Register <IJournalRecordViewModelFactory, JournalRecordViewModelFactory>();

            container.Register <IJournalLoadingSequence, OffsetLoadingSequence>(JournalKeys
                                                                                .OFFSET_LOADING_SEQUENCE);
            container.Register <IJournalLoadingSequence, IndexLoadingSequence>(JournalKeys
                                                                               .INDEX_LOADING_SEQUENCE);

            //ISerializerService serializerService = container.Resolve<ISerializerService>();
            //serializerService.AddKnownTypeForSerializationRange(new[]
            //{
            //    typeof(DependentJournalParameter), typeof(JournalParameterDependancyCondition),
            //    typeof(UniconJournal), typeof(JournalRecord), typeof(JournalParameter), typeof(RecordTemplate),
            //    typeof(SubJournalParameter), typeof(ComplexJournalParameter), typeof(OffsetLoadingSequence), typeof(IndexLoadingSequence)
            //});
            //serializerService.AddNamespaceAttribute("journal", "UniconJournalNS");
            //serializerService.AddNamespaceAttribute("journalRecord", "JournalRecordNS");
            //serializerService.AddNamespaceAttribute("journalParameter", "JournalParameterNS");
            //serializerService.AddNamespaceAttribute("subJournalParameter", "SubJournalParameterNS");
            //serializerService.AddNamespaceAttribute("complexJournalParameter", "ComplexJournalParameterNS");
            //serializerService.AddNamespaceAttribute("offsetLoadingSequence", "OffsetLoadingSequenceNS");
            //serializerService.AddNamespaceAttribute("indexLoadingSequence", "IndexLoadingSequenceNS");
            //serializerService.AddNamespaceAttribute("recordTemplate", "RecordTemplateNS");
            //serializerService.AddNamespaceAttribute("journalParameterDependancyCondition",
            //    "JournalParameterDependancyConditionNS");
            //serializerService.AddNamespaceAttribute("dependentJournalParameter", "DependentJournalParameterNS");


            container.Resolve <IXamlResourcesService>().AddResourceAsGlobal("Resources/JournalDataTemplates.xaml",
                                                                            GetType().Assembly);

            container.Resolve <ILoadAllService>().RegisterFragmentLoadHandler(
                JournalKeys.UNICON_JOURNAL + ApplicationGlobalNames.CommonInjectionStrings.VIEW_MODEL,
                JournalLoadHelper.GetJournalLoadingHelper());

            container.Resolve <ILoadingSequenceLoaderRegistry>().AddLoader <OffsetLoadingSequence>((context, sequence) =>
                                                                                                   new OffsetLoadingSequenceLoader(sequence as OffsetLoadingSequence, context.DataProviderContainer));

            container.Resolve <ILoadingSequenceLoaderRegistry>().AddLoader <IndexLoadingSequence>((context, sequence) =>
                                                                                                  new IndexLoadingSequenceLoader(sequence as IndexLoadingSequence, context.DataProviderContainer));
        }
Beispiel #8
0
        public void Initialize(ITypesContainer container)
        {
            container.Register <IConnectionState, DeviceConnectionState>();
            container.Register <IResourceContainer, ResourceContainer>();

            container.Register <IBoolValue, BoolValue>();
            container.Register <INumericValue, NumericValue>();
            container.Register <IChosenFromListValue, ChosenFromListValue>();
            container.Register <IRange, DefaultRange>();
            container.Register <IBitGroupValue, BitGroupValue>();
            container.Register <IDeviceSharedResources, DeviceSharedResources>();
            container.Register <IErrorValue, ErrorValue>();
            container.Register <IStringValue, StringValue>();
            container.Register <ITimeValue, TimeValue>();
            container.Register <IFragmentSettings, DefaultFragmentSettings>();
            container.Register <IBitMaskValue, BitMaskValue>();
            container.Register <IBoolToAddressDependency, BoolToAddressDependency>();
            container.Register <IActivatedSettingApplyingContext, ActivatedSettingApplyingContext>();
            container.Register <IQuickAccessMemoryApplyingContext, QuickAccessMemoryApplyingContext>();
            container.Register <IFragmentSetting, QuickMemoryAccessSetting>(ApplicationGlobalNames.QUICK_ACCESS_MEMORY_CONFIGURATION_SETTING);

            container.Register <IQueryResult <ushort[]>, DefaultQueryResult <ushort[]> >();
            container.Register <IQueryResult <bool[]>, DefaultQueryResult <bool[]> >();
            container.Register <IQueryResult <bool>, DefaultQueryResult <bool> >();
            container.Register <IQueryResult <ushort>, DefaultQueryResult <ushort> >();
            container.Register <IQueryResult, DefaultQueryResult>();

            container.Register <IQueryResultFactory, QueryResultFactory>();
            container.Register <IDeviceMemory, DeviceMemory>();

            container.Register <ITaskProgressReport, TaskProgressReport>();

            container.Register <IDeviceCreator, DefaultDeviceCreator>();
            container.Register(typeof(IDevice), typeof(DefaultDevice.DefaultDevice));

            //ISerializerService serializer = container.Resolve<ISerializerService>();
            //serializer.AddKnownTypeForSerialization(typeof(BoolValue));
            //serializer.AddKnownTypeForSerialization(typeof(NumericValue));
            //serializer.AddKnownTypeForSerialization(typeof(ChosenFromListValue));
            //serializer.AddKnownTypeForSerialization(typeof(BitGroupValue));
            //serializer.AddKnownTypeForSerialization(typeof(ErrorValue));
            //serializer.AddKnownTypeForSerialization(typeof(StringValue));
            //serializer.AddKnownTypeForSerialization(typeof(BitMaskValue));
            //serializer.AddKnownTypeForSerialization(typeof(TimeValue));

            //serializer.AddKnownTypeForSerialization(typeof(DeviceSharedResources));

            //serializer.AddKnownTypeForSerialization(typeof(QuickMemoryAccessSetting));
            //serializer.AddKnownTypeForSerialization(typeof(DefaultFragmentSettings));
            //serializer.AddNamespaceAttribute("deviceSharedResourcesNS", "DeviceSharedResourcesNS");
            //serializer.AddNamespaceAttribute("quickMemoryAccessSetting", "QuickMemoryAccessSettingNS");
            //serializer.AddNamespaceAttribute("defaultFragmentSettings", "defaultFragmentSettingsNS");
            //serializer.AddKnownTypeForSerialization(typeof(DefaultRange));
            //serializer.AddKnownTypeForSerialization(typeof(DefaultDevice.DefaultDevice));
            //serializer.AddKnownTypeForSerialization(typeof(DeviceConnectionState));
            //serializer.AddNamespaceAttribute("defaultRange", "DefaultRangeNS");
            //serializer.AddNamespaceAttribute("defaultDevice", "DefaultDeviceNS");

            //serializer.AddNamespaceAttribute("array", "http://schemas.microsoft.com/2003/10/Serialization/Arrays");

            //serializer.AddNamespaceAttribute("values", "ValuesNS");
        }
        public void Initialize(ITypesContainer container)
        {
            container.Register <IConfigurationItem, AppointableMatrix>(ConfigurationKeys.APPOINTABLE_MATRIX);
            container.Register <IMatrixTemplate, DefaultMatrixTemplate>();
            container.Register <IMatrixMemoryVariable, DefaultMatrixMemoryVariable>();
            container.Register <IVariableColumnSignature, DefaultVariableColumnSignature>();
            container.Register <IOptionPossibleValue, OptionPossibleValue>();
            container.Register <IPossibleValueCondition, PossibleValueCondition>();
            container.Register <IBitOptionUpdatingStrategy, DefaultBitOptionUpdatingStrategy>();

            container.Register <IMatrixVariableOptionTemplate, ListMatrixVariableOptionTemplate>(MatrixKeys.LIST_MATRIX_TEMPLATE);
            container.Register <IMatrixVariableOptionTemplate, BoolMatrixVariableOptionTemplate>(MatrixKeys.BOOL_MATRIX_TEMPLATE);
            container.Register <IBitOption, BoolMatrixBitOption>(MatrixKeys.BOOL_MATRIX_BIT_OPTION);
            container.Register <IBitOption, ListMatrixBitOption>(MatrixKeys.LIST_MATRIX_BIT_OPTION);
            container.Register <MatrixViewModelTableFactory>();

            //container.Register(typeof(IViewModel), typeof(AppointableMatrixEditorViewModel),
            //    ConfigurationKeys.APPOINTABLE_MATRIX + ApplicationGlobalNames.CommonInjectionStrings.EDITOR_VIEWMODEL);
            //container.Register(typeof(IViewModel), typeof(BoolMatrixVariableOptionTemplateEditorViewModel),
            //         MatrixKeys.BOOL_MATRIX_TEMPLATE + ApplicationGlobalNames.CommonInjectionStrings.EDITOR_VIEWMODEL);
            //container.Register(typeof(IViewModel), typeof(ListMatrixVariableOptionTemplateEditorViewModel),
            //    MatrixKeys.LIST_MATRIX_TEMPLATE + ApplicationGlobalNames.CommonInjectionStrings.EDITOR_VIEWMODEL);



            container.Register(typeof(IRuntimeAppointableMatrixViewModel), typeof(RuntimeRuntimeAppointableMatrixViewModel));


            container.Register <IMatrixTemplateEditorViewModel, MatrixTemplateEditorViewModel>();

            container.Register <IFormattedValueViewModel, MatrixValueViewModel>(
                MatrixKeys.MATRIX_VALUE +
                ApplicationGlobalNames.CommonInjectionStrings.VIEW_MODEL);


            container.Register <IFormattedValueViewModel, EditableMatrixValueViewModel>(
                ApplicationGlobalNames.CommonInjectionStrings.EDITABLE +
                MatrixKeys.MATRIX_VALUE +
                ApplicationGlobalNames.CommonInjectionStrings.VIEW_MODEL);


            container.Register <IMatrixTemplateEditorViewModel, MatrixTemplateEditorViewModel>();

            container.Register <IMatrixMemoryVariableEditorViewModel, MatrixMemoryVariableEditorViewModel>();
            container.Register <IMatrixMemoryVariableEditorViewModelFactory, MatrixMemoryVariableEditorViewModelFactory>();
            container.Register <IVariableSignatureEditorViewModel, VariableSignatureEditorViewModel>();
            container.Register <IVariableSignatureEditorViewModelFactory, VariableSignatureEditorViewModelFactory>();
            container.Register <IMatrixVariableOptionTemplateEditorViewModelFactory, MatrixVariableOptionTemplateEditorViewModelFactory>();

            container.Register <IOptionPossibleValueEditorViewModel, OptionPossibleValueEditorViewModel>();
            container.Register <IPossibleValueConditionEditorViewModel, PossibleValueConditionEditorViewModel>();
            container.Register <IBitOptionEditorViewModel, BitOptionEditorViewModel>();

            container.Register <IAssignedBitEditorViewModel, AssignedBitEditorViewModel>();

            //ISerializerService serializerService = container.Resolve<ISerializerService>();
            //serializerService.AddKnownTypeForSerialization(typeof(AppointableMatrix));
            //serializerService.AddKnownTypeForSerialization(typeof(DefaultMatrixTemplate));
            //serializerService.AddKnownTypeForSerialization(typeof(DefaultMatrixMemoryVariable));
            //serializerService.AddKnownTypeForSerialization(typeof(DefaultVariableColumnSignature));
            //serializerService.AddKnownTypeForSerialization(typeof(ListMatrixVariableOptionTemplate));
            //serializerService.AddKnownTypeForSerialization(typeof(BoolMatrixVariableOptionTemplate));
            //serializerService.AddKnownTypeForSerialization(typeof(OptionPossibleValue));
            //serializerService.AddKnownTypeForSerialization(typeof(PossibleValueCondition));
            //serializerService.AddKnownTypeForSerialization(typeof(BoolMatrixBitOption));
            //serializerService.AddKnownTypeForSerialization(typeof(ListMatrixBitOption));
            //serializerService.AddKnownTypeForSerialization(typeof(MatrixValueFormatter));

            //serializerService.AddNamespaceAttribute("appointableMatrix", "AppointableMatrixNS");
            //serializerService.AddNamespaceAttribute("matrixValueFormatter", "MatrixValueFormatterNS");


            //регистрация ресурсов
            container.Resolve <IXamlResourcesService>().AddResourceAsGlobal("Resources/MatrixDataTemplates.xaml", GetType().Assembly);
        }
Beispiel #10
0
        public void Initialize(ITypesContainer container)
        {
            container.Register(typeof(IFragmentEditorViewModel), typeof(UniconJournalEditorViewModel),
                               JournalKeys.UNICON_JOURNAL + ApplicationGlobalNames.CommonInjectionStrings.EDITOR_VIEWMODEL);

            container.Register <IJournalParameterEditorViewModel, JournalParameterEditorViewModel>();
            container.Register <IJournalParametersEditorViewModelFactory, JournalParametersEditorViewModelFactory>();
            container.Register <IComplexJournalParameterEditorViewModel, ComplexJournalParameterEditorViewModel>();
            container.Register <IDependentJournalParameterEditorViewModel, DependentJournalParameterEditorViewModel>();
            container.Register <IJournalConditionEditorViewModel, JournalConditionEditorViewModel>();
            container.Register <ISubJournalParameterEditorViewModel, SubJournalParameterEditorViewModel>();
            container.Register <IJournalLoadingSequenceEditorViewModel, OffsetLoadingSequenceEditorViewModel>(JournalKeys.OFFSET_LOADING_SEQUENCE + ApplicationGlobalNames.CommonInjectionStrings.EDITOR_VIEWMODEL);
            container.Register <IJournalLoadingSequenceEditorViewModel, IndexLoadingSequenceEditorViewModel>(JournalKeys.INDEX_LOADING_SEQUENCE + ApplicationGlobalNames.CommonInjectionStrings.EDITOR_VIEWMODEL);
            container.Register <IUniconJournalEditorViewModel, UniconJournalEditorViewModel>();

            container.Register <IJournalConditionEditorViewModelFactory, JournalConditionEditorViewModelFactory>();

            container.Register <IJournalSequenceEditorViewModelFactory, JournalSequenceEditorViewModelFactory>();
            container.Register <IRecordTemplateEditorViewModel, RecordTemplateEditorViewModel>();

            container.Resolve <IXamlResourcesService>().AddResourceAsGlobal("Resources/JournalDataTemplates.xaml", this.GetType().Assembly);
        }
Beispiel #11
0
        public void Initialize(ITypesContainer container)
        {
            container.Register <ProgramModel>();
            container.Register <IFragmentViewModel, ProgrammingViewModel>(ProgrammingKeys.PROGRAMMING + ApplicationGlobalNames.CommonInjectionStrings.VIEW_MODEL);
            container.Register <LogicDeviceProvider>();
            container.Register <SchemeTabViewModel>();
            container.Register <LogicElementsFactory>();

            container.Register <LogicElement, Input>(ProgrammingKeys.INPUT);
            container.Register <LogicElementViewModel, InputViewModel>(ProgrammingKeys.INPUT + ApplicationGlobalNames.CommonInjectionStrings.VIEW_MODEL);
            container.Register <LogicElement, Output>(ProgrammingKeys.OUTPUT);
            container.Register <LogicElementViewModel, OutputViewModel>(ProgrammingKeys.OUTPUT + ApplicationGlobalNames.CommonInjectionStrings.VIEW_MODEL);
            container.Register <LogicElement, Inversion>(ProgrammingKeys.INVERSION);
            container.Register <LogicElementViewModel, InversionViewModel>(ProgrammingKeys.INVERSION + ApplicationGlobalNames.CommonInjectionStrings.VIEW_MODEL);
            container.Register <LogicElement, And>(ProgrammingKeys.AND);
            container.Register <LogicElementViewModel, AndViewModel>(ProgrammingKeys.AND + ApplicationGlobalNames.CommonInjectionStrings.VIEW_MODEL);
            container.Register <LogicElement, Or>(ProgrammingKeys.OR);
            container.Register <LogicElementViewModel, OrViewModel>(ProgrammingKeys.OR + ApplicationGlobalNames.CommonInjectionStrings.VIEW_MODEL);
            container.Register <LogicElement, Xor>(ProgrammingKeys.XOR);
            container.Register <LogicElementViewModel, XorViewModel>(ProgrammingKeys.XOR + ApplicationGlobalNames.CommonInjectionStrings.VIEW_MODEL);
            container.Register <LogicElement, AlarmJournal>(ProgrammingKeys.ALARM_JOURNAL);
            container.Register <LogicElementViewModel, AlarmJournalViewModel>(ProgrammingKeys.ALARM_JOURNAL + ApplicationGlobalNames.CommonInjectionStrings.VIEW_MODEL);
            container.Register <LogicElement, SystemJournal>(ProgrammingKeys.SYSTEM_JOURNAL);
            container.Register <LogicElementViewModel, SystemJournalViewModel>(ProgrammingKeys.SYSTEM_JOURNAL + ApplicationGlobalNames.CommonInjectionStrings.VIEW_MODEL);
            container.Register <LogicElement, Timer>(ProgrammingKeys.TIMER);
            container.Register <LogicElementViewModel, TimerViewModel>(ProgrammingKeys.TIMER + ApplicationGlobalNames.CommonInjectionStrings.VIEW_MODEL);
            container.Register <LogicElement, RsTrigger>(ProgrammingKeys.RS_TRIGGER);
            container.Register <LogicElementViewModel, RsTriggerViewModel>(ProgrammingKeys.RS_TRIGGER + ApplicationGlobalNames.CommonInjectionStrings.VIEW_MODEL);
            container.Register <LogicElement, SrTrigger>(ProgrammingKeys.SR_TRIGGER);
            container.Register <LogicElementViewModel, SrTriggerViewModel>(ProgrammingKeys.SR_TRIGGER + ApplicationGlobalNames.CommonInjectionStrings.VIEW_MODEL);

            container.Resolve <IXamlResourcesService>().AddResourceAsGlobal("UI/ProgrammingViewTemplate.xaml", GetType().Assembly);
        }