From 4d51533b0d70c01257dc23e3ea5e3ca11ba7a142 Mon Sep 17 00:00:00 2001 From: Johan Larsson Date: Mon, 23 Nov 2015 00:18:02 +0100 Subject: [PATCH] TypeConverters for Units --- Gu.Units.Generator/Gu.Units.Generator.csproj | 62 +- .../Templates/EnumerableGenerator.tt | 2 +- .../Templates/EnumerableGenerator.txt | 8 +- .../Templates/QuantityGenerator.tt | 4 +- .../Templates/QuantityGenerator.txt | 101 +- ...eConverter.tt => QuantityTypeConverter.tt} | 4 +- ...r.tt => QuantityTypeConverterGenerator.tt} | 4 +- Gu.Units.Generator/Templates/Unit.tt | 2 +- Gu.Units.Generator/Templates/UnitGenerator.tt | 20 +- .../Templates/UnitGenerator.txt | 101 +- .../Templates/UnitTypeConverter.tt | 113 ++ .../Templates/UnitTypeConverterGenerator.tt | 37 + Gu.Units.Wpf.Demo/App.config | 6 + Gu.Units.Wpf.Demo/App.xaml | 9 + Gu.Units.Wpf.Demo/App.xaml.cs | 11 + Gu.Units.Wpf.Demo/Gu.Units.Wpf.Demo.csproj | 111 ++ Gu.Units.Wpf.Demo/MainWindow.xaml | 34 + Gu.Units.Wpf.Demo/MainWindow.xaml.cs | 15 + Gu.Units.Wpf.Demo/Properties/Annotations.cs | 996 ++++++++++++++++++ Gu.Units.Wpf.Demo/Properties/AssemblyInfo.cs | 55 + .../Properties/Resources.Designer.cs | 71 ++ Gu.Units.Wpf.Demo/Properties/Resources.resx | 117 ++ .../Properties/Settings.Designer.cs | 30 + .../Properties/Settings.settings | 7 + Gu.Units.Wpf.Demo/ViewModel.cs | 31 + Gu.Units.Wpf.Tests/Class1.cs | 6 + Gu.Units.Wpf.Tests/Gu.Units.Wpf.Tests.csproj | 85 ++ Gu.Units.Wpf.Tests/Properties/AssemblyInfo.cs | 36 + Gu.Units.Wpf.Tests/paket.references | 1 + Gu.Units.Wpf/Gu.Units.Wpf.csproj | 57 + Gu.Units.Wpf/LengthConverter.cs | 50 + Gu.Units.Wpf/Properties/AssemblyInfo.cs | 40 + Gu.Units.sln | 24 + Gu.Units.sln.DotSettings | 1 + ...AccelerationUnitTypeConverter.generated.cs | 88 ++ Gu.Units/AngleUnitTypeConverter.generated.cs | 88 ++ ...AccelerationUnitTypeConverter.generated.cs | 88 ++ .../AngularJerkUnitTypeConverter.generated.cs | 88 ++ ...AngularSpeedUnitTypeConverter.generated.cs | 88 ++ Gu.Units/AreaUnitTypeConverter.generated.cs | 88 ++ .../CapacitanceUnitTypeConverter.generated.cs | 88 ++ .../CurrentUnitTypeConverter.generated.cs | 88 ++ .../DensityUnitTypeConverter.generated.cs | 88 ++ ...ectricChargeUnitTypeConverter.generated.cs | 88 ++ Gu.Units/EnergyUnitTypeConverter.generated.cs | 88 ++ .../FlexibilityUnitTypeConverter.generated.cs | 88 ++ Gu.Units/ForceUnitTypeConverter.generated.cs | 88 ++ .../FrequencyUnitTypeConverter.generated.cs | 88 ++ Gu.Units/Gu.Units.csproj | 163 ++- .../InductanceUnitTypeConverter.generated.cs | 88 ++ Gu.Units/JerkUnitTypeConverter.generated.cs | 88 ++ Gu.Units/LengthUnitTypeConverter.generated.cs | 88 ++ ...ousIntensityUnitTypeConverter.generated.cs | 88 ++ Gu.Units/MassUnitTypeConverter.generated.cs | 88 ++ Gu.Units/PowerUnitTypeConverter.generated.cs | 88 ++ .../PressureUnitTypeConverter.generated.cs | 88 ++ ...t4 => QuantityTypeConverterGenerator.txt4} | 0 .../ResistanceUnitTypeConverter.generated.cs | 88 ++ ...ecificEnergyUnitTypeConverter.generated.cs | 88 ++ Gu.Units/SpeedUnitTypeConverter.generated.cs | 88 ++ .../StiffnessUnitTypeConverter.generated.cs | 88 ++ .../TemperatureUnitTypeConverter.generated.cs | 88 ++ Gu.Units/TimeUnitTypeConverter.generated.cs | 88 ++ Gu.Units/TorqueUnitTypeConverter.generated.cs | 88 ++ Gu.Units/UnitTypeConverterGenerator.txt4 | 0 .../UnitlessUnitTypeConverter.generated.cs | 88 ++ .../VoltageUnitTypeConverter.generated.cs | 88 ++ Gu.Units/VolumeUnitTypeConverter.generated.cs | 88 ++ ...lumetricFlowUnitTypeConverter.generated.cs | 88 ++ 69 files changed, 5150 insertions(+), 80 deletions(-) rename Gu.Units.Generator/Templates/{TypeConverter.tt => QuantityTypeConverter.tt} (97%) rename Gu.Units.Generator/Templates/{TypeConverterGenerator.tt => QuantityTypeConverterGenerator.tt} (85%) create mode 100644 Gu.Units.Generator/Templates/UnitTypeConverter.tt create mode 100644 Gu.Units.Generator/Templates/UnitTypeConverterGenerator.tt create mode 100644 Gu.Units.Wpf.Demo/App.config create mode 100644 Gu.Units.Wpf.Demo/App.xaml create mode 100644 Gu.Units.Wpf.Demo/App.xaml.cs create mode 100644 Gu.Units.Wpf.Demo/Gu.Units.Wpf.Demo.csproj create mode 100644 Gu.Units.Wpf.Demo/MainWindow.xaml create mode 100644 Gu.Units.Wpf.Demo/MainWindow.xaml.cs create mode 100644 Gu.Units.Wpf.Demo/Properties/Annotations.cs create mode 100644 Gu.Units.Wpf.Demo/Properties/AssemblyInfo.cs create mode 100644 Gu.Units.Wpf.Demo/Properties/Resources.Designer.cs create mode 100644 Gu.Units.Wpf.Demo/Properties/Resources.resx create mode 100644 Gu.Units.Wpf.Demo/Properties/Settings.Designer.cs create mode 100644 Gu.Units.Wpf.Demo/Properties/Settings.settings create mode 100644 Gu.Units.Wpf.Demo/ViewModel.cs create mode 100644 Gu.Units.Wpf.Tests/Class1.cs create mode 100644 Gu.Units.Wpf.Tests/Gu.Units.Wpf.Tests.csproj create mode 100644 Gu.Units.Wpf.Tests/Properties/AssemblyInfo.cs create mode 100644 Gu.Units.Wpf.Tests/paket.references create mode 100644 Gu.Units.Wpf/Gu.Units.Wpf.csproj create mode 100644 Gu.Units.Wpf/LengthConverter.cs create mode 100644 Gu.Units.Wpf/Properties/AssemblyInfo.cs create mode 100644 Gu.Units/AccelerationUnitTypeConverter.generated.cs create mode 100644 Gu.Units/AngleUnitTypeConverter.generated.cs create mode 100644 Gu.Units/AngularAccelerationUnitTypeConverter.generated.cs create mode 100644 Gu.Units/AngularJerkUnitTypeConverter.generated.cs create mode 100644 Gu.Units/AngularSpeedUnitTypeConverter.generated.cs create mode 100644 Gu.Units/AreaUnitTypeConverter.generated.cs create mode 100644 Gu.Units/CapacitanceUnitTypeConverter.generated.cs create mode 100644 Gu.Units/CurrentUnitTypeConverter.generated.cs create mode 100644 Gu.Units/DensityUnitTypeConverter.generated.cs create mode 100644 Gu.Units/ElectricChargeUnitTypeConverter.generated.cs create mode 100644 Gu.Units/EnergyUnitTypeConverter.generated.cs create mode 100644 Gu.Units/FlexibilityUnitTypeConverter.generated.cs create mode 100644 Gu.Units/ForceUnitTypeConverter.generated.cs create mode 100644 Gu.Units/FrequencyUnitTypeConverter.generated.cs create mode 100644 Gu.Units/InductanceUnitTypeConverter.generated.cs create mode 100644 Gu.Units/JerkUnitTypeConverter.generated.cs create mode 100644 Gu.Units/LengthUnitTypeConverter.generated.cs create mode 100644 Gu.Units/LuminousIntensityUnitTypeConverter.generated.cs create mode 100644 Gu.Units/MassUnitTypeConverter.generated.cs create mode 100644 Gu.Units/PowerUnitTypeConverter.generated.cs create mode 100644 Gu.Units/PressureUnitTypeConverter.generated.cs rename Gu.Units/{TypeConverterGenerator.txt4 => QuantityTypeConverterGenerator.txt4} (100%) create mode 100644 Gu.Units/ResistanceUnitTypeConverter.generated.cs create mode 100644 Gu.Units/SpecificEnergyUnitTypeConverter.generated.cs create mode 100644 Gu.Units/SpeedUnitTypeConverter.generated.cs create mode 100644 Gu.Units/StiffnessUnitTypeConverter.generated.cs create mode 100644 Gu.Units/TemperatureUnitTypeConverter.generated.cs create mode 100644 Gu.Units/TimeUnitTypeConverter.generated.cs create mode 100644 Gu.Units/TorqueUnitTypeConverter.generated.cs create mode 100644 Gu.Units/UnitTypeConverterGenerator.txt4 create mode 100644 Gu.Units/UnitlessUnitTypeConverter.generated.cs create mode 100644 Gu.Units/VoltageUnitTypeConverter.generated.cs create mode 100644 Gu.Units/VolumeUnitTypeConverter.generated.cs create mode 100644 Gu.Units/VolumetricFlowUnitTypeConverter.generated.cs diff --git a/Gu.Units.Generator/Gu.Units.Generator.csproj b/Gu.Units.Generator/Gu.Units.Generator.csproj index bde7156e..6a319973 100644 --- a/Gu.Units.Generator/Gu.Units.Generator.csproj +++ b/Gu.Units.Generator/Gu.Units.Generator.csproj @@ -142,6 +142,24 @@ Settings.settings True + + TextTemplatingFileGenerator + UnitTypeConverter.txt + + + True + True + UnitTypeConverterGenerator.tt + + + True + True + UnitTypeConverter.tt + + + TextTemplatingFileGenerator + UnitTypeConverterGenerator.txt + ResXFileCodeGenerator Resources.Designer.cs @@ -153,40 +171,40 @@ Settings.Designer.cs - + TextTemplatingFileGenerator Enumerable.txt - - + + TextTemplatingFileGenerator EnumerableGenerator.txt - - + + TextTemplatingFileGenerator - TypeConverterGenerator.txt - - + QuantityTypeConverterGenerator.txt + + True True - TypeConverterGenerator.tt + QuantityTypeConverterGenerator.tt - + Code TextTemplatingFileGenerator UnitGenerator.txt - - + + TextTemplatingFileGenerator Quantity.txt - - + + TextTemplatingFileGenerator QuantityGenerator.txt - - + + TextTemplatingFileGenerator Unit.txt - + @@ -207,14 +225,14 @@ - + TextTemplatingFileGenerator - TypeConverter.txt - - + QuantityTypeConverter.txt + + True True - TypeConverter.tt + QuantityTypeConverter.tt True diff --git a/Gu.Units.Generator/Templates/EnumerableGenerator.tt b/Gu.Units.Generator/Templates/EnumerableGenerator.tt index 15ae0843..6fe0f60d 100644 --- a/Gu.Units.Generator/Templates/EnumerableGenerator.tt +++ b/Gu.Units.Generator/Templates/EnumerableGenerator.tt @@ -1,5 +1,5 @@ <#@ template debug="false" hostspecific="true" language="C#" #> -<#@ include file="$(SolutionDir)\Packages\T4.TemplateFileManager\tools\ttinc\TemplateFilemanager.CS.ttinclude" #> +<#@ include file="$(SolutionDir)Packages\T4.TemplateFileManager\tools\ttinc\TemplateFilemanager.CS.ttinclude" #> <#@ output extension=".txt" #> <#@ assembly name="System.Core" #> <#@ assembly name="$(TargetPath)" #> diff --git a/Gu.Units.Generator/Templates/EnumerableGenerator.txt b/Gu.Units.Generator/Templates/EnumerableGenerator.txt index 2edc99e3..af60e609 100644 --- a/Gu.Units.Generator/Templates/EnumerableGenerator.txt +++ b/Gu.Units.Generator/Templates/EnumerableGenerator.txt @@ -1 +1,7 @@ -ErrorGeneratingOutput \ No newline at end of file + +Read Settings found 32 quantities +//-> Enumerable.generated.cs +// Generated helper templates +// Gu.Units\Gu.Units\EnumerableGenerator.txt4 +// Generated items +// Gu.Units\Gu.Units\Enumerable.generated.cs diff --git a/Gu.Units.Generator/Templates/QuantityGenerator.tt b/Gu.Units.Generator/Templates/QuantityGenerator.tt index c79a2cc2..8c8229dd 100644 --- a/Gu.Units.Generator/Templates/QuantityGenerator.tt +++ b/Gu.Units.Generator/Templates/QuantityGenerator.tt @@ -1,5 +1,5 @@ <#@ template debug="false" hostspecific="true" language="C#" #> -<#@ include file="$(SolutionDir)\Packages\T4.TemplateFileManager\tools\ttinc\TemplateFilemanager.CS.ttinclude" #> +<#@ include file="$(SolutionDir)Packages\T4.TemplateFileManager\tools\ttinc\TemplateFilemanager.CS.ttinclude" #> <#@ output extension=".txt" #> <#@ assembly name="System.Core" #> <#@ assembly name="$(TargetPath)" #> @@ -19,7 +19,7 @@ fileManager.CanOverwriteExistingFile = true; var paramTmpl = ParamTextTemplate.Create(this.Host); var session = ParamTextTemplate.GetSessionObject(); var settings = Settings.Instance; -this.Write(string.Format("Read Settings found {0} units", settings.Quantities.Count())); +this.Write(string.Format("Read Settings and found {0} units", settings.Quantities.Count())); foreach (var quantity in settings.Quantities) { fileManager.StartNewFile(quantity.ClassName + ".generated." + Settings.Extension , Settings.ProjectName, null, null); diff --git a/Gu.Units.Generator/Templates/QuantityGenerator.txt b/Gu.Units.Generator/Templates/QuantityGenerator.txt index 2edc99e3..20e07f44 100644 --- a/Gu.Units.Generator/Templates/QuantityGenerator.txt +++ b/Gu.Units.Generator/Templates/QuantityGenerator.txt @@ -1 +1,100 @@ -ErrorGeneratingOutput \ No newline at end of file + +Read Settings and found 32 units +//-> Acceleration.generated.cs + +//-> Angle.generated.cs + +//-> AngularAcceleration.generated.cs + +//-> AngularJerk.generated.cs + +//-> AngularSpeed.generated.cs + +//-> Area.generated.cs + +//-> Capacitance.generated.cs + +//-> Current.generated.cs + +//-> Density.generated.cs + +//-> ElectricCharge.generated.cs + +//-> Energy.generated.cs + +//-> Flexibility.generated.cs + +//-> Force.generated.cs + +//-> Frequency.generated.cs + +//-> Inductance.generated.cs + +//-> Jerk.generated.cs + +//-> Length.generated.cs + +//-> LuminousIntensity.generated.cs + +//-> Mass.generated.cs + +//-> Power.generated.cs + +//-> Pressure.generated.cs + +//-> Resistance.generated.cs + +//-> SpecificEnergy.generated.cs + +//-> Speed.generated.cs + +//-> Stiffness.generated.cs + +//-> Temperature.generated.cs + +//-> Time.generated.cs + +//-> Torque.generated.cs + +//-> Unitless.generated.cs + +//-> Voltage.generated.cs + +//-> Volume.generated.cs + +//-> VolumetricFlow.generated.cs +// Generated helper templates +// Gu.Units\Gu.Units\QuantityGenerator.txt4 +// Generated items +// Gu.Units\Gu.Units\Jerk.generated.cs +// Gu.Units\Gu.Units\AngularJerk.generated.cs +// Gu.Units\Gu.Units\AngularAcceleration.generated.cs +// Gu.Units\Gu.Units\Flexibility.generated.cs +// Gu.Units\Gu.Units\Capacitance.generated.cs +// Gu.Units\Gu.Units\Inductance.generated.cs +// Gu.Units\Gu.Units\ElectricCharge.generated.cs +// Gu.Units\Gu.Units\SpecificEnergy.generated.cs +// Gu.Units\Gu.Units\Resistance.generated.cs +// Gu.Units\Gu.Units\Voltage.generated.cs +// Gu.Units\Gu.Units\VolumetricFlow.generated.cs +// Gu.Units\Gu.Units\Stiffness.generated.cs +// Gu.Units\Gu.Units\Torque.generated.cs +// Gu.Units\Gu.Units\Acceleration.generated.cs +// Gu.Units\Gu.Units\Frequency.generated.cs +// Gu.Units\Gu.Units\AngularSpeed.generated.cs +// Gu.Units\Gu.Units\Speed.generated.cs +// Gu.Units\Gu.Units\Power.generated.cs +// Gu.Units\Gu.Units\Energy.generated.cs +// Gu.Units\Gu.Units\Density.generated.cs +// Gu.Units\Gu.Units\Pressure.generated.cs +// Gu.Units\Gu.Units\Force.generated.cs +// Gu.Units\Gu.Units\Volume.generated.cs +// Gu.Units\Gu.Units\Area.generated.cs +// Gu.Units\Gu.Units\LuminousIntensity.generated.cs +// Gu.Units\Gu.Units\Current.generated.cs +// Gu.Units\Gu.Units\Unitless.generated.cs +// Gu.Units\Gu.Units\Angle.generated.cs +// Gu.Units\Gu.Units\Temperature.generated.cs +// Gu.Units\Gu.Units\Time.generated.cs +// Gu.Units\Gu.Units\Length.generated.cs +// Gu.Units\Gu.Units\Mass.generated.cs diff --git a/Gu.Units.Generator/Templates/TypeConverter.tt b/Gu.Units.Generator/Templates/QuantityTypeConverter.tt similarity index 97% rename from Gu.Units.Generator/Templates/TypeConverter.tt rename to Gu.Units.Generator/Templates/QuantityTypeConverter.tt index eb7778ba..4a56ff88 100644 --- a/Gu.Units.Generator/Templates/TypeConverter.tt +++ b/Gu.Units.Generator/Templates/QuantityTypeConverter.tt @@ -1,4 +1,4 @@ -<#@ template debug="true" hostspecific="false" language="C#" #> +<#@ template debug="false" hostspecific="false" language="C#" #> <#@ import namespace="System.Globalization" #> <#@ import namespace="System.Collections" #> <#@ import namespace="System.Collections.Generic" #> @@ -7,7 +7,7 @@ <#@ parameter name="QuantityMetaData" type="Gu.Units.Generator.Quantity" #> <#@ output extension=".txt" #> <# -// Template used by TypeConverterGenerator.tt +// Template used by QuantityTypeConverterGenerator.tt Quantity quantity = null; if(QuantityMetaData != null) { diff --git a/Gu.Units.Generator/Templates/TypeConverterGenerator.tt b/Gu.Units.Generator/Templates/QuantityTypeConverterGenerator.tt similarity index 85% rename from Gu.Units.Generator/Templates/TypeConverterGenerator.tt rename to Gu.Units.Generator/Templates/QuantityTypeConverterGenerator.tt index b9a9f148..294b9683 100644 --- a/Gu.Units.Generator/Templates/TypeConverterGenerator.tt +++ b/Gu.Units.Generator/Templates/QuantityTypeConverterGenerator.tt @@ -1,5 +1,5 @@ <#@ template debug="false" hostspecific="true" language="C#" #> -<#@ include file="$(SolutionDir)\Packages\T4.TemplateFileManager\tools\ttinc\TemplateFilemanager.CS.ttinclude" #> +<#@ include file="$(SolutionDir)Packages\T4.TemplateFileManager\tools\ttinc\TemplateFilemanager.CS.ttinclude" #> <#@ output extension=".txt" #> <#@ assembly name="System.Core" #> <#@ assembly name="$(TargetPath)" #> @@ -25,7 +25,7 @@ foreach (var quantity in settings.Quantities) var fileName = quantity.ClassName + "TypeConverter.generated." + Settings.Extension; fileManager.StartNewFile(fileName , Settings.ProjectName, null, null); session["QuantityMetaData"] = quantity; - string output = paramTmpl.TransformText("TypeConverter.tt", session); + string output = paramTmpl.TransformText("QuantityTypeConverter.tt", session); this.Write(output); } diff --git a/Gu.Units.Generator/Templates/Unit.tt b/Gu.Units.Generator/Templates/Unit.tt index e3a9cfb6..f0832596 100644 --- a/Gu.Units.Generator/Templates/Unit.tt +++ b/Gu.Units.Generator/Templates/Unit.tt @@ -1,4 +1,4 @@ -<#@ template debug="true" hostspecific="false" language="C#" #> +<#@ template debug="false" hostspecific="false" language="C#" #> <#@ import namespace="System.Globalization" #> <#@ import namespace="System.Collections" #> <#@ import namespace="System.Collections.Generic" #> diff --git a/Gu.Units.Generator/Templates/UnitGenerator.tt b/Gu.Units.Generator/Templates/UnitGenerator.tt index 87eb25d4..949f250a 100644 --- a/Gu.Units.Generator/Templates/UnitGenerator.tt +++ b/Gu.Units.Generator/Templates/UnitGenerator.tt @@ -1,5 +1,5 @@ -<#@ template debug="true" hostspecific="true" language="C#" #> -<#@ include file="$(SolutionDir)\Packages\T4.TemplateFileManager\tools\ttinc\TemplateFilemanager.CS.ttinclude" #> +<#@ template debug="false" hostspecific="true" language="C#" #> +<#@ include file="$(SolutionDir)Packages\T4.TemplateFileManager\tools\ttinc\TemplateFilemanager.CS.ttinclude" #> <#@ assembly name="System.Core" #> <#@ assembly name="$(TargetPath)" #> <#@ import namespace="Gu.Units.Generator" #> @@ -19,27 +19,19 @@ fileManager.CanOverwriteExistingFile = true; var paramTmpl = ParamTextTemplate.Create(this.Host); var session = ParamTextTemplate.GetSessionObject(); var settings = Settings.Instance; -this.Write(string.Format("Read Settings found {0} units", settings.SiUnits.Count)); +this.Write(string.Format("Read Settings and found {0} si units and {1} derived units", settings.SiUnits.Count, settings.DerivedUnits.Count)); -foreach (var unit in settings.SiUnits) +foreach (var unit in settings.SiUnits.Concat(settings.DerivedUnits)) { session["UnitMetaData"] = unit; - fileManager.StartNewFile(unit.Quantity.ClassName + "Unit.generated." + Settings.Extension, Settings.ProjectName, Settings.FolderName, null); + var fileName = unit.Quantity.ClassName + "Unit.generated." + Settings.Extension; + fileManager.StartNewFile(fileName, Settings.ProjectName, Settings.FolderName, null); var output = paramTmpl.TransformText("Unit.tt", session); this.Write(output); //this.WriteLine(); } -foreach (var unit in settings.DerivedUnits) -{ - session["UnitMetaData"] = unit; - - fileManager.StartNewFile(unit.Quantity.ClassName + "Unit.generated." + Settings.Extension, Settings.ProjectName, Settings.FolderName, null); - var output = paramTmpl.TransformText("Unit.tt", session); - this.Write(output); - //this.WriteLine(); -} //session["UnitMetaData"] = null; fileManager.Process(); #> diff --git a/Gu.Units.Generator/Templates/UnitGenerator.txt b/Gu.Units.Generator/Templates/UnitGenerator.txt index 2edc99e3..0be5c059 100644 --- a/Gu.Units.Generator/Templates/UnitGenerator.txt +++ b/Gu.Units.Generator/Templates/UnitGenerator.txt @@ -1 +1,100 @@ -ErrorGeneratingOutput \ No newline at end of file + +Read Settings and found 8 si units and 24 derived units +//-> AccelerationUnit.generated.cs + +//-> AngleUnit.generated.cs + +//-> AngularAccelerationUnit.generated.cs + +//-> AngularJerkUnit.generated.cs + +//-> AngularSpeedUnit.generated.cs + +//-> AreaUnit.generated.cs + +//-> CapacitanceUnit.generated.cs + +//-> CurrentUnit.generated.cs + +//-> DensityUnit.generated.cs + +//-> ElectricChargeUnit.generated.cs + +//-> EnergyUnit.generated.cs + +//-> FlexibilityUnit.generated.cs + +//-> ForceUnit.generated.cs + +//-> FrequencyUnit.generated.cs + +//-> InductanceUnit.generated.cs + +//-> JerkUnit.generated.cs + +//-> LengthUnit.generated.cs + +//-> LuminousIntensityUnit.generated.cs + +//-> MassUnit.generated.cs + +//-> PowerUnit.generated.cs + +//-> PressureUnit.generated.cs + +//-> ResistanceUnit.generated.cs + +//-> SpecificEnergyUnit.generated.cs + +//-> SpeedUnit.generated.cs + +//-> StiffnessUnit.generated.cs + +//-> TemperatureUnit.generated.cs + +//-> TimeUnit.generated.cs + +//-> TorqueUnit.generated.cs + +//-> UnitlessUnit.generated.cs + +//-> VoltageUnit.generated.cs + +//-> VolumetricFlowUnit.generated.cs + +//-> VolumeUnit.generated.cs +// Generated helper templates +// Gu.Units\Gu.Units\UnitGenerator.txt4 +// Generated items +// Gu.Units\Gu.Units\JerkUnit.generated.cs +// Gu.Units\Gu.Units\AngularJerkUnit.generated.cs +// Gu.Units\Gu.Units\AngularAccelerationUnit.generated.cs +// Gu.Units\Gu.Units\FlexibilityUnit.generated.cs +// Gu.Units\Gu.Units\CapacitanceUnit.generated.cs +// Gu.Units\Gu.Units\InductanceUnit.generated.cs +// Gu.Units\Gu.Units\ElectricChargeUnit.generated.cs +// Gu.Units\Gu.Units\SpecificEnergyUnit.generated.cs +// Gu.Units\Gu.Units\ResistanceUnit.generated.cs +// Gu.Units\Gu.Units\VoltageUnit.generated.cs +// Gu.Units\Gu.Units\VolumetricFlowUnit.generated.cs +// Gu.Units\Gu.Units\StiffnessUnit.generated.cs +// Gu.Units\Gu.Units\TorqueUnit.generated.cs +// Gu.Units\Gu.Units\AccelerationUnit.generated.cs +// Gu.Units\Gu.Units\FrequencyUnit.generated.cs +// Gu.Units\Gu.Units\AngularSpeedUnit.generated.cs +// Gu.Units\Gu.Units\SpeedUnit.generated.cs +// Gu.Units\Gu.Units\PowerUnit.generated.cs +// Gu.Units\Gu.Units\EnergyUnit.generated.cs +// Gu.Units\Gu.Units\DensityUnit.generated.cs +// Gu.Units\Gu.Units\PressureUnit.generated.cs +// Gu.Units\Gu.Units\ForceUnit.generated.cs +// Gu.Units\Gu.Units\VolumeUnit.generated.cs +// Gu.Units\Gu.Units\AreaUnit.generated.cs +// Gu.Units\Gu.Units\LuminousIntensityUnit.generated.cs +// Gu.Units\Gu.Units\CurrentUnit.generated.cs +// Gu.Units\Gu.Units\UnitlessUnit.generated.cs +// Gu.Units\Gu.Units\AngleUnit.generated.cs +// Gu.Units\Gu.Units\TemperatureUnit.generated.cs +// Gu.Units\Gu.Units\TimeUnit.generated.cs +// Gu.Units\Gu.Units\LengthUnit.generated.cs +// Gu.Units\Gu.Units\MassUnit.generated.cs diff --git a/Gu.Units.Generator/Templates/UnitTypeConverter.tt b/Gu.Units.Generator/Templates/UnitTypeConverter.tt new file mode 100644 index 00000000..bb13a0ea --- /dev/null +++ b/Gu.Units.Generator/Templates/UnitTypeConverter.tt @@ -0,0 +1,113 @@ +<#@ template debug="false" hostspecific="false" language="C#" #> +<#@ import namespace="System.Globalization" #> +<#@ import namespace="System.Collections" #> +<#@ import namespace="System.Collections.Generic" #> +<#@ assembly name="$(TargetPath)" #> +<#@ import namespace="Gu.Units.Generator" #> +<#@ parameter name="UnitMetaData" type="Gu.Units.Generator.IUnit" #> +<#@ output extension=".txt" #> +<# +// Template used by UnitTypeConverterGenerator.tt +IUnit unit; +if(UnitMetaData != null) +{ + unit = UnitMetaData; +} +else +{ + unit = new SiUnit("Metres", "m") + { + QuantityName = "Length" + }; + unit.Conversions.Add(new Conversion("Centimetres", "cm")); + unit.Conversions.Add(new Conversion("Millimetres", "mm")); +} +#> +namespace <#= Settings.Namespace #> +{ + using System; + using System.ComponentModel; + using System.ComponentModel.Design.Serialization; + using System.Globalization; + using System.Reflection; + + /// + /// Provides a type converter to convert + /// objects to and from various + /// other representations. + /// + public class <#= unit.UnitName #>TypeConverter : TypeConverter + { + /// + /// Gets a value indicating whether this converter can + /// convert an object in the given source type to a object using the + /// specified context. + /// + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) + { + if (sourceType == typeof(string)) + { + return true; + } + + return base.CanConvertFrom(context, sourceType); + } + + /// + /// Gets a value indicating whether this converter can + /// convert an object to the given destination type using the context. + /// + public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) + { + if (destinationType == typeof(InstanceDescriptor)) + { + return true; + } + + return base.CanConvertTo(context, destinationType); + } + + /// + /// Converts the given object to a + /// object. + /// + public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) + { + var text = value as string; + if (text != null) + { + text = text.Trim(); + return <#= unit.UnitName #>.Parse(text); + } + + return base.ConvertFrom(context, culture, value); + } + + /// + /// Converts the given object to another type. The most common types to convert + /// are to and from a string object. The default implementation will make a call + /// to ToString on the object if the object is valid and if the destination + /// type is string. If this cannot convert to the type, this will + /// throw a NotSupportedException. + /// + public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) + { + if (destinationType == null) + { + throw new ArgumentNullException(nameof(destinationType)); + } + + if (destinationType == typeof(InstanceDescriptor) && value is <#= unit.UnitName #>) + { + MethodInfo method = typeof(<#= unit.UnitName #>).GetMethod(nameof(<#= unit.UnitName #>.Parse), new Type[] { typeof(string) }); + if (method != null) + { + var args = new object[] { ((<#= unit.UnitName #>)value).Symbol }; + return new InstanceDescriptor(method, args); + } + } + + return base.ConvertTo(context, culture, value, destinationType); + } + } +} \ No newline at end of file diff --git a/Gu.Units.Generator/Templates/UnitTypeConverterGenerator.tt b/Gu.Units.Generator/Templates/UnitTypeConverterGenerator.tt new file mode 100644 index 00000000..61452bb2 --- /dev/null +++ b/Gu.Units.Generator/Templates/UnitTypeConverterGenerator.tt @@ -0,0 +1,37 @@ +<#@ template debug="false" hostspecific="true" language="C#" #> +<#@ include file="$(SolutionDir)Packages\T4.TemplateFileManager\tools\ttinc\TemplateFilemanager.CS.ttinclude" #> +<#@ assembly name="System.Core" #> +<#@ assembly name="$(TargetPath)" #> +<#@ import namespace="Gu.Units.Generator" #> +<#@ import namespace="System.Linq" #> +<#@ output extension=".txt" #> +<# +// after save Generator.tt, the output will be generated in the TestFolder of the project +// var fileProperties = new FileProperties() +// { +// BuildAction = BuildAction.EmbeddedResource +// }; + +var fileManager = TemplateFileManager.Create(this); +fileManager.IsAutoIndentEnabled = true; +fileManager.CanOverwriteExistingFile = true; + +// init handling for parameter templates +var paramTmpl = ParamTextTemplate.Create(this.Host); +var session = ParamTextTemplate.GetSessionObject(); +var settings = Settings.Instance; +this.Write(string.Format("Read Settings found {0} units", settings.SiUnits.Count)); + +foreach (var unit in settings.SiUnits.Concat(settings.DerivedUnits)) +{ + session["UnitMetaData"] = unit; + + fileManager.StartNewFile(unit.UnitName + "TypeConverter.generated." + Settings.Extension, Settings.ProjectName, Settings.FolderName, null); + var output = paramTmpl.TransformText("UnitTypeConverter.tt", session); + this.Write(output); + //this.WriteLine(); +} + +//session["UnitMetaData"] = null; +fileManager.Process(); +#> diff --git a/Gu.Units.Wpf.Demo/App.config b/Gu.Units.Wpf.Demo/App.config new file mode 100644 index 00000000..8e156463 --- /dev/null +++ b/Gu.Units.Wpf.Demo/App.config @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/Gu.Units.Wpf.Demo/App.xaml b/Gu.Units.Wpf.Demo/App.xaml new file mode 100644 index 00000000..c74bc2cb --- /dev/null +++ b/Gu.Units.Wpf.Demo/App.xaml @@ -0,0 +1,9 @@ + + + + + diff --git a/Gu.Units.Wpf.Demo/App.xaml.cs b/Gu.Units.Wpf.Demo/App.xaml.cs new file mode 100644 index 00000000..6829f58f --- /dev/null +++ b/Gu.Units.Wpf.Demo/App.xaml.cs @@ -0,0 +1,11 @@ +namespace Gu.Units.Wpf.Demo +{ + using System.Windows; + + /// + /// Interaction logic for App.xaml + /// + public partial class App : Application + { + } +} diff --git a/Gu.Units.Wpf.Demo/Gu.Units.Wpf.Demo.csproj b/Gu.Units.Wpf.Demo/Gu.Units.Wpf.Demo.csproj new file mode 100644 index 00000000..3d525787 --- /dev/null +++ b/Gu.Units.Wpf.Demo/Gu.Units.Wpf.Demo.csproj @@ -0,0 +1,111 @@ + + + + + Debug + AnyCPU + {8CB38BA2-254B-4B0F-9C9F-57D17DE5D8B5} + WinExe + Properties + Gu.Units.Wpf.Demo + Gu.Units.Wpf.Demo + v4.5 + 512 + {60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + 4 + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + 4.0 + + + + + + + + + MSBuild:Compile + Designer + + + + MSBuild:Compile + Designer + + + App.xaml + Code + + + MainWindow.xaml + Code + + + + + + Code + + + True + True + Resources.resx + + + True + Settings.settings + True + + + ResXFileCodeGenerator + Resources.Designer.cs + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + + + + + + + {ea4bce51-a58d-4fa7-bba4-6f0056d753ca} + Gu.Units.Wpf + + + {f1f8b138-becc-4475-a7ab-b3019338bc7b} + Gu.Units + + + + + \ No newline at end of file diff --git a/Gu.Units.Wpf.Demo/MainWindow.xaml b/Gu.Units.Wpf.Demo/MainWindow.xaml new file mode 100644 index 00000000..8b1ab3a1 --- /dev/null +++ b/Gu.Units.Wpf.Demo/MainWindow.xaml @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + diff --git a/Gu.Units.Wpf.Demo/MainWindow.xaml.cs b/Gu.Units.Wpf.Demo/MainWindow.xaml.cs new file mode 100644 index 00000000..d7d5cc22 --- /dev/null +++ b/Gu.Units.Wpf.Demo/MainWindow.xaml.cs @@ -0,0 +1,15 @@ +namespace Gu.Units.Wpf.Demo +{ + using System.Windows; + + /// + /// Interaction logic for MainWindow.xaml + /// + public partial class MainWindow : Window + { + public MainWindow() + { + InitializeComponent(); + } + } +} diff --git a/Gu.Units.Wpf.Demo/Properties/Annotations.cs b/Gu.Units.Wpf.Demo/Properties/Annotations.cs new file mode 100644 index 00000000..ffe4a389 --- /dev/null +++ b/Gu.Units.Wpf.Demo/Properties/Annotations.cs @@ -0,0 +1,996 @@ +using System; + +#pragma warning disable 1591 +// ReSharper disable UnusedMember.Global +// ReSharper disable MemberCanBePrivate.Global +// ReSharper disable UnusedAutoPropertyAccessor.Global +// ReSharper disable IntroduceOptionalParameters.Global +// ReSharper disable MemberCanBeProtected.Global +// ReSharper disable InconsistentNaming + +namespace Gu.Units.Wpf.Demo.Annotations +{ + /// + /// Indicates that the value of the marked element could be null sometimes, + /// so the check for null is necessary before its usage. + /// + /// + /// [CanBeNull] object Test() => null; + /// + /// void UseTest() { + /// var p = Test(); + /// var s = p.ToString(); // Warning: Possible 'System.NullReferenceException' + /// } + /// + [AttributeUsage( + AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property | + AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event)] + public sealed class CanBeNullAttribute : Attribute { } + + /// + /// Indicates that the value of the marked element could never be null. + /// + /// + /// [NotNull] object Foo() { + /// return null; // Warning: Possible 'null' assignment + /// } + /// + [AttributeUsage( + AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property | + AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event)] + public sealed class NotNullAttribute : Attribute { } + + /// + /// Can be appplied to symbols of types derived from IEnumerable as well as to symbols of Task + /// and Lazy classes to indicate that the value of a collection item, of the Task.Result property + /// or of the Lazy.Value property can never be null. + /// + [AttributeUsage( + AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property | + AttributeTargets.Delegate | AttributeTargets.Field)] + public sealed class ItemNotNullAttribute : Attribute { } + + /// + /// Can be appplied to symbols of types derived from IEnumerable as well as to symbols of Task + /// and Lazy classes to indicate that the value of a collection item, of the Task.Result property + /// or of the Lazy.Value property can be null. + /// + [AttributeUsage( + AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property | + AttributeTargets.Delegate | AttributeTargets.Field)] + public sealed class ItemCanBeNullAttribute : Attribute { } + + /// + /// Indicates that the marked method builds string by format pattern and (optional) arguments. + /// Parameter, which contains format string, should be given in constructor. The format string + /// should be in -like form. + /// + /// + /// [StringFormatMethod("message")] + /// void ShowError(string message, params object[] args) { /* do something */ } + /// + /// void Foo() { + /// ShowError("Failed: {0}"); // Warning: Non-existing argument in format string + /// } + /// + [AttributeUsage( + AttributeTargets.Constructor | AttributeTargets.Method | + AttributeTargets.Property | AttributeTargets.Delegate)] + public sealed class StringFormatMethodAttribute : Attribute + { + /// + /// Specifies which parameter of an annotated method should be treated as format-string + /// + public StringFormatMethodAttribute(string formatParameterName) + { + FormatParameterName = formatParameterName; + } + + public string FormatParameterName { get; private set; } + } + + /// + /// For a parameter that is expected to be one of the limited set of values. + /// Specify fields of which type should be used as values for this parameter. + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Field)] + public sealed class ValueProviderAttribute : Attribute + { + public ValueProviderAttribute(string name) + { + Name = name; + } + + [NotNull] public string Name { get; private set; } + } + + /// + /// Indicates that the function argument should be string literal and match one + /// of the parameters of the caller function. For example, ReSharper annotates + /// the parameter of . + /// + /// + /// void Foo(string param) { + /// if (param == null) + /// throw new ArgumentNullException("par"); // Warning: Cannot resolve symbol + /// } + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class InvokerParameterNameAttribute : Attribute { } + + /// + /// Indicates that the method is contained in a type that implements + /// System.ComponentModel.INotifyPropertyChanged interface and this method + /// is used to notify that some property value changed. + /// + /// + /// The method should be non-static and conform to one of the supported signatures: + /// + /// NotifyChanged(string) + /// NotifyChanged(params string[]) + /// NotifyChanged{T}(Expression{Func{T}}) + /// NotifyChanged{T,U}(Expression{Func{T,U}}) + /// SetProperty{T}(ref T, T, string) + /// + /// + /// + /// public class Foo : INotifyPropertyChanged { + /// public event PropertyChangedEventHandler PropertyChanged; + /// + /// [NotifyPropertyChangedInvocator] + /// protected virtual void NotifyChanged(string propertyName) { ... } + /// + /// string _name; + /// + /// public string Name { + /// get { return _name; } + /// set { _name = value; NotifyChanged("LastName"); /* Warning */ } + /// } + /// } + /// + /// Examples of generated notifications: + /// + /// NotifyChanged("Property") + /// NotifyChanged(() => Property) + /// NotifyChanged((VM x) => x.Property) + /// SetProperty(ref myField, value, "Property") + /// + /// + [AttributeUsage(AttributeTargets.Method)] + public sealed class NotifyPropertyChangedInvocatorAttribute : Attribute + { + public NotifyPropertyChangedInvocatorAttribute() { } + public NotifyPropertyChangedInvocatorAttribute(string parameterName) + { + ParameterName = parameterName; + } + + public string ParameterName { get; private set; } + } + + /// + /// Describes dependency between method input and output. + /// + /// + ///

Function Definition Table syntax:

+ /// + /// FDT ::= FDTRow [;FDTRow]* + /// FDTRow ::= Input => Output | Output <= Input + /// Input ::= ParameterName: Value [, Input]* + /// Output ::= [ParameterName: Value]* {halt|stop|void|nothing|Value} + /// Value ::= true | false | null | notnull | canbenull + /// + /// If method has single input parameter, it's name could be omitted.
+ /// Using halt (or void/nothing, which is the same) + /// for method output means that the methos doesn't return normally.
+ /// canbenull annotation is only applicable for output parameters.
+ /// You can use multiple [ContractAnnotation] for each FDT row, + /// or use single attribute with rows separated by semicolon.
+ /// + /// + /// + /// [ContractAnnotation("=> halt")] + /// public void TerminationMethod() + /// + /// + /// [ContractAnnotation("halt <= condition: false")] + /// public void Assert(bool condition, string text) // regular assertion method + /// + /// + /// [ContractAnnotation("s:null => true")] + /// public bool IsNullOrEmpty(string s) // string.IsNullOrEmpty() + /// + /// + /// // A method that returns null if the parameter is null, + /// // and not null if the parameter is not null + /// [ContractAnnotation("null => null; notnull => notnull")] + /// public object Transform(object data) + /// + /// + /// [ContractAnnotation("s:null=>false; =>true,result:notnull; =>false, result:null")] + /// public bool TryParse(string s, out Person result) + /// + /// + [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)] + public sealed class ContractAnnotationAttribute : Attribute + { + public ContractAnnotationAttribute([NotNull] string contract) + : this(contract, false) { } + + public ContractAnnotationAttribute([NotNull] string contract, bool forceFullStates) + { + Contract = contract; + ForceFullStates = forceFullStates; + } + + public string Contract { get; private set; } + public bool ForceFullStates { get; private set; } + } + + /// + /// Indicates that marked element should be localized or not. + /// + /// + /// [LocalizationRequiredAttribute(true)] + /// class Foo { + /// string str = "my string"; // Warning: Localizable string + /// } + /// + [AttributeUsage(AttributeTargets.All)] + public sealed class LocalizationRequiredAttribute : Attribute + { + public LocalizationRequiredAttribute() : this(true) { } + public LocalizationRequiredAttribute(bool required) + { + Required = required; + } + + public bool Required { get; private set; } + } + + /// + /// Indicates that the value of the marked type (or its derivatives) + /// cannot be compared using '==' or '!=' operators and Equals() + /// should be used instead. However, using '==' or '!=' for comparison + /// with null is always permitted. + /// + /// + /// [CannotApplyEqualityOperator] + /// class NoEquality { } + /// + /// class UsesNoEquality { + /// void Test() { + /// var ca1 = new NoEquality(); + /// var ca2 = new NoEquality(); + /// if (ca1 != null) { // OK + /// bool condition = ca1 == ca2; // Warning + /// } + /// } + /// } + /// + [AttributeUsage(AttributeTargets.Interface | AttributeTargets.Class | AttributeTargets.Struct)] + public sealed class CannotApplyEqualityOperatorAttribute : Attribute { } + + /// + /// When applied to a target attribute, specifies a requirement for any type marked + /// with the target attribute to implement or inherit specific type or types. + /// + /// + /// [BaseTypeRequired(typeof(IComponent)] // Specify requirement + /// class ComponentAttribute : Attribute { } + /// + /// [Component] // ComponentAttribute requires implementing IComponent interface + /// class MyComponent : IComponent { } + /// + [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)] + [BaseTypeRequired(typeof(Attribute))] + public sealed class BaseTypeRequiredAttribute : Attribute + { + public BaseTypeRequiredAttribute([NotNull] Type baseType) + { + BaseType = baseType; + } + + [NotNull] public Type BaseType { get; private set; } + } + + /// + /// Indicates that the marked symbol is used implicitly (e.g. via reflection, in external library), + /// so this symbol will not be marked as unused (as well as by other usage inspections). + /// + [AttributeUsage(AttributeTargets.All)] + public sealed class UsedImplicitlyAttribute : Attribute + { + public UsedImplicitlyAttribute() + : this(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Default) { } + + public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags) + : this(useKindFlags, ImplicitUseTargetFlags.Default) { } + + public UsedImplicitlyAttribute(ImplicitUseTargetFlags targetFlags) + : this(ImplicitUseKindFlags.Default, targetFlags) { } + + public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags) + { + UseKindFlags = useKindFlags; + TargetFlags = targetFlags; + } + + public ImplicitUseKindFlags UseKindFlags { get; private set; } + public ImplicitUseTargetFlags TargetFlags { get; private set; } + } + + /// + /// Should be used on attributes and causes ReSharper to not mark symbols marked with such attributes + /// as unused (as well as by other usage inspections) + /// + [AttributeUsage(AttributeTargets.Class | AttributeTargets.GenericParameter)] + public sealed class MeansImplicitUseAttribute : Attribute + { + public MeansImplicitUseAttribute() + : this(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Default) { } + + public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags) + : this(useKindFlags, ImplicitUseTargetFlags.Default) { } + + public MeansImplicitUseAttribute(ImplicitUseTargetFlags targetFlags) + : this(ImplicitUseKindFlags.Default, targetFlags) { } + + public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags) + { + UseKindFlags = useKindFlags; + TargetFlags = targetFlags; + } + + [UsedImplicitly] public ImplicitUseKindFlags UseKindFlags { get; private set; } + [UsedImplicitly] public ImplicitUseTargetFlags TargetFlags { get; private set; } + } + + [Flags] + public enum ImplicitUseKindFlags + { + Default = Access | Assign | InstantiatedWithFixedConstructorSignature, + /// Only entity marked with attribute considered used. + Access = 1, + /// Indicates implicit assignment to a member. + Assign = 2, + /// + /// Indicates implicit instantiation of a type with fixed constructor signature. + /// That means any unused constructor parameters won't be reported as such. + /// + InstantiatedWithFixedConstructorSignature = 4, + /// Indicates implicit instantiation of a type. + InstantiatedNoFixedConstructorSignature = 8, + } + + /// + /// Specify what is considered used implicitly when marked + /// with or . + /// + [Flags] + public enum ImplicitUseTargetFlags + { + Default = Itself, + Itself = 1, + /// Members of entity marked with attribute are considered used. + Members = 2, + /// Entity marked with attribute and all its members considered used. + WithMembers = Itself | Members + } + + /// + /// This attribute is intended to mark publicly available API + /// which should not be removed and so is treated as used. + /// + [MeansImplicitUse(ImplicitUseTargetFlags.WithMembers)] + public sealed class PublicAPIAttribute : Attribute + { + public PublicAPIAttribute() { } + public PublicAPIAttribute([NotNull] string comment) + { + Comment = comment; + } + + public string Comment { get; private set; } + } + + /// + /// Tells code analysis engine if the parameter is completely handled when the invoked method is on stack. + /// If the parameter is a delegate, indicates that delegate is executed while the method is executed. + /// If the parameter is an enumerable, indicates that it is enumerated while the method is executed. + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class InstantHandleAttribute : Attribute { } + + /// + /// Indicates that a method does not make any observable state changes. + /// The same as System.Diagnostics.Contracts.PureAttribute. + /// + /// + /// [Pure] int Multiply(int x, int y) => x * y; + /// + /// void M() { + /// Multiply(123, 42); // Waring: Return value of pure method is not used + /// } + /// + [AttributeUsage(AttributeTargets.Method)] + public sealed class PureAttribute : Attribute { } + + /// + /// Indicates that the return value of method invocation must be used. + /// + [AttributeUsage(AttributeTargets.Method)] + public sealed class MustUseReturnValueAttribute : Attribute + { + public MustUseReturnValueAttribute() { } + public MustUseReturnValueAttribute([NotNull] string justification) + { + Justification = justification; + } + + public string Justification { get; private set; } + } + + /// + /// Indicates the type member or parameter of some type, that should be used instead of all other ways + /// to get the value that type. This annotation is useful when you have some "context" value evaluated + /// and stored somewhere, meaning that all other ways to get this value must be consolidated with existing one. + /// + /// + /// class Foo { + /// [ProvidesContext] IBarService _barService = ...; + /// + /// void ProcessNode(INode node) { + /// DoSomething(node, node.GetGlobalServices().Bar); + /// // ^ Warning: use value of '_barService' field + /// } + /// } + /// + [AttributeUsage( + AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Parameter | + AttributeTargets.Method)] + public sealed class ProvidesContextAttribute : Attribute { } + + /// + /// Indicates that a parameter is a path to a file or a folder within a web project. + /// Path can be relative or absolute, starting from web root (~). + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class PathReferenceAttribute : Attribute + { + public PathReferenceAttribute() { } + public PathReferenceAttribute([PathReference] string basePath) + { + BasePath = basePath; + } + + public string BasePath { get; private set; } + } + + /// + /// An extension method marked with this attribute is processed by ReSharper code completion + /// as a 'Source Template'. When extension method is completed over some expression, it's source code + /// is automatically expanded like a template at call site. + /// + /// + /// Template method body can contain valid source code and/or special comments starting with '$'. + /// Text inside these comments is added as source code when the template is applied. Template parameters + /// can be used either as additional method parameters or as identifiers wrapped in two '$' signs. + /// Use the attribute to specify macros for parameters. + /// + /// + /// In this example, the 'forEach' method is a source template available over all values + /// of enumerable types, producing ordinary C# 'foreach' statement and placing caret inside block: + /// + /// [SourceTemplate] + /// public static void forEach<T>(this IEnumerable<T> xs) { + /// foreach (var x in xs) { + /// //$ $END$ + /// } + /// } + /// + /// + [AttributeUsage(AttributeTargets.Method)] + public sealed class SourceTemplateAttribute : Attribute { } + + /// + /// Allows specifying a macro for a parameter of a source template. + /// + /// + /// You can apply the attribute on the whole method or on any of its additional parameters. The macro expression + /// is defined in the property. When applied on a method, the target + /// template parameter is defined in the property. To apply the macro silently + /// for the parameter, set the property value = -1. + /// + /// + /// Applying the attribute on a source template method: + /// + /// [SourceTemplate, Macro(Target = "item", Expression = "suggestVariableName()")] + /// public static void forEach<T>(this IEnumerable<T> collection) { + /// foreach (var item in collection) { + /// //$ $END$ + /// } + /// } + /// + /// Applying the attribute on a template method parameter: + /// + /// [SourceTemplate] + /// public static void something(this Entity x, [Macro(Expression = "guid()", Editable = -1)] string newguid) { + /// /*$ var $x$Id = "$newguid$" + x.ToString(); + /// x.DoSomething($x$Id); */ + /// } + /// + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method, AllowMultiple = true)] + public sealed class MacroAttribute : Attribute + { + /// + /// Allows specifying a macro that will be executed for a source template + /// parameter when the template is expanded. + /// + public string Expression { get; set; } + + /// + /// Allows specifying which occurrence of the target parameter becomes editable when the template is deployed. + /// + /// + /// If the target parameter is used several times in the template, only one occurrence becomes editable; + /// other occurrences are changed synchronously. To specify the zero-based index of the editable occurrence, + /// use values >= 0. To make the parameter non-editable when the template is expanded, use -1. + /// > + public int Editable { get; set; } + + /// + /// Identifies the target parameter of a source template if the + /// is applied on a template method. + /// + public string Target { get; set; } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + public sealed class AspMvcAreaMasterLocationFormatAttribute : Attribute + { + public AspMvcAreaMasterLocationFormatAttribute(string format) + { + Format = format; + } + + public string Format { get; private set; } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + public sealed class AspMvcAreaPartialViewLocationFormatAttribute : Attribute + { + public AspMvcAreaPartialViewLocationFormatAttribute(string format) + { + Format = format; + } + + public string Format { get; private set; } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + public sealed class AspMvcAreaViewLocationFormatAttribute : Attribute + { + public AspMvcAreaViewLocationFormatAttribute(string format) + { + Format = format; + } + + public string Format { get; private set; } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + public sealed class AspMvcMasterLocationFormatAttribute : Attribute + { + public AspMvcMasterLocationFormatAttribute(string format) + { + Format = format; + } + + public string Format { get; private set; } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + public sealed class AspMvcPartialViewLocationFormatAttribute : Attribute + { + public AspMvcPartialViewLocationFormatAttribute(string format) + { + Format = format; + } + + public string Format { get; private set; } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + public sealed class AspMvcViewLocationFormatAttribute : Attribute + { + public AspMvcViewLocationFormatAttribute(string format) + { + Format = format; + } + + public string Format { get; private set; } + } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter + /// is an MVC action. If applied to a method, the MVC action name is calculated + /// implicitly from the context. Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)] + public sealed class AspMvcActionAttribute : Attribute + { + public AspMvcActionAttribute() { } + public AspMvcActionAttribute(string anonymousProperty) + { + AnonymousProperty = anonymousProperty; + } + + public string AnonymousProperty { get; private set; } + } + + /// + /// ASP.NET MVC attribute. Indicates that a parameter is an MVC area. + /// Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String). + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class AspMvcAreaAttribute : Attribute + { + public AspMvcAreaAttribute() { } + public AspMvcAreaAttribute(string anonymousProperty) + { + AnonymousProperty = anonymousProperty; + } + + public string AnonymousProperty { get; private set; } + } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is + /// an MVC controller. If applied to a method, the MVC controller name is calculated + /// implicitly from the context. Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String, String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)] + public sealed class AspMvcControllerAttribute : Attribute + { + public AspMvcControllerAttribute() { } + public AspMvcControllerAttribute(string anonymousProperty) + { + AnonymousProperty = anonymousProperty; + } + + public string AnonymousProperty { get; private set; } + } + + /// + /// ASP.NET MVC attribute. Indicates that a parameter is an MVC Master. Use this attribute + /// for custom wrappers similar to System.Web.Mvc.Controller.View(String, String). + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class AspMvcMasterAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. Indicates that a parameter is an MVC model type. Use this attribute + /// for custom wrappers similar to System.Web.Mvc.Controller.View(String, Object). + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class AspMvcModelTypeAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is an MVC + /// partial view. If applied to a method, the MVC partial view name is calculated implicitly + /// from the context. Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Html.RenderPartialExtensions.RenderPartial(HtmlHelper, String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)] + public sealed class AspMvcPartialViewAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. Allows disabling inspections for MVC views within a class or a method. + /// + [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)] + public sealed class AspMvcSuppressViewErrorAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. Indicates that a parameter is an MVC display template. + /// Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Html.DisplayExtensions.DisplayForModel(HtmlHelper, String). + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class AspMvcDisplayTemplateAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. Indicates that a parameter is an MVC editor template. + /// Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Html.EditorExtensions.EditorForModel(HtmlHelper, String). + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class AspMvcEditorTemplateAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. Indicates that a parameter is an MVC template. + /// Use this attribute for custom wrappers similar to + /// System.ComponentModel.DataAnnotations.UIHintAttribute(System.String). + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class AspMvcTemplateAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter + /// is an MVC view component. If applied to a method, the MVC view name is calculated implicitly + /// from the context. Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Controller.View(Object). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)] + public sealed class AspMvcViewAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter + /// is an MVC view component name. + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class AspMvcViewComponentAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter + /// is an MVC view component view. If applied to a method, the MVC view component view name is default. + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)] + public sealed class AspMvcViewComponentViewAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. When applied to a parameter of an attribute, + /// indicates that this parameter is an MVC action name. + /// + /// + /// [ActionName("Foo")] + /// public ActionResult Login(string returnUrl) { + /// ViewBag.ReturnUrl = Url.Action("Foo"); // OK + /// return RedirectToAction("Bar"); // Error: Cannot resolve action + /// } + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property)] + public sealed class AspMvcActionSelectorAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Field)] + public sealed class HtmlElementAttributesAttribute : Attribute + { + public HtmlElementAttributesAttribute() { } + public HtmlElementAttributesAttribute(string name) + { + Name = name; + } + + public string Name { get; private set; } + } + + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)] + public sealed class HtmlAttributeValueAttribute : Attribute + { + public HtmlAttributeValueAttribute([NotNull] string name) + { + Name = name; + } + + [NotNull] public string Name { get; private set; } + } + + /// + /// Razor attribute. Indicates that a parameter or a method is a Razor section. + /// Use this attribute for custom wrappers similar to + /// System.Web.WebPages.WebPageBase.RenderSection(String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)] + public sealed class RazorSectionAttribute : Attribute { } + + /// + /// Indicates how method, constructor invocation or property access + /// over collection type affects content of the collection. + /// + [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Property)] + public sealed class CollectionAccessAttribute : Attribute + { + public CollectionAccessAttribute(CollectionAccessType collectionAccessType) + { + CollectionAccessType = collectionAccessType; + } + + public CollectionAccessType CollectionAccessType { get; private set; } + } + + [Flags] + public enum CollectionAccessType + { + /// Method does not use or modify content of the collection. + None = 0, + /// Method only reads content of the collection but does not modify it. + Read = 1, + /// Method can change content of the collection but does not add new elements. + ModifyExistingContent = 2, + /// Method can add new elements to the collection. + UpdatedContent = ModifyExistingContent | 4 + } + + /// + /// Indicates that the marked method is assertion method, i.e. it halts control flow if + /// one of the conditions is satisfied. To set the condition, mark one of the parameters with + /// attribute. + /// + [AttributeUsage(AttributeTargets.Method)] + public sealed class AssertionMethodAttribute : Attribute { } + + /// + /// Indicates the condition parameter of the assertion method. The method itself should be + /// marked by attribute. The mandatory argument of + /// the attribute is the assertion type. + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class AssertionConditionAttribute : Attribute + { + public AssertionConditionAttribute(AssertionConditionType conditionType) + { + ConditionType = conditionType; + } + + public AssertionConditionType ConditionType { get; private set; } + } + + /// + /// Specifies assertion type. If the assertion method argument satisfies the condition, + /// then the execution continues. Otherwise, execution is assumed to be halted. + /// + public enum AssertionConditionType + { + /// Marked parameter should be evaluated to true. + IS_TRUE = 0, + /// Marked parameter should be evaluated to false. + IS_FALSE = 1, + /// Marked parameter should be evaluated to null value. + IS_NULL = 2, + /// Marked parameter should be evaluated to not null value. + IS_NOT_NULL = 3, + } + + /// + /// Indicates that the marked method unconditionally terminates control flow execution. + /// For example, it could unconditionally throw exception. + /// + [Obsolete("Use [ContractAnnotation('=> halt')] instead")] + [AttributeUsage(AttributeTargets.Method)] + public sealed class TerminatesProgramAttribute : Attribute { } + + /// + /// Indicates that method is pure LINQ method, with postponed enumeration (like Enumerable.Select, + /// .Where). This annotation allows inference of [InstantHandle] annotation for parameters + /// of delegate type by analyzing LINQ method chains. + /// + [AttributeUsage(AttributeTargets.Method)] + public sealed class LinqTunnelAttribute : Attribute { } + + /// + /// Indicates that IEnumerable, passed as parameter, is not enumerated. + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class NoEnumerationAttribute : Attribute { } + + /// + /// Indicates that parameter is regular expression pattern. + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class RegexPatternAttribute : Attribute { } + + /// + /// XAML attribute. Indicates the type that has ItemsSource property and should be treated + /// as ItemsControl-derived type, to enable inner items DataContext type resolve. + /// + [AttributeUsage(AttributeTargets.Class)] + public sealed class XamlItemsControlAttribute : Attribute { } + + /// + /// XAML attribute. Indicates the property of some BindingBase-derived type, that + /// is used to bind some item of ItemsControl-derived type. This annotation will + /// enable the DataContext type resolve for XAML bindings for such properties. + /// + /// + /// Property should have the tree ancestor of the ItemsControl type or + /// marked with the attribute. + /// + [AttributeUsage(AttributeTargets.Property)] + public sealed class XamlItemBindingOfItemsControlAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)] + public sealed class AspChildControlTypeAttribute : Attribute + { + public AspChildControlTypeAttribute(string tagName, Type controlType) + { + TagName = tagName; + ControlType = controlType; + } + + public string TagName { get; private set; } + public Type ControlType { get; private set; } + } + + [AttributeUsage(AttributeTargets.Property | AttributeTargets.Method)] + public sealed class AspDataFieldAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Property | AttributeTargets.Method)] + public sealed class AspDataFieldsAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Property)] + public sealed class AspMethodPropertyAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)] + public sealed class AspRequiredAttributeAttribute : Attribute + { + public AspRequiredAttributeAttribute([NotNull] string attribute) + { + Attribute = attribute; + } + + public string Attribute { get; private set; } + } + + [AttributeUsage(AttributeTargets.Property)] + public sealed class AspTypePropertyAttribute : Attribute + { + public bool CreateConstructorReferences { get; private set; } + + public AspTypePropertyAttribute(bool createConstructorReferences) + { + CreateConstructorReferences = createConstructorReferences; + } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + public sealed class RazorImportNamespaceAttribute : Attribute + { + public RazorImportNamespaceAttribute(string name) + { + Name = name; + } + + public string Name { get; private set; } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + public sealed class RazorInjectionAttribute : Attribute + { + public RazorInjectionAttribute(string type, string fieldName) + { + Type = type; + FieldName = fieldName; + } + + public string Type { get; private set; } + public string FieldName { get; private set; } + } + + [AttributeUsage(AttributeTargets.Method)] + public sealed class RazorHelperCommonAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Property)] + public sealed class RazorLayoutAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Method)] + public sealed class RazorWriteLiteralMethodAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Method)] + public sealed class RazorWriteMethodAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class RazorWriteMethodParameterAttribute : Attribute { } + + /// + /// Prevents the Member Reordering feature from tossing members of the marked class. + /// + /// + /// The attribute must be mentioned in your member reordering patterns + /// + [AttributeUsage(AttributeTargets.All)] + public sealed class NoReorder : Attribute { } +} \ No newline at end of file diff --git a/Gu.Units.Wpf.Demo/Properties/AssemblyInfo.cs b/Gu.Units.Wpf.Demo/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..abb5086f --- /dev/null +++ b/Gu.Units.Wpf.Demo/Properties/AssemblyInfo.cs @@ -0,0 +1,55 @@ +using System.Reflection; +using System.Resources; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Windows; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("Gu.Units.Wpf.Demo")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("Gu.Units.Wpf.Demo")] +[assembly: AssemblyCopyright("Copyright © 2015")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +//In order to begin building localizable applications, set +//CultureYouAreCodingWith in your .csproj file +//inside a . For example, if you are using US english +//in your source files, set the to en-US. Then uncomment +//the NeutralResourceLanguage attribute below. Update the "en-US" in +//the line below to match the UICulture setting in the project file. + +//[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)] + + +[assembly: ThemeInfo( + ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located + //(used if a resource is not found in the page, + // or application resource dictionaries) + ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located + //(used if a resource is not found in the page, + // app, or any theme specific resource dictionaries) +)] + + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/Gu.Units.Wpf.Demo/Properties/Resources.Designer.cs b/Gu.Units.Wpf.Demo/Properties/Resources.Designer.cs new file mode 100644 index 00000000..b4fa4676 --- /dev/null +++ b/Gu.Units.Wpf.Demo/Properties/Resources.Designer.cs @@ -0,0 +1,71 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace Gu.Units.Wpf.Demo.Properties +{ + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources + { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() + { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager + { + get + { + if ((resourceMan == null)) + { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Gu.Units.Wpf.Demo.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture + { + get + { + return resourceCulture; + } + set + { + resourceCulture = value; + } + } + } +} diff --git a/Gu.Units.Wpf.Demo/Properties/Resources.resx b/Gu.Units.Wpf.Demo/Properties/Resources.resx new file mode 100644 index 00000000..af7dbebb --- /dev/null +++ b/Gu.Units.Wpf.Demo/Properties/Resources.resx @@ -0,0 +1,117 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Gu.Units.Wpf.Demo/Properties/Settings.Designer.cs b/Gu.Units.Wpf.Demo/Properties/Settings.Designer.cs new file mode 100644 index 00000000..d97374c4 --- /dev/null +++ b/Gu.Units.Wpf.Demo/Properties/Settings.Designer.cs @@ -0,0 +1,30 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace Gu.Units.Wpf.Demo.Properties +{ + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")] + internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase + { + + private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings()))); + + public static Settings Default + { + get + { + return defaultInstance; + } + } + } +} diff --git a/Gu.Units.Wpf.Demo/Properties/Settings.settings b/Gu.Units.Wpf.Demo/Properties/Settings.settings new file mode 100644 index 00000000..033d7a5e --- /dev/null +++ b/Gu.Units.Wpf.Demo/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file diff --git a/Gu.Units.Wpf.Demo/ViewModel.cs b/Gu.Units.Wpf.Demo/ViewModel.cs new file mode 100644 index 00000000..7d169057 --- /dev/null +++ b/Gu.Units.Wpf.Demo/ViewModel.cs @@ -0,0 +1,31 @@ +namespace Gu.Units.Wpf.Demo +{ + using System.ComponentModel; + using System.Runtime.CompilerServices; + using Annotations; + + public class ViewModel : INotifyPropertyChanged + { + private Length _length; + + public event PropertyChangedEventHandler PropertyChanged; + + public Length Length + { + get { return this._length; } + set + { + if (value.Equals(this._length)) + return; + this._length = value; + OnPropertyChanged(); + } + } + + [NotifyPropertyChangedInvocator] + protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null) + { + PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName)); + } + } +} \ No newline at end of file diff --git a/Gu.Units.Wpf.Tests/Class1.cs b/Gu.Units.Wpf.Tests/Class1.cs new file mode 100644 index 00000000..8e69b133 --- /dev/null +++ b/Gu.Units.Wpf.Tests/Class1.cs @@ -0,0 +1,6 @@ +namespace Gu.Units.Wpf.Tests +{ + public class Class1 + { + } +} diff --git a/Gu.Units.Wpf.Tests/Gu.Units.Wpf.Tests.csproj b/Gu.Units.Wpf.Tests/Gu.Units.Wpf.Tests.csproj new file mode 100644 index 00000000..40311725 --- /dev/null +++ b/Gu.Units.Wpf.Tests/Gu.Units.Wpf.Tests.csproj @@ -0,0 +1,85 @@ + + + + + Debug + AnyCPU + {EE6BCD5F-AEF0-4929-95F6-3613E76E13CB} + Library + Properties + Gu.Units.Wpf.Tests + Gu.Units.Wpf.Tests + v4.5 + 512 + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + ..\packages\NUnit\lib\net20\nunit.framework.dll + True + True + + + + + + + ..\packages\NUnit\lib\net40\nunit.framework.dll + True + True + + + + + + + ..\packages\NUnit\lib\net45\nunit.framework.dll + True + True + + + + + + + ..\packages\NUnit\lib\portable-net45+win8+wp8+wpa81+Xamarin.Mac+MonoAndroid10+MonoTouch10+Xamarin.iOS10\nunit.framework.dll + True + True + + + + + \ No newline at end of file diff --git a/Gu.Units.Wpf.Tests/Properties/AssemblyInfo.cs b/Gu.Units.Wpf.Tests/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..14643c4d --- /dev/null +++ b/Gu.Units.Wpf.Tests/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("Gu.Units.Wpf.Tests")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("Gu.Units.Wpf.Tests")] +[assembly: AssemblyCopyright("Copyright © 2015")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("ee6bcd5f-aef0-4929-95f6-3613e76e13cb")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/Gu.Units.Wpf.Tests/paket.references b/Gu.Units.Wpf.Tests/paket.references new file mode 100644 index 00000000..77bef386 --- /dev/null +++ b/Gu.Units.Wpf.Tests/paket.references @@ -0,0 +1 @@ +NUnit \ No newline at end of file diff --git a/Gu.Units.Wpf/Gu.Units.Wpf.csproj b/Gu.Units.Wpf/Gu.Units.Wpf.csproj new file mode 100644 index 00000000..4513ce99 --- /dev/null +++ b/Gu.Units.Wpf/Gu.Units.Wpf.csproj @@ -0,0 +1,57 @@ + + + + + Debug + AnyCPU + {EA4BCE51-A58D-4FA7-BBA4-6F0056D753CA} + Library + Properties + Gu.Units.Wpf + Gu.Units.Wpf + v4.5 + 512 + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + bin\Release\Gu.Units.Wpf.XML + + + + + + + + + + + + + + {f1f8b138-becc-4475-a7ab-b3019338bc7b} + Gu.Units + + + + + \ No newline at end of file diff --git a/Gu.Units.Wpf/LengthConverter.cs b/Gu.Units.Wpf/LengthConverter.cs new file mode 100644 index 00000000..6e5f92ce --- /dev/null +++ b/Gu.Units.Wpf/LengthConverter.cs @@ -0,0 +1,50 @@ +namespace Gu.Units.Wpf +{ + using System; + using System.ComponentModel; + using System.Globalization; + using System.Windows.Data; + using System.Windows.Markup; + + [MarkupExtensionReturnType(typeof(IValueConverter))] + public class LengthConverter : MarkupExtension, IValueConverter + { + public LengthConverter([TypeConverter(typeof(LengthUnitTypeConverter))]LengthUnit unit) + { + Unit = unit; + } + + [ConstructorArgument("unit"), TypeConverter(typeof(LengthUnitTypeConverter))] + public LengthUnit Unit { get; set; } + + public override object ProvideValue(IServiceProvider serviceProvider) + { + return this; + } + + public object Convert(object value, + Type targetType, + object parameter, + CultureInfo culture) + { + if (value == null) + { + return null; + } + + if (targetType == typeof(double)) + { + throw new NotImplementedException(); + } + throw new NotImplementedException(); + } + + public object ConvertBack(object value, + Type targetType, + object parameter, + CultureInfo culture) + { + throw new NotImplementedException(); + } + } +} diff --git a/Gu.Units.Wpf/Properties/AssemblyInfo.cs b/Gu.Units.Wpf/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..f03b3221 --- /dev/null +++ b/Gu.Units.Wpf/Properties/AssemblyInfo.cs @@ -0,0 +1,40 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Windows.Markup; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("Gu.Units.Wpf")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("Gu.Units.Wpf")] +[assembly: AssemblyCopyright("Copyright © 2015")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("ea4bce51-a58d-4fa7-bba4-6f0056d753ca")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] +[assembly: XmlnsDefinition("http://Gu.com/Units", clrNamespace: "Gu.Units", AssemblyName = "Gu.Units")] +[assembly: XmlnsDefinition("http://Gu.com/Units", clrNamespace: "Gu.Units.Wpf", AssemblyName = "Gu.Units.Wpf")] +[assembly: XmlnsPrefix("http://Gu.com/Units", "units")] diff --git a/Gu.Units.sln b/Gu.Units.sln index 9c3b3f2d..6bb3caf5 100644 --- a/Gu.Units.sln +++ b/Gu.Units.sln @@ -22,6 +22,12 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Gu.Units.Generator.Tests", EndProject Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "Gu.Units.Fsharp.Tests", "Gu.Units.Fsharp.Tests\Gu.Units.Fsharp.Tests.fsproj", "{BE7BE5C0-7D90-49D4-86BF-4D826C052D80}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Gu.Units.Wpf", "Gu.Units.Wpf\Gu.Units.Wpf.csproj", "{EA4BCE51-A58D-4FA7-BBA4-6F0056D753CA}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Gu.Units.Wpf.Tests", "Gu.Units.Wpf.Tests\Gu.Units.Wpf.Tests.csproj", "{EE6BCD5F-AEF0-4929-95F6-3613E76E13CB}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Gu.Units.Wpf.Demo", "Gu.Units.Wpf.Demo\Gu.Units.Wpf.Demo.csproj", "{8CB38BA2-254B-4B0F-9C9F-57D17DE5D8B5}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -55,6 +61,24 @@ Global {BE7BE5C0-7D90-49D4-86BF-4D826C052D80}.Generator Only|Any CPU.ActiveCfg = Release|Any CPU {BE7BE5C0-7D90-49D4-86BF-4D826C052D80}.Release|Any CPU.ActiveCfg = Release|Any CPU {BE7BE5C0-7D90-49D4-86BF-4D826C052D80}.Release|Any CPU.Build.0 = Release|Any CPU + {EA4BCE51-A58D-4FA7-BBA4-6F0056D753CA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {EA4BCE51-A58D-4FA7-BBA4-6F0056D753CA}.Debug|Any CPU.Build.0 = Debug|Any CPU + {EA4BCE51-A58D-4FA7-BBA4-6F0056D753CA}.Generator Only|Any CPU.ActiveCfg = Release|Any CPU + {EA4BCE51-A58D-4FA7-BBA4-6F0056D753CA}.Generator Only|Any CPU.Build.0 = Release|Any CPU + {EA4BCE51-A58D-4FA7-BBA4-6F0056D753CA}.Release|Any CPU.ActiveCfg = Release|Any CPU + {EA4BCE51-A58D-4FA7-BBA4-6F0056D753CA}.Release|Any CPU.Build.0 = Release|Any CPU + {EE6BCD5F-AEF0-4929-95F6-3613E76E13CB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {EE6BCD5F-AEF0-4929-95F6-3613E76E13CB}.Debug|Any CPU.Build.0 = Debug|Any CPU + {EE6BCD5F-AEF0-4929-95F6-3613E76E13CB}.Generator Only|Any CPU.ActiveCfg = Release|Any CPU + {EE6BCD5F-AEF0-4929-95F6-3613E76E13CB}.Generator Only|Any CPU.Build.0 = Release|Any CPU + {EE6BCD5F-AEF0-4929-95F6-3613E76E13CB}.Release|Any CPU.ActiveCfg = Release|Any CPU + {EE6BCD5F-AEF0-4929-95F6-3613E76E13CB}.Release|Any CPU.Build.0 = Release|Any CPU + {8CB38BA2-254B-4B0F-9C9F-57D17DE5D8B5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {8CB38BA2-254B-4B0F-9C9F-57D17DE5D8B5}.Debug|Any CPU.Build.0 = Debug|Any CPU + {8CB38BA2-254B-4B0F-9C9F-57D17DE5D8B5}.Generator Only|Any CPU.ActiveCfg = Release|Any CPU + {8CB38BA2-254B-4B0F-9C9F-57D17DE5D8B5}.Generator Only|Any CPU.Build.0 = Release|Any CPU + {8CB38BA2-254B-4B0F-9C9F-57D17DE5D8B5}.Release|Any CPU.ActiveCfg = Release|Any CPU + {8CB38BA2-254B-4B0F-9C9F-57D17DE5D8B5}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/Gu.Units.sln.DotSettings b/Gu.Units.sln.DotSettings index ba3faa65..d186b64d 100644 --- a/Gu.Units.sln.DotSettings +++ b/Gu.Units.sln.DotSettings @@ -1,6 +1,7 @@  True True + True Field True LINE_BREAK diff --git a/Gu.Units/AccelerationUnitTypeConverter.generated.cs b/Gu.Units/AccelerationUnitTypeConverter.generated.cs new file mode 100644 index 00000000..0b99e583 --- /dev/null +++ b/Gu.Units/AccelerationUnitTypeConverter.generated.cs @@ -0,0 +1,88 @@ +namespace Gu.Units +{ + using System; + using System.ComponentModel; + using System.ComponentModel.Design.Serialization; + using System.Globalization; + using System.Reflection; + + /// + /// Provides a type converter to convert + /// objects to and from various + /// other representations. + /// + public class AccelerationUnitTypeConverter : TypeConverter + { + /// + /// Gets a value indicating whether this converter can + /// convert an object in the given source type to a object using the + /// specified context. + /// + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) + { + if (sourceType == typeof(string)) + { + return true; + } + + return base.CanConvertFrom(context, sourceType); + } + + /// + /// Gets a value indicating whether this converter can + /// convert an object to the given destination type using the context. + /// + public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) + { + if (destinationType == typeof(InstanceDescriptor)) + { + return true; + } + + return base.CanConvertTo(context, destinationType); + } + + /// + /// Converts the given object to a + /// object. + /// + public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) + { + var text = value as string; + if (text != null) + { + text = text.Trim(); + return AccelerationUnit.Parse(text); + } + + return base.ConvertFrom(context, culture, value); + } + + /// + /// Converts the given object to another type. The most common types to convert + /// are to and from a string object. The default implementation will make a call + /// to ToString on the object if the object is valid and if the destination + /// type is string. If this cannot convert to the type, this will + /// throw a NotSupportedException. + /// + public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) + { + if (destinationType == null) + { + throw new ArgumentNullException(nameof(destinationType)); + } + + if (destinationType == typeof(InstanceDescriptor) && value is AccelerationUnit) + { + MethodInfo method = typeof(AccelerationUnit).GetMethod(nameof(AccelerationUnit.Parse), new Type[] { typeof(string) }); + if (method != null) + { + var args = new object[] { ((AccelerationUnit)value).Symbol }; + return new InstanceDescriptor(method, args); + } + } + + return base.ConvertTo(context, culture, value, destinationType); + } + } +} \ No newline at end of file diff --git a/Gu.Units/AngleUnitTypeConverter.generated.cs b/Gu.Units/AngleUnitTypeConverter.generated.cs new file mode 100644 index 00000000..826c800c --- /dev/null +++ b/Gu.Units/AngleUnitTypeConverter.generated.cs @@ -0,0 +1,88 @@ +namespace Gu.Units +{ + using System; + using System.ComponentModel; + using System.ComponentModel.Design.Serialization; + using System.Globalization; + using System.Reflection; + + /// + /// Provides a type converter to convert + /// objects to and from various + /// other representations. + /// + public class AngleUnitTypeConverter : TypeConverter + { + /// + /// Gets a value indicating whether this converter can + /// convert an object in the given source type to a object using the + /// specified context. + /// + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) + { + if (sourceType == typeof(string)) + { + return true; + } + + return base.CanConvertFrom(context, sourceType); + } + + /// + /// Gets a value indicating whether this converter can + /// convert an object to the given destination type using the context. + /// + public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) + { + if (destinationType == typeof(InstanceDescriptor)) + { + return true; + } + + return base.CanConvertTo(context, destinationType); + } + + /// + /// Converts the given object to a + /// object. + /// + public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) + { + var text = value as string; + if (text != null) + { + text = text.Trim(); + return AngleUnit.Parse(text); + } + + return base.ConvertFrom(context, culture, value); + } + + /// + /// Converts the given object to another type. The most common types to convert + /// are to and from a string object. The default implementation will make a call + /// to ToString on the object if the object is valid and if the destination + /// type is string. If this cannot convert to the type, this will + /// throw a NotSupportedException. + /// + public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) + { + if (destinationType == null) + { + throw new ArgumentNullException(nameof(destinationType)); + } + + if (destinationType == typeof(InstanceDescriptor) && value is AngleUnit) + { + MethodInfo method = typeof(AngleUnit).GetMethod(nameof(AngleUnit.Parse), new Type[] { typeof(string) }); + if (method != null) + { + var args = new object[] { ((AngleUnit)value).Symbol }; + return new InstanceDescriptor(method, args); + } + } + + return base.ConvertTo(context, culture, value, destinationType); + } + } +} \ No newline at end of file diff --git a/Gu.Units/AngularAccelerationUnitTypeConverter.generated.cs b/Gu.Units/AngularAccelerationUnitTypeConverter.generated.cs new file mode 100644 index 00000000..e401f741 --- /dev/null +++ b/Gu.Units/AngularAccelerationUnitTypeConverter.generated.cs @@ -0,0 +1,88 @@ +namespace Gu.Units +{ + using System; + using System.ComponentModel; + using System.ComponentModel.Design.Serialization; + using System.Globalization; + using System.Reflection; + + /// + /// Provides a type converter to convert + /// objects to and from various + /// other representations. + /// + public class AngularAccelerationUnitTypeConverter : TypeConverter + { + /// + /// Gets a value indicating whether this converter can + /// convert an object in the given source type to a object using the + /// specified context. + /// + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) + { + if (sourceType == typeof(string)) + { + return true; + } + + return base.CanConvertFrom(context, sourceType); + } + + /// + /// Gets a value indicating whether this converter can + /// convert an object to the given destination type using the context. + /// + public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) + { + if (destinationType == typeof(InstanceDescriptor)) + { + return true; + } + + return base.CanConvertTo(context, destinationType); + } + + /// + /// Converts the given object to a + /// object. + /// + public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) + { + var text = value as string; + if (text != null) + { + text = text.Trim(); + return AngularAccelerationUnit.Parse(text); + } + + return base.ConvertFrom(context, culture, value); + } + + /// + /// Converts the given object to another type. The most common types to convert + /// are to and from a string object. The default implementation will make a call + /// to ToString on the object if the object is valid and if the destination + /// type is string. If this cannot convert to the type, this will + /// throw a NotSupportedException. + /// + public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) + { + if (destinationType == null) + { + throw new ArgumentNullException(nameof(destinationType)); + } + + if (destinationType == typeof(InstanceDescriptor) && value is AngularAccelerationUnit) + { + MethodInfo method = typeof(AngularAccelerationUnit).GetMethod(nameof(AngularAccelerationUnit.Parse), new Type[] { typeof(string) }); + if (method != null) + { + var args = new object[] { ((AngularAccelerationUnit)value).Symbol }; + return new InstanceDescriptor(method, args); + } + } + + return base.ConvertTo(context, culture, value, destinationType); + } + } +} \ No newline at end of file diff --git a/Gu.Units/AngularJerkUnitTypeConverter.generated.cs b/Gu.Units/AngularJerkUnitTypeConverter.generated.cs new file mode 100644 index 00000000..7d3babf8 --- /dev/null +++ b/Gu.Units/AngularJerkUnitTypeConverter.generated.cs @@ -0,0 +1,88 @@ +namespace Gu.Units +{ + using System; + using System.ComponentModel; + using System.ComponentModel.Design.Serialization; + using System.Globalization; + using System.Reflection; + + /// + /// Provides a type converter to convert + /// objects to and from various + /// other representations. + /// + public class AngularJerkUnitTypeConverter : TypeConverter + { + /// + /// Gets a value indicating whether this converter can + /// convert an object in the given source type to a object using the + /// specified context. + /// + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) + { + if (sourceType == typeof(string)) + { + return true; + } + + return base.CanConvertFrom(context, sourceType); + } + + /// + /// Gets a value indicating whether this converter can + /// convert an object to the given destination type using the context. + /// + public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) + { + if (destinationType == typeof(InstanceDescriptor)) + { + return true; + } + + return base.CanConvertTo(context, destinationType); + } + + /// + /// Converts the given object to a + /// object. + /// + public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) + { + var text = value as string; + if (text != null) + { + text = text.Trim(); + return AngularJerkUnit.Parse(text); + } + + return base.ConvertFrom(context, culture, value); + } + + /// + /// Converts the given object to another type. The most common types to convert + /// are to and from a string object. The default implementation will make a call + /// to ToString on the object if the object is valid and if the destination + /// type is string. If this cannot convert to the type, this will + /// throw a NotSupportedException. + /// + public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) + { + if (destinationType == null) + { + throw new ArgumentNullException(nameof(destinationType)); + } + + if (destinationType == typeof(InstanceDescriptor) && value is AngularJerkUnit) + { + MethodInfo method = typeof(AngularJerkUnit).GetMethod(nameof(AngularJerkUnit.Parse), new Type[] { typeof(string) }); + if (method != null) + { + var args = new object[] { ((AngularJerkUnit)value).Symbol }; + return new InstanceDescriptor(method, args); + } + } + + return base.ConvertTo(context, culture, value, destinationType); + } + } +} \ No newline at end of file diff --git a/Gu.Units/AngularSpeedUnitTypeConverter.generated.cs b/Gu.Units/AngularSpeedUnitTypeConverter.generated.cs new file mode 100644 index 00000000..08008fb3 --- /dev/null +++ b/Gu.Units/AngularSpeedUnitTypeConverter.generated.cs @@ -0,0 +1,88 @@ +namespace Gu.Units +{ + using System; + using System.ComponentModel; + using System.ComponentModel.Design.Serialization; + using System.Globalization; + using System.Reflection; + + /// + /// Provides a type converter to convert + /// objects to and from various + /// other representations. + /// + public class AngularSpeedUnitTypeConverter : TypeConverter + { + /// + /// Gets a value indicating whether this converter can + /// convert an object in the given source type to a object using the + /// specified context. + /// + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) + { + if (sourceType == typeof(string)) + { + return true; + } + + return base.CanConvertFrom(context, sourceType); + } + + /// + /// Gets a value indicating whether this converter can + /// convert an object to the given destination type using the context. + /// + public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) + { + if (destinationType == typeof(InstanceDescriptor)) + { + return true; + } + + return base.CanConvertTo(context, destinationType); + } + + /// + /// Converts the given object to a + /// object. + /// + public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) + { + var text = value as string; + if (text != null) + { + text = text.Trim(); + return AngularSpeedUnit.Parse(text); + } + + return base.ConvertFrom(context, culture, value); + } + + /// + /// Converts the given object to another type. The most common types to convert + /// are to and from a string object. The default implementation will make a call + /// to ToString on the object if the object is valid and if the destination + /// type is string. If this cannot convert to the type, this will + /// throw a NotSupportedException. + /// + public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) + { + if (destinationType == null) + { + throw new ArgumentNullException(nameof(destinationType)); + } + + if (destinationType == typeof(InstanceDescriptor) && value is AngularSpeedUnit) + { + MethodInfo method = typeof(AngularSpeedUnit).GetMethod(nameof(AngularSpeedUnit.Parse), new Type[] { typeof(string) }); + if (method != null) + { + var args = new object[] { ((AngularSpeedUnit)value).Symbol }; + return new InstanceDescriptor(method, args); + } + } + + return base.ConvertTo(context, culture, value, destinationType); + } + } +} \ No newline at end of file diff --git a/Gu.Units/AreaUnitTypeConverter.generated.cs b/Gu.Units/AreaUnitTypeConverter.generated.cs new file mode 100644 index 00000000..8b309ef2 --- /dev/null +++ b/Gu.Units/AreaUnitTypeConverter.generated.cs @@ -0,0 +1,88 @@ +namespace Gu.Units +{ + using System; + using System.ComponentModel; + using System.ComponentModel.Design.Serialization; + using System.Globalization; + using System.Reflection; + + /// + /// Provides a type converter to convert + /// objects to and from various + /// other representations. + /// + public class AreaUnitTypeConverter : TypeConverter + { + /// + /// Gets a value indicating whether this converter can + /// convert an object in the given source type to a object using the + /// specified context. + /// + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) + { + if (sourceType == typeof(string)) + { + return true; + } + + return base.CanConvertFrom(context, sourceType); + } + + /// + /// Gets a value indicating whether this converter can + /// convert an object to the given destination type using the context. + /// + public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) + { + if (destinationType == typeof(InstanceDescriptor)) + { + return true; + } + + return base.CanConvertTo(context, destinationType); + } + + /// + /// Converts the given object to a + /// object. + /// + public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) + { + var text = value as string; + if (text != null) + { + text = text.Trim(); + return AreaUnit.Parse(text); + } + + return base.ConvertFrom(context, culture, value); + } + + /// + /// Converts the given object to another type. The most common types to convert + /// are to and from a string object. The default implementation will make a call + /// to ToString on the object if the object is valid and if the destination + /// type is string. If this cannot convert to the type, this will + /// throw a NotSupportedException. + /// + public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) + { + if (destinationType == null) + { + throw new ArgumentNullException(nameof(destinationType)); + } + + if (destinationType == typeof(InstanceDescriptor) && value is AreaUnit) + { + MethodInfo method = typeof(AreaUnit).GetMethod(nameof(AreaUnit.Parse), new Type[] { typeof(string) }); + if (method != null) + { + var args = new object[] { ((AreaUnit)value).Symbol }; + return new InstanceDescriptor(method, args); + } + } + + return base.ConvertTo(context, culture, value, destinationType); + } + } +} \ No newline at end of file diff --git a/Gu.Units/CapacitanceUnitTypeConverter.generated.cs b/Gu.Units/CapacitanceUnitTypeConverter.generated.cs new file mode 100644 index 00000000..7e4968a5 --- /dev/null +++ b/Gu.Units/CapacitanceUnitTypeConverter.generated.cs @@ -0,0 +1,88 @@ +namespace Gu.Units +{ + using System; + using System.ComponentModel; + using System.ComponentModel.Design.Serialization; + using System.Globalization; + using System.Reflection; + + /// + /// Provides a type converter to convert + /// objects to and from various + /// other representations. + /// + public class CapacitanceUnitTypeConverter : TypeConverter + { + /// + /// Gets a value indicating whether this converter can + /// convert an object in the given source type to a object using the + /// specified context. + /// + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) + { + if (sourceType == typeof(string)) + { + return true; + } + + return base.CanConvertFrom(context, sourceType); + } + + /// + /// Gets a value indicating whether this converter can + /// convert an object to the given destination type using the context. + /// + public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) + { + if (destinationType == typeof(InstanceDescriptor)) + { + return true; + } + + return base.CanConvertTo(context, destinationType); + } + + /// + /// Converts the given object to a + /// object. + /// + public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) + { + var text = value as string; + if (text != null) + { + text = text.Trim(); + return CapacitanceUnit.Parse(text); + } + + return base.ConvertFrom(context, culture, value); + } + + /// + /// Converts the given object to another type. The most common types to convert + /// are to and from a string object. The default implementation will make a call + /// to ToString on the object if the object is valid and if the destination + /// type is string. If this cannot convert to the type, this will + /// throw a NotSupportedException. + /// + public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) + { + if (destinationType == null) + { + throw new ArgumentNullException(nameof(destinationType)); + } + + if (destinationType == typeof(InstanceDescriptor) && value is CapacitanceUnit) + { + MethodInfo method = typeof(CapacitanceUnit).GetMethod(nameof(CapacitanceUnit.Parse), new Type[] { typeof(string) }); + if (method != null) + { + var args = new object[] { ((CapacitanceUnit)value).Symbol }; + return new InstanceDescriptor(method, args); + } + } + + return base.ConvertTo(context, culture, value, destinationType); + } + } +} \ No newline at end of file diff --git a/Gu.Units/CurrentUnitTypeConverter.generated.cs b/Gu.Units/CurrentUnitTypeConverter.generated.cs new file mode 100644 index 00000000..d16877f2 --- /dev/null +++ b/Gu.Units/CurrentUnitTypeConverter.generated.cs @@ -0,0 +1,88 @@ +namespace Gu.Units +{ + using System; + using System.ComponentModel; + using System.ComponentModel.Design.Serialization; + using System.Globalization; + using System.Reflection; + + /// + /// Provides a type converter to convert + /// objects to and from various + /// other representations. + /// + public class CurrentUnitTypeConverter : TypeConverter + { + /// + /// Gets a value indicating whether this converter can + /// convert an object in the given source type to a object using the + /// specified context. + /// + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) + { + if (sourceType == typeof(string)) + { + return true; + } + + return base.CanConvertFrom(context, sourceType); + } + + /// + /// Gets a value indicating whether this converter can + /// convert an object to the given destination type using the context. + /// + public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) + { + if (destinationType == typeof(InstanceDescriptor)) + { + return true; + } + + return base.CanConvertTo(context, destinationType); + } + + /// + /// Converts the given object to a + /// object. + /// + public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) + { + var text = value as string; + if (text != null) + { + text = text.Trim(); + return CurrentUnit.Parse(text); + } + + return base.ConvertFrom(context, culture, value); + } + + /// + /// Converts the given object to another type. The most common types to convert + /// are to and from a string object. The default implementation will make a call + /// to ToString on the object if the object is valid and if the destination + /// type is string. If this cannot convert to the type, this will + /// throw a NotSupportedException. + /// + public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) + { + if (destinationType == null) + { + throw new ArgumentNullException(nameof(destinationType)); + } + + if (destinationType == typeof(InstanceDescriptor) && value is CurrentUnit) + { + MethodInfo method = typeof(CurrentUnit).GetMethod(nameof(CurrentUnit.Parse), new Type[] { typeof(string) }); + if (method != null) + { + var args = new object[] { ((CurrentUnit)value).Symbol }; + return new InstanceDescriptor(method, args); + } + } + + return base.ConvertTo(context, culture, value, destinationType); + } + } +} \ No newline at end of file diff --git a/Gu.Units/DensityUnitTypeConverter.generated.cs b/Gu.Units/DensityUnitTypeConverter.generated.cs new file mode 100644 index 00000000..acb58880 --- /dev/null +++ b/Gu.Units/DensityUnitTypeConverter.generated.cs @@ -0,0 +1,88 @@ +namespace Gu.Units +{ + using System; + using System.ComponentModel; + using System.ComponentModel.Design.Serialization; + using System.Globalization; + using System.Reflection; + + /// + /// Provides a type converter to convert + /// objects to and from various + /// other representations. + /// + public class DensityUnitTypeConverter : TypeConverter + { + /// + /// Gets a value indicating whether this converter can + /// convert an object in the given source type to a object using the + /// specified context. + /// + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) + { + if (sourceType == typeof(string)) + { + return true; + } + + return base.CanConvertFrom(context, sourceType); + } + + /// + /// Gets a value indicating whether this converter can + /// convert an object to the given destination type using the context. + /// + public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) + { + if (destinationType == typeof(InstanceDescriptor)) + { + return true; + } + + return base.CanConvertTo(context, destinationType); + } + + /// + /// Converts the given object to a + /// object. + /// + public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) + { + var text = value as string; + if (text != null) + { + text = text.Trim(); + return DensityUnit.Parse(text); + } + + return base.ConvertFrom(context, culture, value); + } + + /// + /// Converts the given object to another type. The most common types to convert + /// are to and from a string object. The default implementation will make a call + /// to ToString on the object if the object is valid and if the destination + /// type is string. If this cannot convert to the type, this will + /// throw a NotSupportedException. + /// + public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) + { + if (destinationType == null) + { + throw new ArgumentNullException(nameof(destinationType)); + } + + if (destinationType == typeof(InstanceDescriptor) && value is DensityUnit) + { + MethodInfo method = typeof(DensityUnit).GetMethod(nameof(DensityUnit.Parse), new Type[] { typeof(string) }); + if (method != null) + { + var args = new object[] { ((DensityUnit)value).Symbol }; + return new InstanceDescriptor(method, args); + } + } + + return base.ConvertTo(context, culture, value, destinationType); + } + } +} \ No newline at end of file diff --git a/Gu.Units/ElectricChargeUnitTypeConverter.generated.cs b/Gu.Units/ElectricChargeUnitTypeConverter.generated.cs new file mode 100644 index 00000000..afda34e2 --- /dev/null +++ b/Gu.Units/ElectricChargeUnitTypeConverter.generated.cs @@ -0,0 +1,88 @@ +namespace Gu.Units +{ + using System; + using System.ComponentModel; + using System.ComponentModel.Design.Serialization; + using System.Globalization; + using System.Reflection; + + /// + /// Provides a type converter to convert + /// objects to and from various + /// other representations. + /// + public class ElectricChargeUnitTypeConverter : TypeConverter + { + /// + /// Gets a value indicating whether this converter can + /// convert an object in the given source type to a object using the + /// specified context. + /// + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) + { + if (sourceType == typeof(string)) + { + return true; + } + + return base.CanConvertFrom(context, sourceType); + } + + /// + /// Gets a value indicating whether this converter can + /// convert an object to the given destination type using the context. + /// + public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) + { + if (destinationType == typeof(InstanceDescriptor)) + { + return true; + } + + return base.CanConvertTo(context, destinationType); + } + + /// + /// Converts the given object to a + /// object. + /// + public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) + { + var text = value as string; + if (text != null) + { + text = text.Trim(); + return ElectricChargeUnit.Parse(text); + } + + return base.ConvertFrom(context, culture, value); + } + + /// + /// Converts the given object to another type. The most common types to convert + /// are to and from a string object. The default implementation will make a call + /// to ToString on the object if the object is valid and if the destination + /// type is string. If this cannot convert to the type, this will + /// throw a NotSupportedException. + /// + public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) + { + if (destinationType == null) + { + throw new ArgumentNullException(nameof(destinationType)); + } + + if (destinationType == typeof(InstanceDescriptor) && value is ElectricChargeUnit) + { + MethodInfo method = typeof(ElectricChargeUnit).GetMethod(nameof(ElectricChargeUnit.Parse), new Type[] { typeof(string) }); + if (method != null) + { + var args = new object[] { ((ElectricChargeUnit)value).Symbol }; + return new InstanceDescriptor(method, args); + } + } + + return base.ConvertTo(context, culture, value, destinationType); + } + } +} \ No newline at end of file diff --git a/Gu.Units/EnergyUnitTypeConverter.generated.cs b/Gu.Units/EnergyUnitTypeConverter.generated.cs new file mode 100644 index 00000000..24a513d6 --- /dev/null +++ b/Gu.Units/EnergyUnitTypeConverter.generated.cs @@ -0,0 +1,88 @@ +namespace Gu.Units +{ + using System; + using System.ComponentModel; + using System.ComponentModel.Design.Serialization; + using System.Globalization; + using System.Reflection; + + /// + /// Provides a type converter to convert + /// objects to and from various + /// other representations. + /// + public class EnergyUnitTypeConverter : TypeConverter + { + /// + /// Gets a value indicating whether this converter can + /// convert an object in the given source type to a object using the + /// specified context. + /// + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) + { + if (sourceType == typeof(string)) + { + return true; + } + + return base.CanConvertFrom(context, sourceType); + } + + /// + /// Gets a value indicating whether this converter can + /// convert an object to the given destination type using the context. + /// + public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) + { + if (destinationType == typeof(InstanceDescriptor)) + { + return true; + } + + return base.CanConvertTo(context, destinationType); + } + + /// + /// Converts the given object to a + /// object. + /// + public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) + { + var text = value as string; + if (text != null) + { + text = text.Trim(); + return EnergyUnit.Parse(text); + } + + return base.ConvertFrom(context, culture, value); + } + + /// + /// Converts the given object to another type. The most common types to convert + /// are to and from a string object. The default implementation will make a call + /// to ToString on the object if the object is valid and if the destination + /// type is string. If this cannot convert to the type, this will + /// throw a NotSupportedException. + /// + public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) + { + if (destinationType == null) + { + throw new ArgumentNullException(nameof(destinationType)); + } + + if (destinationType == typeof(InstanceDescriptor) && value is EnergyUnit) + { + MethodInfo method = typeof(EnergyUnit).GetMethod(nameof(EnergyUnit.Parse), new Type[] { typeof(string) }); + if (method != null) + { + var args = new object[] { ((EnergyUnit)value).Symbol }; + return new InstanceDescriptor(method, args); + } + } + + return base.ConvertTo(context, culture, value, destinationType); + } + } +} \ No newline at end of file diff --git a/Gu.Units/FlexibilityUnitTypeConverter.generated.cs b/Gu.Units/FlexibilityUnitTypeConverter.generated.cs new file mode 100644 index 00000000..30169789 --- /dev/null +++ b/Gu.Units/FlexibilityUnitTypeConverter.generated.cs @@ -0,0 +1,88 @@ +namespace Gu.Units +{ + using System; + using System.ComponentModel; + using System.ComponentModel.Design.Serialization; + using System.Globalization; + using System.Reflection; + + /// + /// Provides a type converter to convert + /// objects to and from various + /// other representations. + /// + public class FlexibilityUnitTypeConverter : TypeConverter + { + /// + /// Gets a value indicating whether this converter can + /// convert an object in the given source type to a object using the + /// specified context. + /// + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) + { + if (sourceType == typeof(string)) + { + return true; + } + + return base.CanConvertFrom(context, sourceType); + } + + /// + /// Gets a value indicating whether this converter can + /// convert an object to the given destination type using the context. + /// + public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) + { + if (destinationType == typeof(InstanceDescriptor)) + { + return true; + } + + return base.CanConvertTo(context, destinationType); + } + + /// + /// Converts the given object to a + /// object. + /// + public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) + { + var text = value as string; + if (text != null) + { + text = text.Trim(); + return FlexibilityUnit.Parse(text); + } + + return base.ConvertFrom(context, culture, value); + } + + /// + /// Converts the given object to another type. The most common types to convert + /// are to and from a string object. The default implementation will make a call + /// to ToString on the object if the object is valid and if the destination + /// type is string. If this cannot convert to the type, this will + /// throw a NotSupportedException. + /// + public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) + { + if (destinationType == null) + { + throw new ArgumentNullException(nameof(destinationType)); + } + + if (destinationType == typeof(InstanceDescriptor) && value is FlexibilityUnit) + { + MethodInfo method = typeof(FlexibilityUnit).GetMethod(nameof(FlexibilityUnit.Parse), new Type[] { typeof(string) }); + if (method != null) + { + var args = new object[] { ((FlexibilityUnit)value).Symbol }; + return new InstanceDescriptor(method, args); + } + } + + return base.ConvertTo(context, culture, value, destinationType); + } + } +} \ No newline at end of file diff --git a/Gu.Units/ForceUnitTypeConverter.generated.cs b/Gu.Units/ForceUnitTypeConverter.generated.cs new file mode 100644 index 00000000..0e37a7d2 --- /dev/null +++ b/Gu.Units/ForceUnitTypeConverter.generated.cs @@ -0,0 +1,88 @@ +namespace Gu.Units +{ + using System; + using System.ComponentModel; + using System.ComponentModel.Design.Serialization; + using System.Globalization; + using System.Reflection; + + /// + /// Provides a type converter to convert + /// objects to and from various + /// other representations. + /// + public class ForceUnitTypeConverter : TypeConverter + { + /// + /// Gets a value indicating whether this converter can + /// convert an object in the given source type to a object using the + /// specified context. + /// + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) + { + if (sourceType == typeof(string)) + { + return true; + } + + return base.CanConvertFrom(context, sourceType); + } + + /// + /// Gets a value indicating whether this converter can + /// convert an object to the given destination type using the context. + /// + public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) + { + if (destinationType == typeof(InstanceDescriptor)) + { + return true; + } + + return base.CanConvertTo(context, destinationType); + } + + /// + /// Converts the given object to a + /// object. + /// + public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) + { + var text = value as string; + if (text != null) + { + text = text.Trim(); + return ForceUnit.Parse(text); + } + + return base.ConvertFrom(context, culture, value); + } + + /// + /// Converts the given object to another type. The most common types to convert + /// are to and from a string object. The default implementation will make a call + /// to ToString on the object if the object is valid and if the destination + /// type is string. If this cannot convert to the type, this will + /// throw a NotSupportedException. + /// + public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) + { + if (destinationType == null) + { + throw new ArgumentNullException(nameof(destinationType)); + } + + if (destinationType == typeof(InstanceDescriptor) && value is ForceUnit) + { + MethodInfo method = typeof(ForceUnit).GetMethod(nameof(ForceUnit.Parse), new Type[] { typeof(string) }); + if (method != null) + { + var args = new object[] { ((ForceUnit)value).Symbol }; + return new InstanceDescriptor(method, args); + } + } + + return base.ConvertTo(context, culture, value, destinationType); + } + } +} \ No newline at end of file diff --git a/Gu.Units/FrequencyUnitTypeConverter.generated.cs b/Gu.Units/FrequencyUnitTypeConverter.generated.cs new file mode 100644 index 00000000..f92ad770 --- /dev/null +++ b/Gu.Units/FrequencyUnitTypeConverter.generated.cs @@ -0,0 +1,88 @@ +namespace Gu.Units +{ + using System; + using System.ComponentModel; + using System.ComponentModel.Design.Serialization; + using System.Globalization; + using System.Reflection; + + /// + /// Provides a type converter to convert + /// objects to and from various + /// other representations. + /// + public class FrequencyUnitTypeConverter : TypeConverter + { + /// + /// Gets a value indicating whether this converter can + /// convert an object in the given source type to a object using the + /// specified context. + /// + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) + { + if (sourceType == typeof(string)) + { + return true; + } + + return base.CanConvertFrom(context, sourceType); + } + + /// + /// Gets a value indicating whether this converter can + /// convert an object to the given destination type using the context. + /// + public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) + { + if (destinationType == typeof(InstanceDescriptor)) + { + return true; + } + + return base.CanConvertTo(context, destinationType); + } + + /// + /// Converts the given object to a + /// object. + /// + public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) + { + var text = value as string; + if (text != null) + { + text = text.Trim(); + return FrequencyUnit.Parse(text); + } + + return base.ConvertFrom(context, culture, value); + } + + /// + /// Converts the given object to another type. The most common types to convert + /// are to and from a string object. The default implementation will make a call + /// to ToString on the object if the object is valid and if the destination + /// type is string. If this cannot convert to the type, this will + /// throw a NotSupportedException. + /// + public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) + { + if (destinationType == null) + { + throw new ArgumentNullException(nameof(destinationType)); + } + + if (destinationType == typeof(InstanceDescriptor) && value is FrequencyUnit) + { + MethodInfo method = typeof(FrequencyUnit).GetMethod(nameof(FrequencyUnit.Parse), new Type[] { typeof(string) }); + if (method != null) + { + var args = new object[] { ((FrequencyUnit)value).Symbol }; + return new InstanceDescriptor(method, args); + } + } + + return base.ConvertTo(context, culture, value, destinationType); + } + } +} \ No newline at end of file diff --git a/Gu.Units/Gu.Units.csproj b/Gu.Units/Gu.Units.csproj index 22f8a7fe..4d2de08f 100644 --- a/Gu.Units/Gu.Units.csproj +++ b/Gu.Units/Gu.Units.csproj @@ -46,88 +46,121 @@ QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 UnitGenerator.txt4 + + UnitTypeConverterGenerator.txt4 + QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 UnitGenerator.txt4 + + UnitTypeConverterGenerator.txt4 + QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 UnitGenerator.txt4 + + UnitTypeConverterGenerator.txt4 + QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 UnitGenerator.txt4 + + UnitTypeConverterGenerator.txt4 + QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 UnitGenerator.txt4 + + UnitTypeConverterGenerator.txt4 + QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 UnitGenerator.txt4 + + UnitTypeConverterGenerator.txt4 + QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 UnitGenerator.txt4 + + UnitTypeConverterGenerator.txt4 + QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 + + + UnitTypeConverterGenerator.txt4 QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 + + + UnitTypeConverterGenerator.txt4 QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 + + + UnitTypeConverterGenerator.txt4 QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 + + + UnitTypeConverterGenerator.txt4 EnumerableGenerator.txt4 @@ -136,25 +169,37 @@ QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 + + + UnitTypeConverterGenerator.txt4 QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 + + + UnitTypeConverterGenerator.txt4 QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 + + + UnitTypeConverterGenerator.txt4 QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 + + + UnitTypeConverterGenerator.txt4 @@ -162,83 +207,122 @@ QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 UnitGenerator.txt4 + + UnitTypeConverterGenerator.txt4 + QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 + + + UnitTypeConverterGenerator.txt4 QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 + + + UnitTypeConverterGenerator.txt4 QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 + + + UnitTypeConverterGenerator.txt4 QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 + + + UnitTypeConverterGenerator.txt4 QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 + + + UnitTypeConverterGenerator.txt4 QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 + + + UnitTypeConverterGenerator.txt4 QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 + + + UnitTypeConverterGenerator.txt4 QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 + + + UnitTypeConverterGenerator.txt4 QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 + + + UnitTypeConverterGenerator.txt4 QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 + + + UnitTypeConverterGenerator.txt4 QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 + + + UnitTypeConverterGenerator.txt4 QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 + + + UnitTypeConverterGenerator.txt4 @@ -308,11 +392,14 @@ QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 UnitGenerator.txt4 + + UnitTypeConverterGenerator.txt4 + @@ -322,11 +409,14 @@ QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 UnitGenerator.txt4 + + UnitTypeConverterGenerator.txt4 + QuantityGenerator.txt4 @@ -334,24 +424,31 @@ QuantityGenerator.txt4 - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 UnitGenerator.txt4 + + UnitTypeConverterGenerator.txt4 + - TypeConverterGenerator.txt4 + QuantityTypeConverterGenerator.txt4 UnitGenerator.txt4 + + UnitTypeConverterGenerator.txt4 + - + +