diff --git a/ExtendedWPFToolkitSolution/ExtendedWPFToolkit.sln b/ExtendedWPFToolkitSolution/ExtendedWPFToolkit.sln index 8b521022..a1c6307a 100644 --- a/ExtendedWPFToolkitSolution/ExtendedWPFToolkit.sln +++ b/ExtendedWPFToolkitSolution/ExtendedWPFToolkit.sln @@ -30,6 +30,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.Modules.ChildWindow EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.Modules.Color", "Src\Samples\Modules\Samples.Modules.Color\Samples.Modules.Color.csproj", "{A36AB9C9-D813-4018-B341-8729A9B5BD7D}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.Modules.DataGrid", "Src\Samples\Modules\Samples.Modules.DataGrid\Samples.Modules.DataGrid.csproj", "{129477D9-F413-495F-BE05-D049575BC16C}" +EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.Modules.DateTime", "Src\Samples\Modules\Samples.Modules.DateTime\Samples.Modules.DateTime.csproj", "{CAB850B9-1D47-4F45-A6A5-07B48599B5D7}" EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.Modules.Numeric", "Src\Samples\Modules\Samples.Modules.Numeric\Samples.Modules.Numeric.csproj", "{CBED4977-79ED-4E46-AA00-0A4D83D333A6}" @@ -54,6 +56,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.Modules.Magnifier", EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.Modules.MessageBox", "Src\Samples\Modules\Samples.Modules.MessageBox\Samples.Modules.MessageBox.csproj", "{C324395B-C1D1-407B-8745-4AAC39B8BFD9}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Xceed.Wpf.DataGrid", "Src\Xceed.Wpf.DataGrid\Xceed.Wpf.DataGrid.csproj", "{63648392-6CE9-4A60-96D4-F9FD718D29B0}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -254,6 +258,26 @@ Global {C324395B-C1D1-407B-8745-4AAC39B8BFD9}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU {C324395B-C1D1-407B-8745-4AAC39B8BFD9}.Release|Mixed Platforms.Build.0 = Release|Any CPU {C324395B-C1D1-407B-8745-4AAC39B8BFD9}.Release|x86.ActiveCfg = Release|Any CPU + {63648392-6CE9-4A60-96D4-F9FD718D29B0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {63648392-6CE9-4A60-96D4-F9FD718D29B0}.Debug|Any CPU.Build.0 = Debug|Any CPU + {63648392-6CE9-4A60-96D4-F9FD718D29B0}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {63648392-6CE9-4A60-96D4-F9FD718D29B0}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {63648392-6CE9-4A60-96D4-F9FD718D29B0}.Debug|x86.ActiveCfg = Debug|Any CPU + {63648392-6CE9-4A60-96D4-F9FD718D29B0}.Release|Any CPU.ActiveCfg = Release|Any CPU + {63648392-6CE9-4A60-96D4-F9FD718D29B0}.Release|Any CPU.Build.0 = Release|Any CPU + {63648392-6CE9-4A60-96D4-F9FD718D29B0}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {63648392-6CE9-4A60-96D4-F9FD718D29B0}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {63648392-6CE9-4A60-96D4-F9FD718D29B0}.Release|x86.ActiveCfg = Release|Any CPU + {129477D9-F413-495F-BE05-D049575BC16C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {129477D9-F413-495F-BE05-D049575BC16C}.Debug|Any CPU.Build.0 = Debug|Any CPU + {129477D9-F413-495F-BE05-D049575BC16C}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {129477D9-F413-495F-BE05-D049575BC16C}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {129477D9-F413-495F-BE05-D049575BC16C}.Debug|x86.ActiveCfg = Debug|Any CPU + {129477D9-F413-495F-BE05-D049575BC16C}.Release|Any CPU.ActiveCfg = Release|Any CPU + {129477D9-F413-495F-BE05-D049575BC16C}.Release|Any CPU.Build.0 = Release|Any CPU + {129477D9-F413-495F-BE05-D049575BC16C}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {129477D9-F413-495F-BE05-D049575BC16C}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {129477D9-F413-495F-BE05-D049575BC16C}.Release|x86.ActiveCfg = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -278,5 +302,6 @@ Global {910A7A19-DD9F-4989-A001-BD7E5BAD2FE8} = {F927B3FE-820C-4EE1-921F-D10D3AE287AE} {C3D3FFAD-2DA3-4142-8DE8-7045E347B63A} = {F927B3FE-820C-4EE1-921F-D10D3AE287AE} {C324395B-C1D1-407B-8745-4AAC39B8BFD9} = {F927B3FE-820C-4EE1-921F-D10D3AE287AE} + {129477D9-F413-495F-BE05-D049575BC16C} = {F927B3FE-820C-4EE1-921F-D10D3AE287AE} EndGlobalSection EndGlobal diff --git a/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.CheckLists/Views/HomeView.xaml b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.CheckLists/Views/HomeView.xaml index 8ce4243c..61eb908b 100644 --- a/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.CheckLists/Views/HomeView.xaml +++ b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.CheckLists/Views/HomeView.xaml @@ -129,7 +129,6 @@ - - + IsDropDownOpen="{Binding ElementName=_isDropDownOpen, Path=IsChecked, Mode=TwoWay}" /> - - - diff --git a/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.DataGrid/DataGridModule.cs b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.DataGrid/DataGridModule.cs new file mode 100644 index 00000000..739d1bd7 --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.DataGrid/DataGridModule.cs @@ -0,0 +1,46 @@ +/************************************************************************ + + Extended WPF Toolkit + + Copyright (C) 2010-2012 Xceed Software Inc. + + This program is provided to you under the terms of the Microsoft Public + License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license + + This program can be provided to you by Xceed Software Inc. under a + proprietary commercial license agreement for use in non-Open Source + projects. The commercial version of Extended WPF Toolkit also includes + priority technical support, commercial updates, and many additional + useful WPF controls if you license Xceed Business Suite for WPF. + + Visit http://xceed.com and follow @datagrid on Twitter. + + **********************************************************************/ + +using Microsoft.Practices.Prism.Regions; +using Microsoft.Practices.Unity; +using Samples.Infrastructure; +using Samples.Infrastructure.Extensions; +using Samples.Modules.DataGrid.Views; + +namespace Samples.Modules.DataGrid +{ + public class DataGridModule : ModuleBase + { + public DataGridModule( IUnityContainer container, IRegionManager regionManager ) + : base( container, regionManager ) + { + } + + protected override void InitializeModule() + { + RegionManager.RegisterViewWithRegion( RegionNames.NavigationRegion, typeof( NavigationView ) ); + } + + protected override void RegisterViewsAndTypes() + { + Container.RegisterNavigationType( typeof( HomeView ) ); + Container.RegisterNavigationType( typeof( FullVersion ) ); + } + } +} diff --git a/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.DataGrid/Properties/AssemblyInfo.cs b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.DataGrid/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..b629e124 --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.DataGrid/Properties/AssemblyInfo.cs @@ -0,0 +1,72 @@ +/************************************************************************ + + Extended WPF Toolkit + + Copyright (C) 2010-2012 Xceed Software Inc. + + This program is provided to you under the terms of the Microsoft Public + License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license + + This program can be provided to you by Xceed Software Inc. under a + proprietary commercial license agreement for use in non-Open Source + projects. The commercial version of Extended WPF Toolkit also includes + priority technical support, commercial updates, and many additional + useful WPF controls if you license Xceed Business Suite for WPF. + + Visit http://xceed.com and follow @datagrid on Twitter. + + **********************************************************************/ + +using System.Reflection; +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( "Extended WPF Toolkit DataGrid Sample" )] +[assembly: AssemblyDescription( "" )] +[assembly: AssemblyConfiguration( "" )] +[assembly: AssemblyCompany( "Xceed Software Inc." )] +[assembly: AssemblyProduct( "Extended WPF Toolkit DataGrid Sample" )] +[assembly: AssemblyCopyright( "Copyright © Xceed Software Inc. 2010-2012" )] +[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/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.DataGrid/Samples.Modules.DataGrid.csproj b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.DataGrid/Samples.Modules.DataGrid.csproj new file mode 100644 index 00000000..bdaad47d --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.DataGrid/Samples.Modules.DataGrid.csproj @@ -0,0 +1,116 @@ + + + + Debug + AnyCPU + 8.0.30703 + 2.0 + {129477D9-F413-495F-BE05-D049575BC16C} + library + Properties + Samples.Modules.DataGrid + Samples.Modules.DataGrid + v4.0 + Client + 512 + {60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + 4 + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + ..\..\..\..\Libs\Prism\Microsoft.Practices.Prism.dll + + + ..\..\..\..\Libs\Prism\Microsoft.Practices.Unity.dll + + + + + + + + + + 4.0 + + + + + + ..\..\..\..\Libs\Xceed.Wpf.DataGrid.Samples.SampleData.dll + + + + + Code + + + FullVersion.xaml + + + HomeView.xaml + + + NavigationView.xaml + + + + + Code + + + + + + {63648392-6CE9-4A60-96D4-F9FD718D29B0} + Xceed.Wpf.DataGrid + + + {A4A049A4-665A-4651-9046-7D06E9D0CCDC} + Samples.Infrastructure + + + + + MSBuild:Compile + Designer + + + MSBuild:Compile + Designer + + + MSBuild:Compile + Designer + + + + + xcopy "$(TargetDir)*.*" "$(SolutionDir)Src\Samples\Samples\bin\$(ConfigurationName)\" /Y +xcopy "$(ProjectDir)Views" "$(SolutionDir)Src\Samples\Samples\bin\$(ConfigurationName)\Samples\$(ProjectName)\" /s /Y /I + + + \ No newline at end of file diff --git a/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.DataGrid/Views/FullVersion.xaml b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.DataGrid/Views/FullVersion.xaml new file mode 100644 index 00000000..e2703f39 --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.DataGrid/Views/FullVersion.xaml @@ -0,0 +1,103 @@ + + + + + + + The full featured version of the DataGrid available commercially will provide + you with extended features like: + + + + Master Details + + + Filter Row + + + Insertion Row + + + Excel Auto-Filtering + + + Column Chooser + + + CardView, CompactCardView + + + 3DView, MultiSurfaceView + + + Statistical Functions and Summary row + + + Print, Print Preview + + + Export to Excel + + + Fixed Column Splitter UI element + + + Persist User Settings + + + Design time support in Visual Studio and Expression Blend + + + Comprehensive documentation fully integrated into Visual Studio + + + Includes a variety of VB.NET and C# sample applications to get you started + + + Office 2007 Themes: Blue, Black, and Silver + + + The Xceed Live Explorer theme + + + Includes Xceed 3D Views for WPF + + + And many more.... + + + + + + + + Click here for more details about the full featured DataGrid control. + + + + + diff --git a/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.DataGrid/Views/FullVersion.xaml.cs b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.DataGrid/Views/FullVersion.xaml.cs new file mode 100644 index 00000000..06fcdf64 --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.DataGrid/Views/FullVersion.xaml.cs @@ -0,0 +1,46 @@ +/************************************************************************ + + Extended WPF Toolkit + + Copyright (C) 2010-2012 Xceed Software Inc. + + This program is provided to you under the terms of the Microsoft Public + License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license + + This program can be provided to you by Xceed Software Inc. under a + proprietary commercial license agreement for use in non-Open Source + projects. The commercial version of Extended WPF Toolkit also includes + priority technical support, commercial updates, and many additional + useful WPF controls if you license Xceed Business Suite for WPF. + + Visit http://xceed.com and follow @datagrid on Twitter. + + **********************************************************************/ + +using Microsoft.Practices.Prism.Regions; +using Samples.Infrastructure.Controls; +using Xceed.Wpf.DataGrid.Samples.SampleData; +using System.Data; +using Xceed.Wpf.DataGrid; +using System.Diagnostics; + +namespace Samples.Modules.DataGrid.Views +{ + /// + /// Interaction logic for FullVersion.xaml + /// + [RegionMemberLifetime( KeepAlive = false )] + public partial class FullVersion : DemoView + { + public FullVersion() + { + InitializeComponent(); + } + + private void Hyperlink_RequestNavigate( object sender, System.Windows.Navigation.RequestNavigateEventArgs e ) + { + Process.Start( new ProcessStartInfo( e.Uri.AbsoluteUri ) ); + e.Handled = true; + } + } +} diff --git a/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.DataGrid/Views/HomeView.xaml b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.DataGrid/Views/HomeView.xaml new file mode 100644 index 00000000..61fb391e --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.DataGrid/Views/HomeView.xaml @@ -0,0 +1,54 @@ + + + +The experience Xceed DataGrid for WPF provides centers on its Tableflow view, which lets you take advantage of a stunning, shaded appearance and capabilities such as inertial smooth scrolling and animated full-column reordering—which mimic the physics of real-life movement. Add to that the datagrid’s zero-lag data virtualization, and you have the fastest WPF datagrid around—in performance and feel. + +It's rock-solid and time-tested, so you can trust it in your most important applications. Constantly evolving—no other datagrid is updated as often—it has more features than any other offering and a flexible, extensible object model. It also provides unbeatable performance by handling millions of rows and thousands of columns, and integrates easily into any WPF app. It’s easy to understand why it’s the most-adopted WPF datagrid available and used by Microsoft in Visual Studio 2010 and by IBM U2 in SystemBuilder 4GL (SB+)! + + + + + + + + + + + + + + + + + + + + diff --git a/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.DataGrid/Views/HomeView.xaml.cs b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.DataGrid/Views/HomeView.xaml.cs new file mode 100644 index 00000000..4c56b5e3 --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.DataGrid/Views/HomeView.xaml.cs @@ -0,0 +1,47 @@ +/************************************************************************ + + Extended WPF Toolkit + + Copyright (C) 2010-2012 Xceed Software Inc. + + This program is provided to you under the terms of the Microsoft Public + License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license + + This program can be provided to you by Xceed Software Inc. under a + proprietary commercial license agreement for use in non-Open Source + projects. The commercial version of Extended WPF Toolkit also includes + priority technical support, commercial updates, and many additional + useful WPF controls if you license Xceed Business Suite for WPF. + + Visit http://xceed.com and follow @datagrid on Twitter. + + **********************************************************************/ + +using Microsoft.Practices.Prism.Regions; +using Samples.Infrastructure.Controls; +using Xceed.Wpf.DataGrid.Samples.SampleData; +using System.Data; +using Xceed.Wpf.DataGrid; + +namespace Samples.Modules.DataGrid.Views +{ + /// + /// Interaction logic for HomeView.xaml + /// + [RegionMemberLifetime( KeepAlive = false )] + public partial class HomeView : DemoView + { + public HomeView() + { + this.Orders = DataProvider.GetNorthwindDataSet().Tables[ "Orders" ]; + InitializeComponent(); + } + + public DataTable Orders + { + get; + private set; + } + + } +} diff --git a/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.DataGrid/Views/NavigationView.xaml b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.DataGrid/Views/NavigationView.xaml new file mode 100644 index 00000000..ae1a7d56 --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.DataGrid/Views/NavigationView.xaml @@ -0,0 +1,32 @@ + + + + + + + - - + + + + + ShowAdvancedOptions="{Binding IsChecked, ElementName=_showAdvancedOptions}" + IsReadOnly="{Binding IsChecked, ElementName=_isReadOnly}"/> diff --git a/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.PropertyGrid/Views/HomeView.xaml.cs b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.PropertyGrid/Views/HomeView.xaml.cs index 3745fa8f..a0a8d253 100644 --- a/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.PropertyGrid/Views/HomeView.xaml.cs +++ b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.PropertyGrid/Views/HomeView.xaml.cs @@ -19,6 +19,7 @@ using Microsoft.Practices.Prism.Regions; using Samples.Infrastructure.Controls; +using System; namespace Samples.Modules.PropertyGrid.Views { @@ -32,5 +33,10 @@ namespace Samples.Modules.PropertyGrid.Views { InitializeComponent(); } + + private void OnButtonClick( object sender, EventArgs e ) + { + _propertyGrid.SelectedObject = sender; + } } } diff --git a/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Samples.Modules.Text.csproj b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Samples.Modules.Text.csproj index 33091a37..6ce027d8 100644 --- a/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Samples.Modules.Text.csproj +++ b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Samples.Modules.Text.csproj @@ -69,6 +69,9 @@ Code + + AutoSelectTextBoxView.xaml + HomeView.xaml @@ -90,6 +93,10 @@ + + MSBuild:Compile + Designer + MSBuild:Compile Designer diff --git a/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/TextModule.cs b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/TextModule.cs index 5f056680..1f0db4f1 100644 --- a/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/TextModule.cs +++ b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/TextModule.cs @@ -44,6 +44,7 @@ namespace Samples.Modules.Text Container.RegisterNavigationType( typeof( MultiLineTextEditorView ) ); Container.RegisterNavigationType( typeof( RichTextBoxView ) ); Container.RegisterNavigationType( typeof( WatermarkTextBoxView ) ); + Container.RegisterNavigationType( typeof( AutoSelectTextBoxView ) ); } } } diff --git a/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Views/AutoSelectTextBoxView.xaml b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Views/AutoSelectTextBoxView.xaml new file mode 100644 index 00000000..c6b4a4bb --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Views/AutoSelectTextBoxView.xaml @@ -0,0 +1,118 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + AutoSelectBehavior: + + Controled by the "AutoSelectBehavior" property, the content of the AutoSelectTextBox will be selected or not when the control get the focus. + + + AutoMoveFocus: + + Effect with "MaxLength" property: + + + Setting the "MaxLenght" of the text box allow the focus to move from the AutoSelectTextBox once the max lenght has been reached. + In the following "Telephone Number" fields, the "MaxLenght" property of the control has been set to 3, 3 and 4, respectively + + + + + + + + + + + + + + + + + Effect with Arrow keys + + + The "AutoMoveFocus" at true also allow to navigate the focus thru the controls using the arrow keys to move the focus up, down, left or right. + You are no longer limited to the "left-right" scenario of the "Tab, Shift-Tab" keys. + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/Editors/DecimalUpDownEditor.cs b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Views/AutoSelectTextBoxView.xaml.cs similarity index 66% rename from ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/Editors/DecimalUpDownEditor.cs rename to ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Views/AutoSelectTextBoxView.xaml.cs index b778bcfc..6a7dc340 100644 --- a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/Editors/DecimalUpDownEditor.cs +++ b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Views/AutoSelectTextBoxView.xaml.cs @@ -17,18 +17,20 @@ **********************************************************************/ -namespace Xceed.Wpf.Toolkit.PropertyGrid.Editors +using Microsoft.Practices.Prism.Regions; +using Samples.Infrastructure.Controls; + +namespace Samples.Modules.Text.Views { - public class DecimalUpDownEditor : TypeEditor + /// + /// Interaction logic for WatermarkTextBoxView.xaml + /// + [RegionMemberLifetime( KeepAlive = false )] + public partial class AutoSelectTextBoxView : DemoView { - protected override void SetControlProperties() - { - Editor.BorderThickness = new System.Windows.Thickness( 0 ); - } - - protected override void SetValueDependencyProperty() + public AutoSelectTextBoxView() { - ValueProperty = DecimalUpDown.ValueProperty; + InitializeComponent(); } } } diff --git a/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Views/MaskedTextBoxView.xaml b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Views/MaskedTextBoxView.xaml index b1171869..6aba50d4 100644 --- a/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Views/MaskedTextBoxView.xaml +++ b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Views/MaskedTextBoxView.xaml @@ -21,6 +21,8 @@ xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:sample="clr-namespace:Samples.Infrastructure.Controls;assembly=Samples.Infrastructure" xmlns:xctk="http://schemas.xceed.com/wpf/xaml/toolkit" + xmlns:osb="clr-namespace:Xceed.Wpf.Toolkit.Obselete;assembly=WPFToolkit.Extended" + xmlns:s="clr-namespace:System;assembly=mscorlib" Title="MaskedTextBox" Description="The MaskedTextBox control lets you display and edit values based on a mask."> @@ -43,10 +45,12 @@ - + - + @@ -60,23 +64,25 @@ - + - + - + - + + diff --git a/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Views/MaskedTextBoxView.xaml.cs b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Views/MaskedTextBoxView.xaml.cs index 8663bd8e..6d9ff25b 100644 --- a/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Views/MaskedTextBoxView.xaml.cs +++ b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Views/MaskedTextBoxView.xaml.cs @@ -31,6 +31,12 @@ namespace Samples.Modules.Text.Views public MaskedTextBoxView() { InitializeComponent(); + _mask.TextChanged += new System.Windows.Controls.TextChangedEventHandler( _mask_TextChanged ); + } + + void _mask_TextChanged( object sender, System.Windows.Controls.TextChangedEventArgs e ) + { + _maskedTextBox.Value = null; } } } diff --git a/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Views/MultiLineTextEditor.xaml b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Views/MultiLineTextEditor.xaml index 3ef1a469..70dc3365 100644 --- a/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Views/MultiLineTextEditor.xaml +++ b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Views/MultiLineTextEditor.xaml @@ -16,6 +16,7 @@ Visit http://xceed.com and follow @datagrid on Twitter. ********************************************************************--> + + Description="The MultiLineTextEditor is a TextBox that allows you to edit text that is too long to display in a regular TextBox. The popup is resizable to accommodate any text."> diff --git a/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Views/NavigationView.xaml b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Views/NavigationView.xaml index 37538b50..e18d7a31 100644 --- a/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Views/NavigationView.xaml +++ b/ExtendedWPFToolkitSolution/Src/Samples/Modules/Samples.Modules.Text/Views/NavigationView.xaml @@ -20,12 +20,14 @@ xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:views="clr-namespace:Samples.Modules.Text.Views" - Header="Text" Tag="{x:Type views:HomeView}"> + Header="Text" Tag="{x:Type views:HomeView}" + Style="{StaticResource newFeature}" > + + + diff --git a/ExtendedWPFToolkitSolution/Src/Samples/Samples/Samples.csproj b/ExtendedWPFToolkitSolution/Src/Samples/Samples/Samples.csproj index 21cf80f7..b37c4d80 100644 --- a/ExtendedWPFToolkitSolution/Src/Samples/Samples/Samples.csproj +++ b/ExtendedWPFToolkitSolution/Src/Samples/Samples/Samples.csproj @@ -87,6 +87,10 @@ + + {72E591D6-8F83-4D8C-8F67-9C325E623234} + WPFToolkit.Extended + {A4A049A4-665A-4651-9046-7D06E9D0CCDC} Samples.Infrastructure diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/AssemblyVersionInfo.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/AssemblyVersionInfo.cs index 74011485..45843ae6 100644 --- a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/AssemblyVersionInfo.cs +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/AssemblyVersionInfo.cs @@ -22,7 +22,7 @@ internal static class _XceedVersionInfo { [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields" )] - public const string BaseVersion = "1.7"; + public const string BaseVersion = "1.8"; [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields" )] public const string Version = BaseVersion + _XceedVersionInfoCommon.Build; diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/AutoSelectTextBox/Implementation/AutoSelectBehaviorEnum.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/AutoSelectTextBox/Implementation/AutoSelectBehaviorEnum.cs new file mode 100644 index 00000000..2340995d --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/AutoSelectTextBox/Implementation/AutoSelectBehaviorEnum.cs @@ -0,0 +1,31 @@ +/************************************************************************ + + Extended WPF Toolkit + + Copyright (C) 2010-2012 Xceed Software Inc. + + This program is provided to you under the terms of the Microsoft Public + License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license + + This program can be provided to you by Xceed Software Inc. under a + proprietary commercial license agreement for use in non-Open Source + projects. The commercial version of Extended WPF Toolkit also includes + priority technical support, commercial updates, and many additional + useful WPF controls if you license Xceed Business Suite for WPF. + + Visit http://xceed.com and follow @datagrid on Twitter. + + **********************************************************************/ + +using System; +using System.Collections.Generic; +using System.Text; + +namespace Xceed.Wpf.Toolkit +{ + public enum AutoSelectBehavior + { + Never, + OnFocus + } +} diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/AutoSelectTextBox/Implementation/AutoSelectTextBox.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/AutoSelectTextBox/Implementation/AutoSelectTextBox.cs new file mode 100644 index 00000000..87aa6d0b --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/AutoSelectTextBox/Implementation/AutoSelectTextBox.cs @@ -0,0 +1,301 @@ +/************************************************************************ + + Extended WPF Toolkit + + Copyright (C) 2010-2012 Xceed Software Inc. + + This program is provided to you under the terms of the Microsoft Public + License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license + + This program can be provided to you by Xceed Software Inc. under a + proprietary commercial license agreement for use in non-Open Source + projects. The commercial version of Extended WPF Toolkit also includes + priority technical support, commercial updates, and many additional + useful WPF controls if you license Xceed Business Suite for WPF. + + Visit http://xceed.com and follow @datagrid on Twitter. + + **********************************************************************/ + +using System.Windows.Controls; +using System.Windows.Input; +using System.Windows; +using System.Windows.Automation; +using Xceed.Wpf.Toolkit.Core.Utilities; + +namespace Xceed.Wpf.Toolkit +{ + public class AutoSelectTextBox : TextBox + { + static AutoSelectTextBox() + { + AutomationProperties.AutomationIdProperty.OverrideMetadata( typeof( AutoSelectTextBox ), new UIPropertyMetadata( "AutoSelectTextBox" ) ); + } + + #region AutoSelectBehavior PROPERTY + + public AutoSelectBehavior AutoSelectBehavior + { + get + { + return ( AutoSelectBehavior )GetValue( AutoSelectBehaviorProperty ); + } + set + { + SetValue( AutoSelectBehaviorProperty, value ); + } + } + + public static readonly DependencyProperty AutoSelectBehaviorProperty = + DependencyProperty.Register( "AutoSelectBehavior", typeof( AutoSelectBehavior ), typeof( AutoSelectTextBox ), + new UIPropertyMetadata( AutoSelectBehavior.Never ) ); + + #endregion AutoSelectBehavior PROPERTY + + #region AutoMoveFocus PROPERTY + + public bool AutoMoveFocus + { + get + { + return ( bool )GetValue( AutoMoveFocusProperty ); + } + set + { + SetValue( AutoMoveFocusProperty, value ); + } + } + + public static readonly DependencyProperty AutoMoveFocusProperty = + DependencyProperty.Register( "AutoMoveFocus", typeof( bool ), typeof( AutoSelectTextBox ), new UIPropertyMetadata( false ) ); + + #endregion AutoMoveFocus PROPERTY + + #region QueryMoveFocus EVENT + + public static readonly RoutedEvent QueryMoveFocusEvent = EventManager.RegisterRoutedEvent( "QueryMoveFocus", + RoutingStrategy.Bubble, + typeof( QueryMoveFocusEventHandler ), + typeof( AutoSelectTextBox ) ); + #endregion QueryMoveFocus EVENT + + protected override void OnPreviewKeyDown( KeyEventArgs e ) + { + if( !this.AutoMoveFocus ) + { + base.OnPreviewKeyDown( e ); + return; + } + + if( ( e.Key == Key.Left ) + && ( ( Keyboard.Modifiers == ModifierKeys.None ) + || ( Keyboard.Modifiers == ModifierKeys.Control ) ) ) + { + e.Handled = this.MoveFocusLeft(); + } + + if( ( e.Key == Key.Right ) + && ( ( Keyboard.Modifiers == ModifierKeys.None ) + || ( Keyboard.Modifiers == ModifierKeys.Control ) ) ) + { + e.Handled = this.MoveFocusRight(); + } + + if( ( ( e.Key == Key.Up ) || ( e.Key == Key.PageUp ) ) + && ( ( Keyboard.Modifiers == ModifierKeys.None ) + || ( Keyboard.Modifiers == ModifierKeys.Control ) ) ) + { + e.Handled = this.MoveFocusUp(); + } + + if( ( ( e.Key == Key.Down ) || ( e.Key == Key.PageDown ) ) + && ( ( Keyboard.Modifiers == ModifierKeys.None ) + || ( Keyboard.Modifiers == ModifierKeys.Control ) ) ) + { + e.Handled = this.MoveFocusDown(); + } + + base.OnPreviewKeyDown( e ); + } + + protected override void OnPreviewGotKeyboardFocus( KeyboardFocusChangedEventArgs e ) + { + base.OnPreviewGotKeyboardFocus( e ); + + if( this.AutoSelectBehavior == AutoSelectBehavior.OnFocus ) + { + // If the focus was not in one of our child ( or popup ), we select all the text. + if( !TreeHelper.IsDescendantOf( e.OldFocus as DependencyObject, this ) ) + this.SelectAll(); + } + } + + protected override void OnPreviewMouseLeftButtonDown( MouseButtonEventArgs e ) + { + base.OnPreviewMouseLeftButtonDown( e ); + + if( this.AutoSelectBehavior == AutoSelectBehavior.Never ) + return; + + if( this.IsKeyboardFocusWithin == false ) + { + this.Focus(); + e.Handled = true; + } + } + + protected override void OnTextChanged( TextChangedEventArgs e ) + { + base.OnTextChanged( e ); + + if( !this.AutoMoveFocus ) + return; + + if( ( this.Text.Length != 0 ) + && ( this.Text.Length == this.MaxLength ) + && ( this.CaretIndex == this.MaxLength ) ) + { + if( this.CanMoveFocus( FocusNavigationDirection.Right, true ) == true ) + { + FocusNavigationDirection direction = ( this.FlowDirection == FlowDirection.LeftToRight ) + ? FocusNavigationDirection.Right + : FocusNavigationDirection.Left; + + this.MoveFocus( new TraversalRequest( direction ) ); + } + } + } + + private bool CanMoveFocus( FocusNavigationDirection direction, bool reachedMax ) + { + QueryMoveFocusEventArgs e = new QueryMoveFocusEventArgs( direction, reachedMax ); + this.RaiseEvent( e ); + return e.CanMoveFocus; + } + + private bool MoveFocusLeft() + { + if( this.FlowDirection == FlowDirection.LeftToRight ) + { + //occurs only if the cursor is at the beginning of the text + if( ( this.CaretIndex == 0 ) && ( this.SelectionLength == 0 ) ) + { + if( ComponentCommands.MoveFocusBack.CanExecute( null, this ) ) + { + ComponentCommands.MoveFocusBack.Execute( null, this ); + return true; + } + else if( this.CanMoveFocus( FocusNavigationDirection.Left, false ) ) + { + this.MoveFocus( new TraversalRequest( FocusNavigationDirection.Left ) ); + return true; + } + } + } + else + { + //occurs only if the cursor is at the end of the text + if( ( this.CaretIndex == this.Text.Length ) && ( this.SelectionLength == 0 ) ) + { + if( ComponentCommands.MoveFocusBack.CanExecute( null, this ) ) + { + ComponentCommands.MoveFocusBack.Execute( null, this ); + return true; + } + else if( this.CanMoveFocus( FocusNavigationDirection.Left, false ) ) + { + this.MoveFocus( new TraversalRequest( FocusNavigationDirection.Left ) ); + return true; + } + } + } + + return false; + } + + private bool MoveFocusRight() + { + if( this.FlowDirection == FlowDirection.LeftToRight ) + { + //occurs only if the cursor is at the beginning of the text + if( ( this.CaretIndex == this.Text.Length ) && ( this.SelectionLength == 0 ) ) + { + if( ComponentCommands.MoveFocusForward.CanExecute( null, this ) ) + { + ComponentCommands.MoveFocusForward.Execute( null, this ); + return true; + } + else if( this.CanMoveFocus( FocusNavigationDirection.Right, false ) ) + { + this.MoveFocus( new TraversalRequest( FocusNavigationDirection.Right ) ); + return true; + } + } + } + else + { + //occurs only if the cursor is at the end of the text + if( ( this.CaretIndex == 0 ) && ( this.SelectionLength == 0 ) ) + { + if( ComponentCommands.MoveFocusForward.CanExecute( null, this ) ) + { + ComponentCommands.MoveFocusForward.Execute( null, this ); + return true; + } + else if( this.CanMoveFocus( FocusNavigationDirection.Right, false ) ) + { + this.MoveFocus( new TraversalRequest( FocusNavigationDirection.Right ) ); + return true; + } + } + } + + return false; + } + + private bool MoveFocusUp() + { + int lineNumber = this.GetLineIndexFromCharacterIndex( this.SelectionStart ); + + //occurs only if the cursor is on the first line + if( lineNumber == 0 ) + { + if( ComponentCommands.MoveFocusUp.CanExecute( null, this ) ) + { + ComponentCommands.MoveFocusUp.Execute( null, this ); + return true; + } + else if( this.CanMoveFocus( FocusNavigationDirection.Up, false ) ) + { + this.MoveFocus( new TraversalRequest( FocusNavigationDirection.Up ) ); + return true; + } + } + + return false; + } + + private bool MoveFocusDown() + { + int lineNumber = this.GetLineIndexFromCharacterIndex( this.SelectionStart ); + + //occurs only if the cursor is on the first line + if( lineNumber == ( this.LineCount - 1 ) ) + { + if( ComponentCommands.MoveFocusDown.CanExecute( null, this ) ) + { + ComponentCommands.MoveFocusDown.Execute( null, this ); + return true; + } + else if( this.CanMoveFocus( FocusNavigationDirection.Down, false ) ) + { + this.MoveFocus( new TraversalRequest( FocusNavigationDirection.Down ) ); + return true; + } + } + + return false; + } + } +} + diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/AutoSelectTextBox/Implementation/QueryMoveFocusEventArgs.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/AutoSelectTextBox/Implementation/QueryMoveFocusEventArgs.cs new file mode 100644 index 00000000..b77d1772 --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/AutoSelectTextBox/Implementation/QueryMoveFocusEventArgs.cs @@ -0,0 +1,76 @@ +/************************************************************************ + + Extended WPF Toolkit + + Copyright (C) 2010-2012 Xceed Software Inc. + + This program is provided to you under the terms of the Microsoft Public + License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license + + This program can be provided to you by Xceed Software Inc. under a + proprietary commercial license agreement for use in non-Open Source + projects. The commercial version of Extended WPF Toolkit also includes + priority technical support, commercial updates, and many additional + useful WPF controls if you license Xceed Business Suite for WPF. + + Visit http://xceed.com and follow @datagrid on Twitter. + + **********************************************************************/ + +using System.Windows; +using System.Windows.Input; + +namespace Xceed.Wpf.Toolkit +{ + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1003:UseGenericEventHandlerInstances" )] + public delegate void QueryMoveFocusEventHandler( object sender, QueryMoveFocusEventArgs e ); + + public class QueryMoveFocusEventArgs : RoutedEventArgs + { + //default CTOR private to prevent its usage. + private QueryMoveFocusEventArgs() + { + } + + //internal to prevent anybody from building this type of event. + internal QueryMoveFocusEventArgs( FocusNavigationDirection direction, bool reachedMaxLength ) + : base( AutoSelectTextBox.QueryMoveFocusEvent ) + { + m_navigationDirection = direction; + m_reachedMaxLength = reachedMaxLength; + } + + public FocusNavigationDirection FocusNavigationDirection + { + get + { + return m_navigationDirection; + } + } + + public bool ReachedMaxLength + { + get + { + return m_reachedMaxLength; + } + } + + public bool CanMoveFocus + { + get + { + return m_canMove; + } + set + { + m_canMove = value; + } + } + + private FocusNavigationDirection m_navigationDirection; + private bool m_reachedMaxLength; + private bool m_canMove = true; //defaults to true... if nobody does nothing, then its capable of moving focus. + + } +} diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/CheckComboBox/Implementation/CheckComboBox.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/CheckComboBox/Implementation/CheckComboBox.cs index be17afce..1b06dc3c 100644 --- a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/CheckComboBox/Implementation/CheckComboBox.cs +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/CheckComboBox/Implementation/CheckComboBox.cs @@ -22,11 +22,14 @@ using System.Linq; using System.Windows; using System.Windows.Input; using Xceed.Wpf.Toolkit.Primitives; +using Xceed.Wpf.Toolkit.Core.Utilities; namespace Xceed.Wpf.Toolkit { public class CheckComboBox : Selector { + private ValueChangeHelper _displayMemberPathValuesChangeHelper; + #region Constructors static CheckComboBox() @@ -37,6 +40,7 @@ namespace Xceed.Wpf.Toolkit public CheckComboBox() { Mouse.AddPreviewMouseDownOutsideCapturedElementHandler( this, OnMouseDownOutsideCapturedElement ); + _displayMemberPathValuesChangeHelper = new ValueChangeHelper( this.OnDisplayMemberPathValuesChanged ); } #endregion //Constructors @@ -98,7 +102,13 @@ namespace Xceed.Wpf.Toolkit protected override void OnDisplayMemberPathChanged( string oldDisplayMemberPath, string newDisplayMemberPath ) { base.OnDisplayMemberPathChanged( oldDisplayMemberPath, newDisplayMemberPath ); - UpdateText(); + this.UpdateDisplayMemberPathValuesBindings(); + } + + protected override void OnItemsSourceChanged( System.Collections.IEnumerable oldValue, System.Collections.IEnumerable newValue ) + { + base.OnItemsSourceChanged( oldValue, newValue ); + this.UpdateDisplayMemberPathValuesBindings(); } #endregion //Base Class Overrides @@ -114,6 +124,16 @@ namespace Xceed.Wpf.Toolkit #region Methods + private void UpdateDisplayMemberPathValuesBindings() + { + _displayMemberPathValuesChangeHelper.UpdateValueSource( ItemsCollection, this.DisplayMemberPath ); + } + + private void OnDisplayMemberPathValuesChanged() + { + this.UpdateText(); + } + private void UpdateText() { #if VS2008 diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/ColorCanvas/Implementation/ColorCanvas.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/ColorCanvas/Implementation/ColorCanvas.cs index 01a0031c..d0303af0 100644 --- a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/ColorCanvas/Implementation/ColorCanvas.cs +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/ColorCanvas/Implementation/ColorCanvas.cs @@ -25,17 +25,20 @@ using System.Windows.Media; using Xceed.Wpf.Toolkit.Core.Utilities; using Xceed.Wpf.Toolkit.Primitives; using System.IO; +using System; namespace Xceed.Wpf.Toolkit { [TemplatePart( Name = PART_ColorShadingCanvas, Type = typeof( Canvas ) )] [TemplatePart( Name = PART_ColorShadeSelector, Type = typeof( Canvas ) )] [TemplatePart( Name = PART_SpectrumSlider, Type = typeof( ColorSpectrumSlider ) )] + [TemplatePart( Name = PART_HexadecimalTextBox, Type = typeof( TextBox ) )] public class ColorCanvas : Control { private const string PART_ColorShadingCanvas = "PART_ColorShadingCanvas"; private const string PART_ColorShadeSelector = "PART_ColorShadeSelector"; private const string PART_SpectrumSlider = "PART_SpectrumSlider"; + private const string PART_HexadecimalTextBox = "PART_HexadecimalTextBox"; #region Private Members @@ -43,6 +46,7 @@ namespace Xceed.Wpf.Toolkit private Canvas _colorShadingCanvas; private Canvas _colorShadeSelector; private ColorSpectrumSlider _spectrumSlider; + private TextBox _hexadecimalTextBox; private Point? _currentColorPosition; private bool _surpressPropertyChanged; @@ -74,7 +78,7 @@ namespace Xceed.Wpf.Toolkit protected virtual void OnSelectedColorChanged( Color oldValue, Color newValue ) { - HexadecimalString = GetFormatedColorString( newValue ); + SetHexadecimalStringProperty( GetFormatedColorString( newValue ), false ); UpdateRGBValues( newValue ); UpdateColorShadeSelectorPosition( newValue ); @@ -237,6 +241,8 @@ namespace Xceed.Wpf.Toolkit string currentColorString = GetFormatedColorString( SelectedColor ); if( !currentColorString.Equals( newColorString ) ) UpdateSelectedColor( ( Color )ColorConverter.ConvertFromString( newColorString ) ); + + SetHexadecimalTextBoxTextProperty( newValue ); } private static object OnCoerceHexadecimalString( DependencyObject d, object basevalue ) @@ -251,16 +257,19 @@ namespace Xceed.Wpf.Toolkit private object OnCoerceHexadecimalString( object newValue ) { var value = newValue as string; + string retValue = value; + try { ColorConverter.ConvertFromString( value ); } catch { + //When HexadecimalString is changed via Code-Behind and hexadecimal format is bad, throw. throw new InvalidDataException( "Color provided is not in the correct format." ); } - return value; + return retValue; } #endregion //HexadecimalString @@ -289,7 +298,7 @@ namespace Xceed.Wpf.Toolkit protected virtual void OnUsingAlphaChannelChanged() { - HexadecimalString = GetFormatedColorString( SelectedColor ); + SetHexadecimalStringProperty( GetFormatedColorString( SelectedColor ), false ); } #endregion //UsingAlphaChannel @@ -342,17 +351,31 @@ namespace Xceed.Wpf.Toolkit if( _spectrumSlider != null ) _spectrumSlider.ValueChanged += SpectrumSlider_ValueChanged; + if( _hexadecimalTextBox != null ) + _hexadecimalTextBox.LostFocus -= new RoutedEventHandler( HexadecimalTextBox_LostFocus ); + + _hexadecimalTextBox = GetTemplateChild( PART_HexadecimalTextBox ) as TextBox; + + if( _hexadecimalTextBox != null ) + _hexadecimalTextBox.LostFocus += new RoutedEventHandler( HexadecimalTextBox_LostFocus ); + UpdateRGBValues( SelectedColor ); UpdateColorShadeSelectorPosition( SelectedColor ); + + // When changing theme, HexadecimalString needs to be set since it is not binded. + SetHexadecimalTextBoxTextProperty( GetFormatedColorString( SelectedColor ) ); } - protected override void OnPreviewKeyDown( KeyEventArgs e ) + protected override void OnKeyDown( KeyEventArgs e ) { - //hitting enter on textbox will update value of underlying source + base.OnKeyDown( e ); + + //hitting enter on textbox will update Hexadecimal string if( e.Key == Key.Enter && e.OriginalSource is TextBox ) { - BindingExpression be = ( ( TextBox )e.OriginalSource ).GetBindingExpression( TextBox.TextProperty ); - be.UpdateSource(); + TextBox textBox = ( TextBox )e.OriginalSource; + if( textBox.Name == PART_HexadecimalTextBox ) + SetHexadecimalStringProperty( textBox.Text, true ); } } @@ -404,6 +427,12 @@ namespace Xceed.Wpf.Toolkit } } + void HexadecimalTextBox_LostFocus( object sender, RoutedEventArgs e ) + { + TextBox textbox = sender as TextBox; + SetHexadecimalStringProperty( textbox.Text, true ); + } + #endregion //Event Handlers #region Events @@ -503,7 +532,7 @@ namespace Xceed.Wpf.Toolkit var currentColor = ColorUtilities.ConvertHsvToRgb( hsv.H, hsv.S, hsv.V ); currentColor.A = A; SelectedColor = currentColor; - HexadecimalString = GetFormatedColorString( SelectedColor ); + SetHexadecimalStringProperty( GetFormatedColorString( SelectedColor ), false ); } private string GetFormatedColorString( Color colorToFormat ) @@ -516,6 +545,34 @@ namespace Xceed.Wpf.Toolkit return ColorUtilities.FormatColorString( stringToFormat, UsingAlphaChannel ); } + private void SetHexadecimalStringProperty( string newValue, bool modifyFromUI ) + { + if( modifyFromUI ) + { + try + { + ColorConverter.ConvertFromString( newValue ); + HexadecimalString = newValue; + } + catch + { + //When HexadecimalString is changed via UI and hexadecimal format is bad, keep the previous HexadecimalString. + SetHexadecimalTextBoxTextProperty( HexadecimalString ); + } + } + else + { + //When HexadecimalString is changed via Code-Behind, hexadecimal format will be evaluated in OnCoerceHexadecimalString() + HexadecimalString = newValue; + } + } + + private void SetHexadecimalTextBoxTextProperty( string newValue ) + { + if( _hexadecimalTextBox != null ) + _hexadecimalTextBox.Text = newValue; + } + #endregion //Methods } } diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/ColorCanvas/Themes/Generic.xaml b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/ColorCanvas/Themes/Generic.xaml index 7164d0a0..4bb44947 100644 --- a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/ColorCanvas/Themes/Generic.xaml +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/ColorCanvas/Themes/Generic.xaml @@ -260,7 +260,7 @@ - + diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/ColorPicker/Implementation/ColorPicker.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/ColorPicker/Implementation/ColorPicker.cs index 42aca48a..899743e0 100644 --- a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/ColorPicker/Implementation/ColorPicker.cs +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/ColorPicker/Implementation/ColorPicker.cs @@ -343,7 +343,7 @@ namespace Xceed.Wpf.Toolkit { return ( bool )GetValue( UsingAlphaChannelProperty ); } - protected set + set { SetValue( UsingAlphaChannelProperty, value ); } diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Converters/WizardPageButtonVisibilityConverter.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Converters/WizardPageButtonVisibilityConverter.cs index 1c8bc7a9..317fafbf 100644 --- a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Converters/WizardPageButtonVisibilityConverter.cs +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Converters/WizardPageButtonVisibilityConverter.cs @@ -28,7 +28,9 @@ namespace Xceed.Wpf.Toolkit.Core.Converters public object Convert( object[] values, Type targetType, object parameter, System.Globalization.CultureInfo culture ) { Visibility wizardVisibility = ( Visibility )values[ 0 ]; - WizardPageButtonVisibility wizardPageVisibility = ( WizardPageButtonVisibility )values[ 1 ]; + WizardPageButtonVisibility wizardPageVisibility = ( (values[ 1 ] == null) || (values[ 1 ] == DependencyProperty.UnsetValue) ) + ? WizardPageButtonVisibility.Hidden + : ( WizardPageButtonVisibility )values[ 1 ]; Visibility visibility = Visibility.Visible; diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Input/IValidateInput.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Input/IValidateInput.cs new file mode 100644 index 00000000..15d600da --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Input/IValidateInput.cs @@ -0,0 +1,32 @@ +/************************************************************************ + + Extended WPF Toolkit + + Copyright (C) 2010-2012 Xceed Software Inc. + + This program is provided to you under the terms of the Microsoft Public + License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license + + This program can be provided to you by Xceed Software Inc. under a + proprietary commercial license agreement for use in non-Open Source + projects. The commercial version of Extended WPF Toolkit also includes + priority technical support, commercial updates, and many additional + useful WPF controls if you license Xceed Business Suite for WPF. + + Visit http://xceed.com and follow @datagrid on Twitter. + + **********************************************************************/ + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace Xceed.Wpf.Toolkit.Core.Input +{ + public interface IValidateInput + { + event InputValidationErrorEventHandler InputValidationError; + void CommitInput(); + } +} diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Input/InputValidationErrorEventArgs.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Input/InputValidationErrorEventArgs.cs new file mode 100644 index 00000000..312c90ce --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Input/InputValidationErrorEventArgs.cs @@ -0,0 +1,46 @@ +/************************************************************************ + + Extended WPF Toolkit + + Copyright (C) 2010-2012 Xceed Software Inc. + + This program is provided to you under the terms of the Microsoft Public + License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license + + This program can be provided to you by Xceed Software Inc. under a + proprietary commercial license agreement for use in non-Open Source + projects. The commercial version of Extended WPF Toolkit also includes + priority technical support, commercial updates, and many additional + useful WPF controls if you license Xceed Business Suite for WPF. + + Visit http://xceed.com and follow @datagrid on Twitter. + + **********************************************************************/ + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace Xceed.Wpf.Toolkit.Core.Input +{ + public delegate void InputValidationErrorEventHandler( object sender, InputValidationErrorEventArgs e ); + + public class InputValidationErrorEventArgs : EventArgs + { + public InputValidationErrorEventArgs( string errorMsg ) + { + _errorMessage = errorMsg; + } + + public string ErrorMessage + { + get + { + return _errorMessage; + } + } + + private string _errorMessage; + } +} diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Primitives/CachedTextInfo.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Primitives/CachedTextInfo.cs new file mode 100644 index 00000000..d887ffb8 --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Primitives/CachedTextInfo.cs @@ -0,0 +1,57 @@ +/************************************************************************ + + Extended WPF Toolkit + + Copyright (C) 2010-2012 Xceed Software Inc. + + This program is provided to you under the terms of the Microsoft Public + License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license + + This program can be provided to you by Xceed Software Inc. under a + proprietary commercial license agreement for use in non-Open Source + projects. The commercial version of Extended WPF Toolkit also includes + priority technical support, commercial updates, and many additional + useful WPF controls if you license Xceed Business Suite for WPF. + + Visit http://xceed.com and follow @datagrid on Twitter. + + **********************************************************************/ + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Windows.Controls; + +namespace Xceed.Wpf.Toolkit.Primitives +{ + internal class CachedTextInfo : ICloneable + { + private CachedTextInfo( string text, int caretIndex, int selectionStart, int selectionLength ) + { + this.Text = text; + this.CaretIndex = caretIndex; + this.SelectionStart = selectionStart; + this.SelectionLength = selectionLength; + } + + public CachedTextInfo( TextBox textBox ) + : this( textBox.Text, textBox.CaretIndex, textBox.SelectionStart, textBox.SelectionLength ) + { + } + + public string Text { get; private set; } + public int CaretIndex { get; private set; } + public int SelectionStart { get; private set; } + public int SelectionLength { get; private set; } + + #region ICloneable Members + + public object Clone() + { + return new CachedTextInfo( this.Text, this.CaretIndex, this.SelectionStart, this.SelectionLength ); + } + + #endregion + } +} diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Primitives/Selector.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Primitives/Selector.cs index f8cfcd3f..12c902f4 100644 --- a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Primitives/Selector.cs +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Primitives/Selector.cs @@ -26,16 +26,28 @@ using System.Windows; using System.Windows.Controls; using System.Windows.Data; using System.Windows.Input; +using System.Collections.Generic; +using System.Collections.Specialized; +using System.Reflection; +using Xceed.Wpf.Toolkit.Core.Utilities; namespace Xceed.Wpf.Toolkit.Primitives { - public class Selector : ItemsControl //should probably make this control an ICommandSource + public class Selector : ItemsControl, IWeakEventListener //should probably make this control an ICommandSource { #region Members - private bool _ignoreSetSelectedValue; - private bool _surpressSelectionChanged; - private bool _surpressSelectedValueChanged; + private bool _surpressItemSelectionChanged; + private bool _ignoreSelectedItemChanged; + private bool _ignoreSelectedValueChanged; + private int _ignoreSelectedItemsCollectionChanged; + private int _ignoreSelectedMemberPathValuesChanged; + private IList _selectedItems; + + private ValueChangeHelper _selectedMemberPathValuesHelper; + private ValueChangeHelper _valueMemberPathValuesHelper; + + #endregion //Members @@ -43,9 +55,11 @@ namespace Xceed.Wpf.Toolkit.Primitives public Selector() { - SelectedItems = new ObservableCollection(); - AddHandler( Selector.SelectedEvent, new RoutedEventHandler( Selector_ItemSelected ) ); - AddHandler( Selector.UnSelectedEvent, new RoutedEventHandler( Selector_ItemUnselected ) ); + this.SelectedItems = new ObservableCollection(); + AddHandler( Selector.SelectedEvent, new RoutedEventHandler( ( s, args ) => this.OnItemSelectionChangedCore( args, false ) ) ); + AddHandler( Selector.UnSelectedEvent, new RoutedEventHandler( ( s, args ) => this.OnItemSelectionChangedCore( args, true ) ) ); + _selectedMemberPathValuesHelper = new ValueChangeHelper( this.OnSelectedMemberPathValuesChanged ); + _valueMemberPathValuesHelper = new ValueChangeHelper( this.OnValueMemberPathValuesChanged ); } #endregion //Constructors @@ -88,7 +102,9 @@ namespace Xceed.Wpf.Toolkit.Primitives #endregion - public static readonly DependencyProperty SelectedItemProperty = DependencyProperty.Register( "SelectedItem", typeof( object ), typeof( Selector ), new UIPropertyMetadata( null ) ); + #region SelectedItem property + + public static readonly DependencyProperty SelectedItemProperty = DependencyProperty.Register( "SelectedItem", typeof( object ), typeof( Selector ), new UIPropertyMetadata( null, OnSelectedItemChanged ) ); public object SelectedItem { get @@ -101,22 +117,91 @@ namespace Xceed.Wpf.Toolkit.Primitives } } - //Since you cannot data bind to ReadOnly DependencyProperty, I am leaving this a public get/set DP. This will allow you to data bind to the SelectedItems from a ViewModel, but it is - //intended to be ReadOnly. So you MUST set the binding Mode=OneWayToSource. Otherwise it will not behave as expected. - public static readonly DependencyProperty SelectedItemsProperty = DependencyProperty.Register( "SelectedItems", typeof( IList ), typeof( Selector ), new UIPropertyMetadata( null ) ); + private static void OnSelectedItemChanged( DependencyObject sender, DependencyPropertyChangedEventArgs args ) + { + ( ( Selector )sender ).OnSelectedItemChanged( args.OldValue, args.NewValue ); + } + + private void OnSelectedItemChanged( object oldValue, object newValue ) + { + if( _ignoreSelectedItemChanged ) + return; + + _ignoreSelectedItemsCollectionChanged++; + SelectedItems.Clear(); + if( newValue != null ) + { + SelectedItems.Add( newValue ); + } + this.UpdateFromSelectedItems(); + _ignoreSelectedItemsCollectionChanged--; + } + + #endregion + + #region SelectedItems Property + public IList SelectedItems { get { - return ( IList )GetValue( SelectedItemsProperty ); + return _selectedItems; + } + private set + { + if( value == null ) + throw new ArgumentNullException( "value" ); + + INotifyCollectionChanged oldCollection = _selectedItems as INotifyCollectionChanged; + INotifyCollectionChanged newCollection = value as INotifyCollectionChanged; + + if( oldCollection != null ) + { + CollectionChangedEventManager.RemoveListener( oldCollection, this ); + } + + if( newCollection != null ) + { + CollectionChangedEventManager.AddListener( newCollection, this ); + } + + _selectedItems = value; + + this.UpdateFromSelectedItems(); + } + } + + #endregion SelectedItems + + + #region SelectedItemsOverride property + + public static readonly DependencyProperty SelectedItemsOverrideProperty = DependencyProperty.Register( "SelectedItemsOverride", typeof( IList ), typeof( Selector ), new UIPropertyMetadata( null, SelectedItemsOverrideChanged ) ); + public IList SelectedItemsOverride + { + get + { + return ( IList )GetValue( SelectedItemsOverrideProperty ); } set { - SetValue( SelectedItemsProperty, value ); + SetValue( SelectedItemsOverrideProperty, value ); } } - public static readonly DependencyProperty SelectedMemberPathProperty = DependencyProperty.Register( "SelectedMemberPath", typeof( string ), typeof( Selector ), new UIPropertyMetadata( null ) ); + private static void SelectedItemsOverrideChanged( DependencyObject sender, DependencyPropertyChangedEventArgs args ) + { + ( ( Selector )sender ).OnSelectedItemsOverrideChanged( ( IList )args.OldValue, ( IList )args.NewValue ); + } + + private void OnSelectedItemsOverrideChanged( IList oldValue, IList newValue ) + { + this.SelectedItems = ( newValue != null ) ? newValue : new ObservableCollection(); + } + + #endregion + + public static readonly DependencyProperty SelectedMemberPathProperty = DependencyProperty.Register( "SelectedMemberPath", typeof( string ), typeof( Selector ), new UIPropertyMetadata( null, OnSelectedMemberPathChanged ) ); public string SelectedMemberPath { get @@ -129,6 +214,11 @@ namespace Xceed.Wpf.Toolkit.Primitives } } + private static void OnSelectedMemberPathChanged( DependencyObject o, DependencyPropertyChangedEventArgs e ) + { + ( ( Selector )o ).UpdateSelectedMemberPathValuesBindings(); + } + #region SelectedValue public static readonly DependencyProperty SelectedValueProperty = DependencyProperty.Register( "SelectedValue", typeof( string ), typeof( Selector ), new FrameworkPropertyMetadata( null, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnSelectedValueChanged ) ); @@ -153,10 +243,10 @@ namespace Xceed.Wpf.Toolkit.Primitives protected virtual void OnSelectedValueChanged( string oldValue, string newValue ) { - if( _surpressSelectedValueChanged ) + if( _ignoreSelectedValueChanged ) return; - UpdateSelectedItemsFromSelectedValue(); + UpdateFromSelectedValue(); } #endregion //SelectedValue @@ -178,7 +268,20 @@ namespace Xceed.Wpf.Toolkit.Primitives private static void OnValueMemberPathChanged( DependencyObject o, DependencyPropertyChangedEventArgs e ) { - ( ( Selector )o ).UpdateSelectedValue(); + + ( ( Selector )o ).UpdateValueMemberPathValuesBindings(); + } + + #endregion + + #region ItemsCollection Property + + protected IEnumerable ItemsCollection + { + get + { + return ItemsSource ?? ( ( IEnumerable )Items ?? ( IEnumerable )new object[ 0 ] ); + } } #endregion @@ -199,79 +302,65 @@ namespace Xceed.Wpf.Toolkit.Primitives protected override void PrepareContainerForItemOverride( DependencyObject element, object item ) { - _surpressSelectionChanged = true; + base.PrepareContainerForItemOverride( element, item ); + + _surpressItemSelectionChanged = true; var selectorItem = element as FrameworkElement; - //first try resolving SelectorItem.IsSelected by data binding to the SelectedMemeberPath property - if( !String.IsNullOrEmpty( SelectedMemberPath ) ) + selectorItem.SetValue( SelectorItem.IsSelectedProperty, SelectedItems.Contains(item) ); + + _surpressItemSelectionChanged = false; + } + + protected override void OnItemsSourceChanged( IEnumerable oldValue, IEnumerable newValue ) + { + base.OnItemsSourceChanged( oldValue, newValue ); + + var oldCollection = oldValue as INotifyCollectionChanged; + var newCollection = newValue as INotifyCollectionChanged; + + if( oldCollection != null ) { - Binding selectedBinding = new Binding( SelectedMemberPath ) - { - Mode = BindingMode.TwoWay, - Source = item - }; - selectorItem.SetBinding( SelectorItem.IsSelectedProperty, selectedBinding ); + CollectionChangedEventManager.RemoveListener( oldCollection, this ); } - //now let's search the SelectedItems for the current item. If it's there then mark it as selected - if( SelectedItems != null ) + if( newCollection != null ) { - foreach( object selectedItem in SelectedItems ) - { - //a match was found so select it and get the hell out of here - if( item.Equals( selectedItem ) ) - { - selectorItem.SetValue( SelectorItem.IsSelectedProperty, true ); - break; - } - } + CollectionChangedEventManager.AddListener( newCollection, this ); } - base.PrepareContainerForItemOverride( element, item ); - _surpressSelectionChanged = false; + this.RemoveUnavailableSelectedItems(); + this.UpdateSelectedMemberPathValuesBindings(); + this.UpdateValueMemberPathValuesBindings(); } #endregion //Base Class Overrides #region Events - public static readonly RoutedEvent SelectedEvent = EventManager.RegisterRoutedEvent( "SelectedEvent", RoutingStrategy.Bubble, typeof( SelectedItemChangedEventHandler ), typeof( Selector ) ); - public static readonly RoutedEvent UnSelectedEvent = EventManager.RegisterRoutedEvent( "UnSelectedEvent", RoutingStrategy.Bubble, typeof( SelectedItemChangedEventHandler ), typeof( Selector ) ); + public static readonly RoutedEvent SelectedEvent = EventManager.RegisterRoutedEvent( "SelectedEvent", RoutingStrategy.Bubble, typeof( RoutedEventHandler ), typeof( Selector ) ); + public static readonly RoutedEvent UnSelectedEvent = EventManager.RegisterRoutedEvent( "UnSelectedEvent", RoutingStrategy.Bubble, typeof( RoutedEventHandler ), typeof( Selector ) ); - public static readonly RoutedEvent SelectedItemChangedEvent = EventManager.RegisterRoutedEvent( "SelectedItemChanged", RoutingStrategy.Bubble, typeof( SelectedItemChangedEventHandler ), typeof( Selector ) ); - public event SelectedItemChangedEventHandler SelectedItemChanged + public static readonly RoutedEvent ItemSelectionChangedEvent = EventManager.RegisterRoutedEvent( "ItemSelectionChanged", RoutingStrategy.Bubble, typeof( ItemSelectionChangedEventHandler ), typeof( Selector ) ); + public event ItemSelectionChangedEventHandler ItemSelectionChanged { add { - AddHandler( SelectedItemChangedEvent, value ); + AddHandler( ItemSelectionChangedEvent, value ); } remove { - RemoveHandler( SelectedItemChangedEvent, value ); + RemoveHandler( ItemSelectionChangedEvent, value ); } } #endregion //Events - #region Event Handlers - - protected virtual void Selector_ItemSelected( object sender, RoutedEventArgs e ) - { - OnItemSelected( e.OriginalSource, false ); - } - - protected virtual void Selector_ItemUnselected( object sender, RoutedEventArgs e ) - { - OnItemSelected( e.OriginalSource, true ); - } - - #endregion //Event Handlers - #region Methods protected object GetItemValue( object item ) { - if( !String.IsNullOrEmpty( ValueMemberPath ) && (item != null)) + if( !String.IsNullOrEmpty( ValueMemberPath ) && ( item != null ) ) { var property = item.GetType().GetProperty( ValueMemberPath ); if( property != null ) @@ -281,49 +370,86 @@ namespace Xceed.Wpf.Toolkit.Primitives return item; } - protected string GetDelimitedValue( object value ) + protected object ResolveItemByValue( string value ) { - return String.Format( "{0}{1}", value, Delimiter ); + if( !String.IsNullOrEmpty( ValueMemberPath ) ) + { + foreach( object item in ItemsCollection ) + { + var property = item.GetType().GetProperty( ValueMemberPath ); + if( property != null ) + { + var propertyValue = property.GetValue( item, null ); + if( value.Equals( propertyValue.ToString(), StringComparison.InvariantCultureIgnoreCase ) ) + return item; + } + } + } + + return value; } - protected virtual void OnItemSelected( object itemContainer, bool remove ) + private bool? GetSelectedMemberPathValue( object item ) { - object item = this.ItemContainerGenerator.ItemFromContainer( ( DependencyObject )itemContainer ); - Update( item, remove ); - RaiseSelectedItemChangedEvent( item, !remove ); //inverse the remove paramter to correctly reflect the IsSelected state + PropertyInfo prop = this.GetSelectedMemberPathProperty(item); + + return ( prop != null ) + ? ( bool )prop.GetValue( item, null ) + : ( bool? )null; } - protected virtual void RaiseSelectedItemChangedEvent( object item, bool isSelected ) + private void SetSelectedMemberPathValue( object item, bool value ) { - if( _surpressSelectionChanged ) - return; - - RaiseEvent( new SelectedItemChangedEventArgs( Selector.SelectedItemChangedEvent, this, item, isSelected ) ); + PropertyInfo prop = this.GetSelectedMemberPathProperty(item); - if( Command != null ) - Command.Execute( item ); + if( prop != null ) + { + prop.SetValue( item, value, null ); + } } - protected virtual void Update( object item, bool remove ) + private PropertyInfo GetSelectedMemberPathProperty(object item) { - UpdateSelectedItem( item ); - UpdateSelectedItems( item, remove ); - UpdateSelectedValue(); + PropertyInfo propertyInfo = null; + if( !String.IsNullOrEmpty( SelectedMemberPath ) && ( item != null ) ) + { + var property = item.GetType().GetProperty( SelectedMemberPath ); + if( property != null && property.PropertyType == typeof( bool ) ) + { + propertyInfo = property; + } + } + + return propertyInfo; } - private void UpdateSelectedItem( object item ) + /// + /// When SelectedItems collection implements INotifyPropertyChanged, this is the callback. + /// + /// + /// + private void OnSelectedItemsCollectionChanged( object sender, NotifyCollectionChangedEventArgs e ) { - SelectedItem = item; + if( _ignoreSelectedItemsCollectionChanged > 0 ) + return; + + // Keep it simple for now. Just update all + this.UpdateFromSelectedItems(); } - private void UpdateSelectedItems( object item, bool remove ) + private void OnItemSelectionChangedCore( RoutedEventArgs args, bool unselected ) { - if( SelectedItems == null ) - SelectedItems = new ObservableCollection(); + object item = this.ItemContainerGenerator.ItemFromContainer( ( DependencyObject )args.OriginalSource ); - if( remove ) + // When the item is it's own container, "UnsetValue" will be returned. + if( item == DependencyProperty.UnsetValue ) { - if( SelectedItems.Contains( item ) ) + item = args.OriginalSource; + } + + if( unselected ) + { + while( SelectedItems.Contains( item ) ) SelectedItems.Remove( item ); } else @@ -331,116 +457,263 @@ namespace Xceed.Wpf.Toolkit.Primitives if( !SelectedItems.Contains( item ) ) SelectedItems.Add( item ); } + + OnItemSelectionChanged( + new ItemSelectionChangedEventArgs( Selector.ItemSelectionChangedEvent, this, item, !unselected ) ); } - private void UpdateSelectedValue() + /// + /// When the ItemsSource implements INotifyPropertyChanged, this is the change callback. + /// + /// + /// + private void OnItemsSourceCollectionChanged( object sender, NotifyCollectionChangedEventArgs args ) { - //get out of here if we don't want to set the SelectedValue - if( _ignoreSetSelectedValue ) + this.RemoveUnavailableSelectedItems(); + this.UpdateSelectedMemberPathValuesBindings(); + this.UpdateValueMemberPathValuesBindings(); + } + + /// + /// This is called when any value of any item referenced by SelectedMemberPath + /// is modified. This may affect the SelectedItems collection. + /// + private void OnSelectedMemberPathValuesChanged() + { + if( _ignoreSelectedMemberPathValuesChanged > 0 ) return; - _surpressSelectedValueChanged = true; + this.UpdateFromSelectedMemberPathValues(); + } + + /// + /// This is called when any value of any item referenced by ValueMemberPath + /// is modified. This will affect the SelectedValue property + /// + private void OnValueMemberPathValuesChanged() + { + this.UpdateSelectedValue(); + } + + private void UpdateSelectedMemberPathValuesBindings() + { + _selectedMemberPathValuesHelper.UpdateValueSource( ItemsCollection, SelectedMemberPath ); + } + + private void UpdateValueMemberPathValuesBindings() + { + _valueMemberPathValuesHelper.UpdateValueSource( ItemsCollection, ValueMemberPath ); + } + /// + /// This method will be called when the "IsSelected" property of an SelectorItem + /// has been modified. + /// + /// + protected virtual void OnItemSelectionChanged( ItemSelectionChangedEventArgs args ) + { + if( _surpressItemSelectionChanged ) + return; + + RaiseEvent( args ); + + if( Command != null ) + Command.Execute( args.Item ); + } + + /// + /// Updates the SelectedValue property based on what is present in the SelectedItems property. + /// + private void UpdateSelectedValue() + { #if VS2008 string newValue = String.Join( Delimiter, SelectedItems.Cast().Select( x => GetItemValue( x ).ToString() ).ToArray() ); #else string newValue = String.Join( Delimiter, SelectedItems.Cast().Select( x => GetItemValue( x ) ) ); #endif if( String.IsNullOrEmpty( SelectedValue ) || !SelectedValue.Equals( newValue ) ) + { + _ignoreSelectedValueChanged = true; SelectedValue = newValue; - - _surpressSelectedValueChanged = false; + _ignoreSelectedValueChanged = false; + } } - private void UpdateSelectedItemsFromSelectedValue() + /// + /// Updates the SelectedItem property based on what is present in the SelectedItems property. + /// + private void UpdateSelectedItem() { - _surpressSelectionChanged = true; - - //first we have to unselect everything - ClearSelectedItems(); + if( !SelectedItems.Contains( SelectedItem ) ) + { + _ignoreSelectedItemChanged = true; + SelectedItem = ( SelectedItems.Count > 0 ) ? SelectedItems[ 0 ] : null; + _ignoreSelectedItemChanged = false; + } + } - if( !String.IsNullOrEmpty( SelectedValue ) ) + /// + /// Update the SelectedItems collection based on the values + /// refered to by the SelectedMemberPath property. + /// + private void UpdateFromSelectedMemberPathValues() + { + _ignoreSelectedItemsCollectionChanged++; + foreach( var item in ItemsCollection ) { - string[] values = SelectedValue.Split( new string[] { Delimiter }, StringSplitOptions.RemoveEmptyEntries ); - foreach( string value in values ) + bool? isSelected = this.GetSelectedMemberPathValue( item ); + if( isSelected != null ) { - var item = ResolveItemByValue( value ); - - if( item != null ) + if( isSelected.Value ) { - SelectedItems.Add( item ); - - //now try to select it in the list - var selectorItem = ItemContainerGenerator.ContainerFromItem( item ) as SelectorItem; - if( selectorItem != null ) + if( !SelectedItems.Contains( item ) ) + { + SelectedItems.Add( item ); + } + } + else + { + if( SelectedItems.Contains( item ) ) { - if( !selectorItem.IsSelected ) - selectorItem.IsSelected = true; + SelectedItems.Remove( item ); } } } } - - _surpressSelectionChanged = false; + _ignoreSelectedItemsCollectionChanged--; + this.UpdateFromSelectedItems(); } - private void ClearSelectedItems() + /// + /// Updates the following based on the content of SelectedItems: + /// - All SelectorItems "IsSelected" properties + /// - Values refered to by SelectedMemberPath + /// - SelectedItem property + /// - SelectedValue property + /// Refered to by the SelectedMemberPath property. + /// + private void UpdateFromSelectedItems() { - if( SelectedItems != null ) - SelectedItems.Clear(); - else - SelectedItems = new ObservableCollection(); + foreach( object o in ItemsCollection ) + { + bool isSelected = SelectedItems.Contains( o ); - UnselectAllInternal(); + _ignoreSelectedMemberPathValuesChanged++; + this.SetSelectedMemberPathValue(o, isSelected); + _ignoreSelectedMemberPathValuesChanged--; + + var selectorItem = ItemContainerGenerator.ContainerFromItem( o ) as SelectorItem; + if( selectorItem != null ) + { + selectorItem.IsSelected = isSelected; + } + } + + UpdateSelectedItem(); + UpdateSelectedValue(); } - private void UnselectAllInternal() + /// + /// Removes all items from SelectedItems that are no longer in ItemsSource. + /// + private void RemoveUnavailableSelectedItems() { - _ignoreSetSelectedValue = true; + _ignoreSelectedItemsCollectionChanged++; + HashSet hash = new HashSet( ItemsCollection.Cast() ); - if( ItemsSource != null ) + for( int i = 0; i < SelectedItems.Count; i++ ) { - foreach( object item in ItemsSource ) + if( !hash.Contains( SelectedItems[ i ] ) ) { - var selectorItem = ItemContainerGenerator.ContainerFromItem( item ) as SelectorItem; - if( selectorItem != null ) - { - if( selectorItem.IsSelected ) - selectorItem.IsSelected = false; - } + SelectedItems.RemoveAt( i ); + i--; } } + _ignoreSelectedItemsCollectionChanged--; - _ignoreSetSelectedValue = false; + UpdateSelectedItem(); + UpdateSelectedValue(); } - protected object ResolveItemByValue( string value ) + /// + /// Updates the SelectedItems collection based on the content of + /// the SelectedValue property. + /// + private void UpdateFromSelectedValue() { - if( !String.IsNullOrEmpty( ValueMemberPath ) ) + _ignoreSelectedItemsCollectionChanged++; + // Just update the SelectedItems collection content + // and let the synchronization be made from UpdateFromSelectedItems(); + SelectedItems.Clear(); + + if( !String.IsNullOrEmpty( SelectedValue ) ) { - if( ItemsSource != null ) + List selectedValues = SelectedValue.Split( new string[] { Delimiter }, StringSplitOptions.RemoveEmptyEntries ).ToList(); + ValueEqualityComparer comparer = new ValueEqualityComparer(); + + foreach( object item in ItemsCollection ) { - foreach( object item in ItemsSource ) + object itemValue = this.GetItemValue( item ); + + bool isSelected = ( itemValue != null ) + && selectedValues.Contains( itemValue.ToString(), comparer ); + + if( isSelected ) { - var property = item.GetType().GetProperty( ValueMemberPath ); - if( property != null ) - { - var propertyValue = property.GetValue( item, null ); - if( value.Equals( propertyValue.ToString(), StringComparison.InvariantCultureIgnoreCase ) ) - return item; - } + SelectedItems.Add( item ); } } } + _ignoreSelectedItemsCollectionChanged--; - return value; + this.UpdateFromSelectedItems(); } #endregion //Methods + + #region IWeakEventListener Members + + public bool ReceiveWeakEvent( Type managerType, object sender, EventArgs e ) + { + if( managerType == typeof( CollectionChangedEventManager ) ) + { + if( object.ReferenceEquals( _selectedItems, sender ) ) + { + this.OnSelectedItemsCollectionChanged( sender, ( NotifyCollectionChangedEventArgs )e ); + return true; + } + else if( object.ReferenceEquals( ItemsCollection, sender ) ) + { + this.OnItemsSourceCollectionChanged( sender, ( NotifyCollectionChangedEventArgs )e ); + } + } + + return false; + } + + #endregion + + #region ValueEqualityComparer private class + + private class ValueEqualityComparer : IEqualityComparer + { + public bool Equals( string x, string y ) + { + return string.Equals( x, y, StringComparison.InvariantCultureIgnoreCase ); + } + + public int GetHashCode( string obj ) + { + return 1; + } + } + + #endregion } - public delegate void SelectedItemChangedEventHandler( object sender, SelectedItemChangedEventArgs e ); - public class SelectedItemChangedEventArgs : RoutedEventArgs + + public delegate void ItemSelectionChangedEventHandler( object sender, ItemSelectionChangedEventArgs e ); + public class ItemSelectionChangedEventArgs : RoutedEventArgs { public bool IsSelected { @@ -453,7 +726,7 @@ namespace Xceed.Wpf.Toolkit.Primitives private set; } - public SelectedItemChangedEventArgs( RoutedEvent routedEvent, object source, object item, bool isSelected ) + public ItemSelectionChangedEventArgs( RoutedEvent routedEvent, object source, object item, bool isSelected ) : base( routedEvent, source ) { Item = item; diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Primitives/SelectorItem.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Primitives/SelectorItem.cs index ab70ae5b..9996902e 100644 --- a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Primitives/SelectorItem.cs +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Primitives/SelectorItem.cs @@ -64,9 +64,9 @@ namespace Xceed.Wpf.Toolkit.Primitives protected virtual void OnIsSelectedChanged( bool oldValue, bool newValue ) { if( newValue ) - RaiseSelectionChangedEvent( new RoutedEventArgs( Selector.SelectedEvent, this ) ); + this.RaiseEvent( new RoutedEventArgs( Selector.SelectedEvent, this ) ); else - RaiseSelectionChangedEvent( new RoutedEventArgs( Selector.UnSelectedEvent, this ) ); + this.RaiseEvent( new RoutedEventArgs( Selector.UnSelectedEvent, this ) ); } internal Selector ParentSelector @@ -95,13 +95,5 @@ namespace Xceed.Wpf.Toolkit.Primitives #endregion //Event Hanlders - #region Methods - - private void RaiseSelectionChangedEvent( RoutedEventArgs e ) - { - base.RaiseEvent( e ); - } - - #endregion //Methods } } diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Primitives/UpDownBase.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Primitives/UpDownBase.cs index 86893750..021995d8 100644 --- a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Primitives/UpDownBase.cs +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Primitives/UpDownBase.cs @@ -22,12 +22,14 @@ using System.Windows; using System.Windows.Controls; using System.Windows.Data; using System.Windows.Input; +using Xceed.Wpf.Toolkit.Core; +using Xceed.Wpf.Toolkit.Core.Input; namespace Xceed.Wpf.Toolkit.Primitives { [TemplatePart( Name = PART_TextBox, Type = typeof( TextBox ) )] [TemplatePart( Name = PART_Spinner, Type = typeof( Spinner ) )] - public abstract class UpDownBase : InputBase + public abstract class UpDownBase : InputBase, IValidateInput { #region Members @@ -45,6 +47,7 @@ namespace Xceed.Wpf.Toolkit.Primitives /// Flags if the Text and Value properties are in the process of being sync'd /// private bool _isSyncingTextAndValueProperties; + private bool _isTextChangedFromUI; #endregion //Members @@ -114,7 +117,7 @@ namespace Xceed.Wpf.Toolkit.Primitives #region Value - public static readonly DependencyProperty ValueProperty = DependencyProperty.Register( "Value", typeof( T ), typeof( UpDownBase ), new FrameworkPropertyMetadata( default( T ), FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnValueChanged, null, false, UpdateSourceTrigger.LostFocus ) ); + public static readonly DependencyProperty ValueProperty = DependencyProperty.Register( "Value", typeof( T ), typeof( UpDownBase ), new FrameworkPropertyMetadata( default( T ), FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnValueChanged, OnCoerceValue, false, UpdateSourceTrigger.LostFocus ) ); public T Value { get @@ -127,6 +130,16 @@ namespace Xceed.Wpf.Toolkit.Primitives } } + private static object OnCoerceValue( DependencyObject o, object basevalue ) + { + return ( ( UpDownBase )o ).OnCoerceValue( basevalue ); + } + + protected virtual object OnCoerceValue( object newValue ) + { + return newValue; + } + private static void OnValueChanged( DependencyObject o, DependencyPropertyChangedEventArgs e ) { UpDownBase upDownBase = o as UpDownBase; @@ -136,9 +149,7 @@ namespace Xceed.Wpf.Toolkit.Primitives protected virtual void OnValueChanged( T oldValue, T newValue ) { - ValidateValue( newValue ); - - SyncTextAndValueProperties( ValueProperty, string.Empty ); + SyncTextAndValueProperties( false, null ); SetValidSpinDirection(); @@ -174,6 +185,12 @@ namespace Xceed.Wpf.Toolkit.Primitives base.OnApplyTemplate(); TextBox = GetTemplateChild( PART_TextBox ) as TextBox; + if( TextBox != null ) + { + TextBox.Text = Text; + TextBox.LostFocus += new RoutedEventHandler( TextBox_LostFocus ); + TextBox.TextChanged += new TextChangedEventHandler( TextBox_TextChanged ); + } if( Spinner != null ) Spinner.Spin -= OnSpinnerSpin; @@ -213,6 +230,20 @@ namespace Xceed.Wpf.Toolkit.Primitives } } + protected override void OnKeyDown( KeyEventArgs e ) + { + switch( e.Key ) + { + case Key.Enter: + { + // Commit Text on "Enter" to raise Error event + CommitInput(); + e.Handled = true; + break; + } + } + } + protected override void OnMouseWheel( MouseWheelEventArgs e ) { base.OnMouseWheel( e ); @@ -234,7 +265,10 @@ namespace Xceed.Wpf.Toolkit.Primitives protected override void OnTextChanged( string oldValue, string newValue ) { - SyncTextAndValueProperties( InputBase.TextProperty, newValue ); + if( !_isTextChangedFromUI ) + { + SyncTextAndValueProperties( true, Text ); + } } #endregion //Base Class Overrides @@ -251,6 +285,10 @@ namespace Xceed.Wpf.Toolkit.Primitives #region Events + public event InputValidationErrorEventHandler InputValidationError; + + #region ValueChanged Event + //Due to a bug in Visual Studio, you cannot create event handlers for generic T args in XAML, so I have to use object instead. public static readonly RoutedEvent ValueChangedEvent = EventManager.RegisterRoutedEvent( "ValueChanged", RoutingStrategy.Bubble, typeof( RoutedPropertyChangedEventHandler ), typeof( UpDownBase ) ); public event RoutedPropertyChangedEventHandler ValueChanged @@ -265,6 +303,8 @@ namespace Xceed.Wpf.Toolkit.Primitives } } + #endregion + #endregion //Events #region Methods @@ -302,38 +342,65 @@ namespace Xceed.Wpf.Toolkit.Primitives } } - protected void SyncTextAndValueProperties( DependencyProperty p, string text ) + private void TextBox_TextChanged( object sender, TextChangedEventArgs e ) + { + _isTextChangedFromUI = true; + + TextBox textBox = sender as TextBox; + Text = textBox.Text; + + _isTextChangedFromUI = false; + } + + private void TextBox_LostFocus( object sender, RoutedEventArgs e ) + { + CommitInput(); + } + + public void CommitInput() + { + this.SyncTextAndValueProperties( true, Text ); + } + + protected void SyncTextAndValueProperties(bool updateValueFromText, string text ) { - //prevents recursive syncing properties if( _isSyncingTextAndValueProperties ) return; _isSyncingTextAndValueProperties = true; + Exception error = null; - //this only occures when the user typed in the value - if( InputBase.TextProperty == p ) + if( updateValueFromText ) { - Value = ConvertTextToValue( text ); + try + { + Value = ConvertTextToValue( Text ); + } + catch( Exception e ) + { + error = e; + } } Text = ConvertValueToText(); -#if VS2008 - //there is a bug in .NET 3.5 which will not correctly update the textbox text through binding. - if ( TextBox != null ) + if( TextBox != null ) TextBox.Text = Text; -#endif + + if( updateValueFromText ) + { + if( ( error != null ) && ( InputValidationError != null ) ) + { + InputValidationErrorEventArgs args = new InputValidationErrorEventArgs( error.Message ); + InputValidationError( this, args ); + } + } _isSyncingTextAndValueProperties = false; } #region Abstract - /// - /// Coerces the value. - /// - protected abstract T CoerceValue( T value ); - /// /// Converts the formatted text to a value. /// @@ -360,12 +427,6 @@ namespace Xceed.Wpf.Toolkit.Primitives /// protected abstract void SetValidSpinDirection(); - /// - /// Validates the value and keeps it between the Min and Max values. - /// - /// The value. - protected abstract void ValidateValue( T value ); - #endregion //Abstract #endregion //Methods diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Primitives/ValueRangeTextBox.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Primitives/ValueRangeTextBox.cs new file mode 100644 index 00000000..7fcf8019 --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Primitives/ValueRangeTextBox.cs @@ -0,0 +1,1192 @@ +/************************************************************************ + + Extended WPF Toolkit + + Copyright (C) 2010-2012 Xceed Software Inc. + + This program is provided to you under the terms of the Microsoft Public + License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license + + This program can be provided to you by Xceed Software Inc. under a + proprietary commercial license agreement for use in non-Open Source + projects. The commercial version of Extended WPF Toolkit also includes + priority technical support, commercial updates, and many additional + useful WPF controls if you license Xceed Business Suite for WPF. + + Visit http://xceed.com and follow @datagrid on Twitter. + + **********************************************************************/ + +using System; +using System.Collections.Generic; +using System.Text; +using System.Windows.Controls; +using System.Windows; +using System.Collections; +using System.Reflection; +using System.Windows.Input; +using System.Windows.Documents; +using System.Globalization; +using Microsoft.Win32; +using System.ComponentModel; +using System.Collections.Specialized; +using System.Diagnostics; +using System.Windows.Automation; +using Xceed.Wpf.Toolkit; +using Xceed.Wpf.Toolkit.Core; + +namespace Xceed.Wpf.Toolkit.Primitives +{ + public class ValueRangeTextBox : AutoSelectTextBox + { + static ValueRangeTextBox() + { + ValueRangeTextBox.TextProperty.OverrideMetadata( typeof( ValueRangeTextBox ), + new FrameworkPropertyMetadata( + null, + new CoerceValueCallback( ValueRangeTextBox.TextCoerceValueCallback ) ) ); + + ValueRangeTextBox.AcceptsReturnProperty.OverrideMetadata( typeof( ValueRangeTextBox ), + new FrameworkPropertyMetadata( + false, null, new CoerceValueCallback( ValueRangeTextBox.AcceptsReturnCoerceValueCallback ) ) ); + + ValueRangeTextBox.AcceptsTabProperty.OverrideMetadata( typeof( ValueRangeTextBox ), + new FrameworkPropertyMetadata( + false, null, new CoerceValueCallback( ValueRangeTextBox.AcceptsTabCoerceValueCallback ) ) ); + + AutomationProperties.AutomationIdProperty.OverrideMetadata( typeof( ValueRangeTextBox ), new UIPropertyMetadata( "ValueRangeTextBox" ) ); + } + + public ValueRangeTextBox() + { + } + + #region AcceptsReturn Property + + private static object AcceptsReturnCoerceValueCallback( DependencyObject sender, object value ) + { + bool acceptsReturn = ( bool )value; + + if( acceptsReturn ) + throw new NotSupportedException( "The ValueRangeTextBox does not support the AcceptsReturn property." ); + + return false; + } + + #endregion AcceptsReturn Property + + #region AcceptsTab Property + + private static object AcceptsTabCoerceValueCallback( DependencyObject sender, object value ) + { + bool acceptsTab = ( bool )value; + + if( acceptsTab ) + throw new NotSupportedException( "The ValueRangeTextBox does not support the AcceptsTab property." ); + + return false; + } + + #endregion AcceptsTab Property + + #region BeepOnError Property + + public bool BeepOnError + { + get + { + return ( bool )GetValue( BeepOnErrorProperty ); + } + set + { + SetValue( BeepOnErrorProperty, value ); + } + } + + public static readonly DependencyProperty BeepOnErrorProperty = + DependencyProperty.Register( "BeepOnError", typeof( bool ), typeof( ValueRangeTextBox ), new UIPropertyMetadata( false ) ); + + #endregion BeepOnError Property + + #region FormatProvider Property + + public IFormatProvider FormatProvider + { + get + { + return ( IFormatProvider )GetValue( FormatProviderProperty ); + } + set + { + SetValue( FormatProviderProperty, value ); + } + } + + public static readonly DependencyProperty FormatProviderProperty = + DependencyProperty.Register( "FormatProvider", typeof( IFormatProvider ), typeof( ValueRangeTextBox ), + new UIPropertyMetadata( null, + new PropertyChangedCallback( ValueRangeTextBox.FormatProviderPropertyChangedCallback ) ) ); + + private static void FormatProviderPropertyChangedCallback( DependencyObject sender, DependencyPropertyChangedEventArgs e ) + { + ValueRangeTextBox valueRangeTextBox = ( ValueRangeTextBox )sender; + + if( !valueRangeTextBox.IsInitialized ) + return; + + valueRangeTextBox.OnFormatProviderChanged(); + } + + internal virtual void OnFormatProviderChanged() + { + this.RefreshConversionHelpers(); + this.RefreshCurrentText( false ); + this.RefreshValue(); + } + + #endregion FormatProvider Property + + #region MinValue Property + + public object MinValue + { + get + { + return ( object )GetValue( MinValueProperty ); + } + set + { + SetValue( MinValueProperty, value ); + } + } + + public static readonly DependencyProperty MinValueProperty = + DependencyProperty.Register( "MinValue", typeof( object ), typeof( ValueRangeTextBox ), + new UIPropertyMetadata( + null, + null, + new CoerceValueCallback( ValueRangeTextBox.MinValueCoerceValueCallback ) ) ); + + private static object MinValueCoerceValueCallback( DependencyObject sender, object value ) + { + ValueRangeTextBox valueRangeTextBox = sender as ValueRangeTextBox; + + if( !valueRangeTextBox.IsInitialized ) + return DependencyProperty.UnsetValue; + + if( value == null ) + return value; + + Type type = valueRangeTextBox.ValueDataType; + + if( type == null ) + throw new InvalidOperationException( "An attempt was made to set a minimum value when the ValueDataType property is null." ); + + if( valueRangeTextBox.IsFinalizingInitialization ) + value = ValueRangeTextBox.ConvertValueToDataType( value, valueRangeTextBox.ValueDataType ); + + if( value.GetType() != type ) + throw new ArgumentException( "The value is not of type " + type.Name + ".", "MinValue" ); + + IComparable comparable = value as IComparable; + + if( comparable == null ) + throw new InvalidOperationException( "MinValue does not implement the IComparable interface." ); + + // ValidateValueInRange will throw if it must. + object maxValue = valueRangeTextBox.MaxValue; + + valueRangeTextBox.ValidateValueInRange( value, maxValue, valueRangeTextBox.Value ); + + return value; + } + + #endregion MinValue Property + + #region MaxValue Property + + public object MaxValue + { + get + { + return ( object )GetValue( MaxValueProperty ); + } + set + { + SetValue( MaxValueProperty, value ); + } + } + + public static readonly DependencyProperty MaxValueProperty = + DependencyProperty.Register( "MaxValue", typeof( object ), typeof( ValueRangeTextBox ), + new UIPropertyMetadata( + null, + null, + new CoerceValueCallback( MaxValueCoerceValueCallback ) ) ); + + private static object MaxValueCoerceValueCallback( DependencyObject sender, object value ) + { + ValueRangeTextBox valueRangeTextBox = sender as ValueRangeTextBox; + + if( !valueRangeTextBox.IsInitialized ) + return DependencyProperty.UnsetValue; + + if( value == null ) + return value; + + Type type = valueRangeTextBox.ValueDataType; + + if( type == null ) + throw new InvalidOperationException( "An attempt was made to set a maximum value when the ValueDataType property is null." ); + + if( valueRangeTextBox.IsFinalizingInitialization ) + value = ValueRangeTextBox.ConvertValueToDataType( value, valueRangeTextBox.ValueDataType ); + + if( value.GetType() != type ) + throw new ArgumentException( "The value is not of type " + type.Name + ".", "MinValue" ); + + IComparable comparable = value as IComparable; + + if( comparable == null ) + throw new InvalidOperationException( "MaxValue does not implement the IComparable interface." ); + + object minValue = valueRangeTextBox.MinValue; + + // ValidateValueInRange will throw if it must. + valueRangeTextBox.ValidateValueInRange( minValue, value, valueRangeTextBox.Value ); + + return value; + } + + #endregion MaxValue Property + + #region NullValue Property + + public object NullValue + { + get + { + return ( object )GetValue( NullValueProperty ); + } + set + { + SetValue( NullValueProperty, value ); + } + } + + public static readonly DependencyProperty NullValueProperty = + DependencyProperty.Register( "NullValue", typeof( object ), typeof( ValueRangeTextBox ), + new UIPropertyMetadata( + null, + new PropertyChangedCallback( ValueRangeTextBox.NullValuePropertyChangedCallback ), + new CoerceValueCallback( NullValueCoerceValueCallback ) ) ); + + private static object NullValueCoerceValueCallback( DependencyObject sender, object value ) + { + ValueRangeTextBox valueRangeTextBox = sender as ValueRangeTextBox; + + if( !valueRangeTextBox.IsInitialized ) + return DependencyProperty.UnsetValue; + + if( ( value == null ) || ( value == DBNull.Value ) ) + return value; + + Type type = valueRangeTextBox.ValueDataType; + + if( type == null ) + throw new InvalidOperationException( "An attempt was made to set a null value when the ValueDataType property is null." ); + + if( valueRangeTextBox.IsFinalizingInitialization ) + value = ValueRangeTextBox.ConvertValueToDataType( value, valueRangeTextBox.ValueDataType ); + + if( value.GetType() != type ) + throw new ArgumentException( "The value is not of type " + type.Name + ".", "NullValue" ); + + return value; + } + + private static void NullValuePropertyChangedCallback( DependencyObject sender, DependencyPropertyChangedEventArgs e ) + { + ValueRangeTextBox valueRangeTextBox = sender as ValueRangeTextBox; + + if( e.OldValue == null ) + { + if( valueRangeTextBox.Value == null ) + valueRangeTextBox.RefreshValue(); + } + else + { + if( e.OldValue.Equals( valueRangeTextBox.Value ) ) + valueRangeTextBox.RefreshValue(); + } + } + + #endregion NullValue Property + + #region Value Property + + public object Value + { + get + { + return ( object )GetValue( ValueProperty ); + } + set + { + SetValue( ValueProperty, value ); + } + } + + public static readonly DependencyProperty ValueProperty = + DependencyProperty.Register( "Value", typeof( object ), typeof( ValueRangeTextBox ), + new FrameworkPropertyMetadata( + null, + FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, + new PropertyChangedCallback( ValueRangeTextBox.ValuePropertyChangedCallback ), + new CoerceValueCallback( ValueRangeTextBox.ValueCoerceValueCallback ) ) ); + + private static object ValueCoerceValueCallback( object sender, object value ) + { + ValueRangeTextBox valueRangeTextBox = sender as ValueRangeTextBox; + + if( !valueRangeTextBox.IsInitialized ) + return DependencyProperty.UnsetValue; + + if( valueRangeTextBox.IsFinalizingInitialization ) + value = ValueRangeTextBox.ConvertValueToDataType( value, valueRangeTextBox.ValueDataType ); + + if( !valueRangeTextBox.IsForcingValue ) + valueRangeTextBox.ValidateValue( value ); + + return value; + } + + private static void ValuePropertyChangedCallback( object sender, DependencyPropertyChangedEventArgs e ) + { + ValueRangeTextBox valueRangeTextBox = sender as ValueRangeTextBox; + + if( valueRangeTextBox.IsForcingValue ) + return; + + // The ValueChangedCallback can be raised even though both values are the same since the property + // datatype is Object. + if( object.Equals( e.NewValue, e.OldValue ) ) + return; + + valueRangeTextBox.IsInValueChanged = true; + try + { + valueRangeTextBox.Text = valueRangeTextBox.GetTextFromValue( e.NewValue ); + } + finally + { + valueRangeTextBox.IsInValueChanged = false; + } + } + + #endregion Value Property + + #region ValueDataType Property + + public Type ValueDataType + { + get + { + return ( Type )GetValue( ValueDataTypeProperty ); + } + set + { + SetValue( ValueDataTypeProperty, value ); + } + } + + public static readonly DependencyProperty ValueDataTypeProperty = + DependencyProperty.Register( "ValueDataType", typeof( Type ), typeof( ValueRangeTextBox ), + new UIPropertyMetadata( + null, + new PropertyChangedCallback( ValueRangeTextBox.ValueDataTypePropertyChangedCallback ), + new CoerceValueCallback( ValueRangeTextBox.ValueDataTypeCoerceValueCallback ) ) ); + + private static object ValueDataTypeCoerceValueCallback( DependencyObject sender, object value ) + { + ValueRangeTextBox valueRangeTextBox = sender as ValueRangeTextBox; + + if( !valueRangeTextBox.IsInitialized ) + return DependencyProperty.UnsetValue; + + Type valueDataType = value as Type; + + try + { + valueRangeTextBox.ValidateDataType( valueDataType ); + } + catch( Exception exception ) + { + throw new ArgumentException( "An error occured while trying to change the ValueDataType.", exception ); + } + + return value; + } + + private static void ValueDataTypePropertyChangedCallback( DependencyObject sender, DependencyPropertyChangedEventArgs e ) + { + ValueRangeTextBox valueRangeTextBox = sender as ValueRangeTextBox; + + Type valueDataType = e.NewValue as Type; + + valueRangeTextBox.IsNumericValueDataType = ValueRangeTextBox.IsNumericType( valueDataType ); + + valueRangeTextBox.RefreshConversionHelpers(); + + valueRangeTextBox.ConvertValuesToDataType( valueDataType ); + } + + internal virtual void ValidateDataType( Type type ) + { + // Null will always be valid and will reset the MinValue, MaxValue, NullValue and Value to null. + if( type == null ) + return; + + // We use InvariantCulture instead of the active format provider since the FormatProvider is only + // used when the source type is String. When we are converting from a string, we are + // actually converting a value from XAML. Therefore, if the string will have a period as a + // decimal separator. If we were using the active format provider, we could end up expecting a coma + // as the decimal separator and the ChangeType method would throw. + + object minValue = this.MinValue; + + if( ( minValue != null ) && ( minValue.GetType() != type ) ) + minValue = System.Convert.ChangeType( minValue, type, CultureInfo.InvariantCulture ); + + object maxValue = this.MaxValue; + + if( ( maxValue != null ) && ( maxValue.GetType() != type ) ) + maxValue = System.Convert.ChangeType( maxValue, type, CultureInfo.InvariantCulture ); + + object nullValue = this.NullValue; + + if( ( ( nullValue != null ) && ( nullValue != DBNull.Value ) ) + && ( nullValue.GetType() != type ) ) + { + nullValue = System.Convert.ChangeType( nullValue, type, CultureInfo.InvariantCulture ); + } + + object value = this.Value; + + if( ( ( value != null ) && ( value != DBNull.Value ) ) + && ( value.GetType() != type ) ) + { + value = System.Convert.ChangeType( value, type, CultureInfo.InvariantCulture ); + } + + if( ( minValue != null ) || ( maxValue != null ) + || ( ( nullValue != null ) && ( nullValue != DBNull.Value ) ) ) + { + // Value comparaisons will occur. Therefore, the aspiring data type must implement IComparable. + + Type iComparable = type.GetInterface( "IComparable" ); + + if( iComparable == null ) + throw new InvalidOperationException( "MinValue, MaxValue, and NullValue must implement the IComparable interface." ); + } + } + + private void ConvertValuesToDataType( Type type ) + { + if( type == null ) + { + this.MinValue = null; + this.MaxValue = null; + this.NullValue = null; + + this.Value = null; + + return; + } + + object minValue = this.MinValue; + + if( ( minValue != null ) && ( minValue.GetType() != type ) ) + this.MinValue = ValueRangeTextBox.ConvertValueToDataType( minValue, type ); + + object maxValue = this.MaxValue; + + if( ( maxValue != null ) && ( maxValue.GetType() != type ) ) + this.MaxValue = ValueRangeTextBox.ConvertValueToDataType( maxValue, type ); + + object nullValue = this.NullValue; + + if( ( ( nullValue != null ) && ( nullValue != DBNull.Value ) ) + && ( nullValue.GetType() != type ) ) + { + this.NullValue = ValueRangeTextBox.ConvertValueToDataType( nullValue, type ); + } + + object value = this.Value; + + if( ( ( value != null ) && ( value != DBNull.Value ) ) + && ( value.GetType() != type ) ) + { + this.Value = ValueRangeTextBox.ConvertValueToDataType( value, type ); + } + } + + #endregion ValueDataType Property + + #region Text Property + + private static object TextCoerceValueCallback( object sender, object value ) + { + ValueRangeTextBox valueRangeTextBox = sender as ValueRangeTextBox; + + if( !valueRangeTextBox.IsInitialized ) + return DependencyProperty.UnsetValue; + + if( value == null ) + return string.Empty; + + return value; + } + + protected override void OnTextChanged( TextChangedEventArgs e ) + { + // If in IME Composition, RefreshValue already returns without doing anything. + this.RefreshValue(); + + base.OnTextChanged( e ); + } + + #endregion Text Property + + #region HasValidationError Property + + private static readonly DependencyPropertyKey HasValidationErrorPropertyKey = + DependencyProperty.RegisterReadOnly( "HasValidationError", typeof( bool ), typeof( ValueRangeTextBox ), new UIPropertyMetadata( false ) ); + + public static readonly DependencyProperty HasValidationErrorProperty = ValueRangeTextBox.HasValidationErrorPropertyKey.DependencyProperty; + + public bool HasValidationError + { + get + { + return ( bool )this.GetValue( ValueRangeTextBox.HasValidationErrorProperty ); + } + } + + private void SetHasValidationError( bool value ) + { + this.SetValue( ValueRangeTextBox.HasValidationErrorPropertyKey, value ); + } + + #endregion HasValidationError Property + + #region HasParsingError Property + + private static readonly DependencyPropertyKey HasParsingErrorPropertyKey = + DependencyProperty.RegisterReadOnly( "HasParsingError", typeof( bool ), typeof( ValueRangeTextBox ), new UIPropertyMetadata( false ) ); + + public static readonly DependencyProperty HasParsingErrorProperty = ValueRangeTextBox.HasParsingErrorPropertyKey.DependencyProperty; + + public bool HasParsingError + { + get + { + return ( bool )this.GetValue( ValueRangeTextBox.HasParsingErrorProperty ); + } + } + + internal void SetHasParsingError( bool value ) + { + this.SetValue( ValueRangeTextBox.HasParsingErrorPropertyKey, value ); + } + + #endregion HasParsingError Property + + #region IsValueOutOfRange Property + + private static readonly DependencyPropertyKey IsValueOutOfRangePropertyKey = + DependencyProperty.RegisterReadOnly( "IsValueOutOfRange", typeof( bool ), typeof( ValueRangeTextBox ), new UIPropertyMetadata( false ) ); + + public static readonly DependencyProperty IsValueOutOfRangeProperty = ValueRangeTextBox.IsValueOutOfRangePropertyKey.DependencyProperty; + + public bool IsValueOutOfRange + { + get + { + return ( bool )this.GetValue( ValueRangeTextBox.IsValueOutOfRangeProperty ); + } + } + + private void SetIsValueOutOfRange( bool value ) + { + this.SetValue( ValueRangeTextBox.IsValueOutOfRangePropertyKey, value ); + } + + #endregion IsValueOutOfRange Property + + #region IsInValueChanged property + + internal bool IsInValueChanged + { + get + { + return m_flags[ ( int )ValueRangeTextBoxFlags.IsInValueChanged ]; + } + private set + { + m_flags[ ( int )ValueRangeTextBoxFlags.IsInValueChanged ] = value; + } + } + + #endregion + + #region IsForcingValue property + + internal bool IsForcingValue + { + get + { + return m_flags[ ( int )ValueRangeTextBoxFlags.IsForcingValue ]; + } + private set + { + m_flags[ ( int )ValueRangeTextBoxFlags.IsForcingValue ] = value; + } + } + + #endregion + + #region IsForcingText property + + internal bool IsForcingText + { + get + { + return m_flags[ ( int )ValueRangeTextBoxFlags.IsForcingText ]; + } + private set + { + m_flags[ ( int )ValueRangeTextBoxFlags.IsForcingText ] = value; + } + } + + #endregion + + #region IsNumericValueDataType property + + internal bool IsNumericValueDataType + { + get + { + return m_flags[ ( int )ValueRangeTextBoxFlags.IsNumericValueDataType ]; + } + private set + { + m_flags[ ( int )ValueRangeTextBoxFlags.IsNumericValueDataType ] = value; + } + } + + #endregion + + #region IsTextReadyToBeParsed property + + internal virtual bool IsTextReadyToBeParsed + { + get + { + return true; + } + } + + #endregion + + #region IsInIMEComposition property + + internal bool IsInIMEComposition + { + get + { + return m_imePreCompositionCachedTextInfo != null; + } + } + + #endregion + + #region IsFinalizingInitialization Property + + private bool IsFinalizingInitialization + { + get + { + return m_flags[ ( int )ValueRangeTextBoxFlags.IsFinalizingInitialization ]; + } + set + { + m_flags[ ( int )ValueRangeTextBoxFlags.IsFinalizingInitialization ] = value; + } + } + + #endregion + + #region TEXT FROM VALUE + + public event EventHandler QueryTextFromValue; + + internal string GetTextFromValue( object value ) + { + string text = this.QueryTextFromValueCore( value ); + + QueryTextFromValueEventArgs e = new QueryTextFromValueEventArgs( value, text ); + + this.OnQueryTextFromValue( e ); + + return e.Text; + } + + protected virtual string QueryTextFromValueCore( object value ) + { + if( ( value == null ) || ( value == DBNull.Value ) ) + return string.Empty; + + IFormatProvider formatProvider = this.GetActiveFormatProvider(); + + CultureInfo cultureInfo = formatProvider as CultureInfo; + + if( cultureInfo != null ) + { + TypeConverter converter = TypeDescriptor.GetConverter( value.GetType() ); + + if( converter.CanConvertTo( typeof( string ) ) ) + return ( string )converter.ConvertTo( null, cultureInfo, value, typeof( string ) ); + } + + try + { + string result = System.Convert.ToString( value, formatProvider ); + + return result; + } + catch + { + } + + return value.ToString(); + } + + private void OnQueryTextFromValue( QueryTextFromValueEventArgs e ) + { + if( this.QueryTextFromValue != null ) + this.QueryTextFromValue( this, e ); + } + + #endregion TEXT FROM VALUE + + #region VALUE FROM TEXT + + public event EventHandler QueryValueFromText; + + internal object GetValueFromText( string text, out bool hasParsingError ) + { + object value = null; + bool success = this.QueryValueFromTextCore( text, out value ); + + QueryValueFromTextEventArgs e = new QueryValueFromTextEventArgs( text, value ); + e.HasParsingError = !success; + + this.OnQueryValueFromText( e ); + + hasParsingError = e.HasParsingError; + + return e.Value; + } + + protected virtual bool QueryValueFromTextCore( string text, out object value ) + { + value = null; + + Type validatingType = this.ValueDataType; + + text = text.Trim(); + + if( validatingType == null ) + return true; + + if( !validatingType.IsValueType && ( validatingType != typeof( string ) ) ) + return false; + + try + { + value = System.Convert.ChangeType( text, validatingType, this.GetActiveFormatProvider() ); + } + catch + { + return false; + } + + return true; + } + + private void OnQueryValueFromText( QueryValueFromTextEventArgs e ) + { + if( this.QueryValueFromText != null ) + this.QueryValueFromText( this, e ); + } + + #endregion VALUE FROM TEXT + + protected override void OnPreviewKeyDown( KeyEventArgs e ) + { + if( ( e.ImeProcessedKey != Key.None ) && ( !this.IsInIMEComposition ) ) + { + // Start of an IME Composition. Cache all the critical infos. + this.StartIMEComposition(); + } + + base.OnPreviewKeyDown( e ); + } + + protected override void OnGotFocus( RoutedEventArgs e ) + { + base.OnGotFocus( e ); + + this.RefreshCurrentText( true ); + } + + protected override void OnLostFocus( RoutedEventArgs e ) + { + base.OnLostFocus( e ); + + this.RefreshCurrentText( true ); + } + + protected override void OnTextInput( TextCompositionEventArgs e ) + { + if( this.IsInIMEComposition ) + this.EndIMEComposition(); + + base.OnTextInput( e ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly" )] + protected virtual void ValidateValue( object value ) + { + if( value == null ) + return; + + Type validatingType = this.ValueDataType; + + if( validatingType == null ) + throw new InvalidOperationException( "An attempt was made to set a value when the ValueDataType property is null." ); + + if( ( value != DBNull.Value ) && ( value.GetType() != validatingType ) ) + throw new ArgumentException( "The value is not of type " + validatingType.Name + ".", "Value" ); + + this.ValidateValueInRange( this.MinValue, this.MaxValue, value ); + } + + internal static bool IsNumericType( Type type ) + { + if( type == null ) + return false; + + if( type.IsValueType ) + { + if( ( type == typeof( int ) ) || ( type == typeof( double ) ) || ( type == typeof( decimal ) ) + || ( type == typeof( float ) ) || ( type == typeof( short ) ) || ( type == typeof( long ) ) + || ( type == typeof( ushort ) ) || ( type == typeof( uint ) ) || ( type == typeof( ulong ) ) + || ( type == typeof( byte ) ) + ) + { + return true; + } + } + + return false; + } + + internal void StartIMEComposition() + { + Debug.Assert( m_imePreCompositionCachedTextInfo == null, "EndIMEComposition should have been called before another IME Composition starts." ); + + m_imePreCompositionCachedTextInfo = new CachedTextInfo( this ); + } + + internal void EndIMEComposition() + { + CachedTextInfo cachedTextInfo = m_imePreCompositionCachedTextInfo.Clone() as CachedTextInfo; + m_imePreCompositionCachedTextInfo = null; + + this.OnIMECompositionEnded( cachedTextInfo ); + } + + internal virtual void OnIMECompositionEnded( CachedTextInfo cachedTextInfo ) + { + } + + internal virtual void RefreshConversionHelpers() + { + } + + internal IFormatProvider GetActiveFormatProvider() + { + IFormatProvider formatProvider = this.FormatProvider; + + if( formatProvider != null ) + return formatProvider; + + return CultureInfo.CurrentCulture; + } + + internal CultureInfo GetCultureInfo() + { + CultureInfo cultureInfo = this.GetActiveFormatProvider() as CultureInfo; + + if( cultureInfo != null ) + return cultureInfo; + + return CultureInfo.CurrentCulture; + } + + internal virtual string GetCurrentText() + { + return this.Text; + } + + internal virtual string GetParsableText() + { + return this.Text; + } + + internal void ForceText( string text, bool preserveCaret ) + { + this.IsForcingText = true; + try + { + int oldCaretIndex = this.CaretIndex; + + this.Text = text; + + if( ( preserveCaret ) && ( this.IsLoaded ) ) + { + try + { + this.SelectionStart = oldCaretIndex; + } + catch( NullReferenceException ) + { + } + } + } + finally + { + this.IsForcingText = false; + } + } + + internal bool IsValueNull( object value ) + { + if( ( value == null ) || ( value == DBNull.Value ) ) + return true; + + Type type = this.ValueDataType; + + if( value.GetType() != type ) + value = System.Convert.ChangeType( value, type ); + + object nullValue = this.NullValue; + + if( nullValue == null ) + return false; + + if( nullValue.GetType() != type ) + nullValue = System.Convert.ChangeType( nullValue, type ); + + return nullValue.Equals( value ); + } + + internal void ForceValue( object value ) + { + this.IsForcingValue = true; + try + { + this.Value = value; + } + finally + { + this.IsForcingValue = false; + } + } + + internal void RefreshCurrentText( bool preserveCurrentCaretPosition ) + { + string displayText = this.GetCurrentText(); + + if( !string.Equals( displayText, this.Text ) ) + this.ForceText( displayText, preserveCurrentCaretPosition ); + } + + internal void RefreshValue() + { + if( ( this.IsForcingValue ) || ( this.ValueDataType == null ) || ( this.IsInIMEComposition ) ) + return; + + object value; + bool hasParsingError; + + if( this.IsTextReadyToBeParsed ) + { + string parsableText = this.GetParsableText(); + + value = this.GetValueFromText( parsableText, out hasParsingError ); + + if( this.IsValueNull( value ) ) + value = this.NullValue; + } + else + { + // We don't consider empty text as a parsing error. + hasParsingError = !this.GetIsEditTextEmpty(); + value = this.NullValue; + } + + this.SetHasParsingError( hasParsingError ); + + bool hasValidationError = hasParsingError; + try + { + this.ValidateValue( value ); + + this.SetIsValueOutOfRange( false ); + } + catch( Exception exception ) + { + hasValidationError = true; + + if( exception is ArgumentOutOfRangeException ) + this.SetIsValueOutOfRange( true ); + + value = this.NullValue; + } + + if( !object.Equals( value, this.Value ) ) + this.ForceValue( value ); + + this.SetHasValidationError( hasValidationError ); + } + + internal virtual bool GetIsEditTextEmpty() + { + return this.Text == string.Empty; + } + + private static object ConvertValueToDataType( object value, Type type ) + { + // We use InvariantCulture instead of the active format provider since the FormatProvider is only + // used when the source type is String. When we are converting from a string, we are + // actually converting a value from XAML. Therefore, if the string will have a period as a + // decimal separator. If we were using the active format provider, we could end up expecting a coma + // as the decimal separator and the ChangeType method would throw. + if( type == null ) + return null; + + if( ( ( value != null ) && ( value != DBNull.Value ) ) + && ( value.GetType() != type ) ) + { + return System.Convert.ChangeType( value, type, CultureInfo.InvariantCulture ); + } + + return value; + } + + private void CanEnterLineBreak( object sender, CanExecuteRoutedEventArgs e ) + { + e.CanExecute = false; + e.Handled = true; + } + + private void CanEnterParagraphBreak( object sender, CanExecuteRoutedEventArgs e ) + { + e.CanExecute = false; + e.Handled = true; + } + + private void ValidateValueInRange( object minValue, object maxValue, object value ) + { + if( this.IsValueNull( value ) ) + return; + + Type type = this.ValueDataType; + + if( value.GetType() != type ) + value = System.Convert.ChangeType( value, type ); + + // Validate the value against the range. + if( minValue != null ) + { + IComparable minValueComparable = ( IComparable )minValue; + + if( ( maxValue != null ) && ( minValueComparable.CompareTo( maxValue ) > 0 ) ) + throw new ArgumentOutOfRangeException( "minValue", "MaxValue must be greater than MinValue." ); + + if( minValueComparable.CompareTo( value ) > 0 ) + throw new ArgumentOutOfRangeException( "minValue", "Value must be greater than MinValue." ); + } + + if( maxValue != null ) + { + IComparable maxValueComparable = ( IComparable )maxValue; + + if( maxValueComparable.CompareTo( value ) < 0 ) + throw new ArgumentOutOfRangeException( "maxValue", "Value must be less than MaxValue." ); + } + } + + #region ISupportInitialize + + protected override void OnInitialized( EventArgs e ) + { + this.IsFinalizingInitialization = true; + try + { + this.CoerceValue( ValueRangeTextBox.ValueDataTypeProperty ); + + this.IsNumericValueDataType = ValueRangeTextBox.IsNumericType( this.ValueDataType ); + this.RefreshConversionHelpers(); + + this.CoerceValue( ValueRangeTextBox.MinValueProperty ); + this.CoerceValue( ValueRangeTextBox.MaxValueProperty ); + + this.CoerceValue( ValueRangeTextBox.ValueProperty ); + + this.CoerceValue( ValueRangeTextBox.NullValueProperty ); + + this.CoerceValue( ValueRangeTextBox.TextProperty ); + } + catch( Exception exception ) + { + throw new InvalidOperationException( "Initialization of the ValueRangeTextBox failed.", exception ); + } + finally + { + this.IsFinalizingInitialization = false; + } + + base.OnInitialized( e ); + } + + #endregion ISupportInitialize + + private BitVector32 m_flags; + private CachedTextInfo m_imePreCompositionCachedTextInfo; + + [Flags] + private enum ValueRangeTextBoxFlags + { + IsFinalizingInitialization = 1, + IsForcingText = 2, + IsForcingValue = 4, + IsInValueChanged = 8, + IsNumericValueDataType = 16 + } + } +} diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/QueryTextFromValueEventArgs.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/QueryTextFromValueEventArgs.cs new file mode 100644 index 00000000..c2c15882 --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/QueryTextFromValueEventArgs.cs @@ -0,0 +1,57 @@ +/************************************************************************ + + Extended WPF Toolkit + + Copyright (C) 2010-2012 Xceed Software Inc. + + This program is provided to you under the terms of the Microsoft Public + License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license + + This program can be provided to you by Xceed Software Inc. under a + proprietary commercial license agreement for use in non-Open Source + projects. The commercial version of Extended WPF Toolkit also includes + priority technical support, commercial updates, and many additional + useful WPF controls if you license Xceed Business Suite for WPF. + + Visit http://xceed.com and follow @datagrid on Twitter. + + **********************************************************************/ + +using System; +using System.Collections.Generic; +using System.Text; + +namespace Xceed.Wpf.Toolkit.Core +{ + public class QueryTextFromValueEventArgs : EventArgs + { + public QueryTextFromValueEventArgs( object value, string text ) + { + m_value = value; + m_text = text; + } + + #region Value Property + + private object m_value; + + public object Value + { + get { return m_value; } + } + + #endregion Value Property + + #region Text Property + + private string m_text; + + public string Text + { + get { return m_text; } + set { m_text = value; } + } + + #endregion Text Property + } +} diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/QueryValueFromTextEventArgs.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/QueryValueFromTextEventArgs.cs new file mode 100644 index 00000000..53ae9960 --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/QueryValueFromTextEventArgs.cs @@ -0,0 +1,70 @@ +/************************************************************************ + + Extended WPF Toolkit + + Copyright (C) 2010-2012 Xceed Software Inc. + + This program is provided to you under the terms of the Microsoft Public + License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license + + This program can be provided to you by Xceed Software Inc. under a + proprietary commercial license agreement for use in non-Open Source + projects. The commercial version of Extended WPF Toolkit also includes + priority technical support, commercial updates, and many additional + useful WPF controls if you license Xceed Business Suite for WPF. + + Visit http://xceed.com and follow @datagrid on Twitter. + + **********************************************************************/ + +using System; +using System.Collections.Generic; +using System.Text; + +namespace Xceed.Wpf.Toolkit.Core +{ + public class QueryValueFromTextEventArgs : EventArgs + { + public QueryValueFromTextEventArgs( string text, object value ) + { + m_text = text; + m_value = value; + } + + #region Text Property + + private string m_text; + + public string Text + { + get { return m_text; } + } + + #endregion Text Property + + #region Value Property + + private object m_value; + + public object Value + { + get { return m_value; } + set { m_value = value; } + } + + #endregion Value Property + + #region HasParsingError Property + + private bool m_hasParsingError; + + public bool HasParsingError + { + get { return m_hasParsingError; } + set { m_hasParsingError = value; } + } + + #endregion HasParsingError Property + + } +} diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Utilities/ColorUtilities.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Utilities/ColorUtilities.cs index db088862..c1b0549b 100644 --- a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Utilities/ColorUtilities.cs +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Utilities/ColorUtilities.cs @@ -184,7 +184,7 @@ namespace Xceed.Wpf.Toolkit.Core.Utilities } - return Color.FromArgb( 255, ( byte )( r * 255 ), ( byte )( g * 255 ), ( byte )( b * 255 ) ); + return Color.FromArgb( 255, ( byte )( Math.Round(r * 255) ), ( byte )( Math.Round(g * 255) ), ( byte )( Math.Round(b * 255) ) ); } /// diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Utilities/NotifyPropertyChangedHelper.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Utilities/NotifyPropertyChangedHelper.cs new file mode 100644 index 00000000..58a27f75 --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Utilities/NotifyPropertyChangedHelper.cs @@ -0,0 +1,163 @@ +/************************************************************************ + + Extended WPF Toolkit + + Copyright (C) 2010-2012 Xceed Software Inc. + + This program is provided to you under the terms of the Microsoft Public + License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license + + This program can be provided to you by Xceed Software Inc. under a + proprietary commercial license agreement for use in non-Open Source + projects. The commercial version of Extended WPF Toolkit also includes + priority technical support, commercial updates, and many additional + useful WPF controls if you license Xceed Business Suite for WPF. + + Visit http://xceed.com and follow @datagrid on Twitter. + + **********************************************************************/ + +using System; +using System.ComponentModel; +using System.Diagnostics; +using System.Linq.Expressions; + +namespace Xceed.Wpf.Toolkit.Core.Utilities +{ + [DebuggerStepThrough] + internal sealed class NotifyPropertyChangedHelper + { + #region Constructor + + internal NotifyPropertyChangedHelper( + INotifyPropertyChanged owner, + Action notifyPropertyChangedDelegate ) + { + if( owner == null ) + throw new ArgumentNullException( "owner" ); + + if( notifyPropertyChangedDelegate == null ) + throw new ArgumentNullException( "notifyPropertyChangedDelegate" ); + + m_owner = owner; + m_delegate = notifyPropertyChangedDelegate; + } + + #endregion + + internal static bool PropertyChanged( string propertyName, PropertyChangedEventArgs e, bool targetPropertyOnly ) + { + string target = e.PropertyName; + if( target == propertyName ) + return true; + + return ( !targetPropertyOnly ) + && ( string.IsNullOrEmpty( target ) ); + } + + internal static bool PropertyChanged( + Expression> expression, + PropertyChangedEventArgs e, + bool targetPropertyOnly ) + { + var body = expression.Body as MemberExpression; + if( body == null ) + throw new ArgumentException( "The expression must target a property or field.", "expression" ); + + return NotifyPropertyChangedHelper.PropertyChanged( body, typeof( TOwner ), e, targetPropertyOnly ); + } + + internal static bool PropertyChanged( + Expression> expression, + PropertyChangedEventArgs e, + bool targetPropertyOnly ) + { + var body = expression.Body as MemberExpression; + if( body == null ) + throw new ArgumentException( "The expression must target a property or field.", "expression" ); + + return NotifyPropertyChangedHelper.PropertyChanged( body, typeof( TOwner ), e, targetPropertyOnly ); + } + + internal void RaisePropertyChanged( string propertyName ) + { + ReflectionHelper.ValidatePropertyName( m_owner, propertyName ); + + this.InvokeDelegate( propertyName ); + } + + internal void RaisePropertyChanged( Expression> expression ) + { + if( expression == null ) + throw new ArgumentNullException( "expression" ); + + var body = expression.Body as MemberExpression; + if( body == null ) + throw new ArgumentException( "The expression must target a property or field.", "expression" ); + + var propertyName = NotifyPropertyChangedHelper.GetPropertyName( body, m_owner.GetType() ); + + this.InvokeDelegate( propertyName ); + } + + internal void HandleReferenceChanged( Expression> expression, ref TMember localReference, TMember newValue ) where TMember : class + { + if( localReference != newValue ) + { + this.ExecutePropertyChanged( expression, ref localReference, newValue ); + } + } + + internal void HandleEqualityChanged( Expression> expression, ref TMember localReference, TMember newValue ) + { + if( !object.Equals( localReference, newValue ) ) + { + this.ExecutePropertyChanged( expression, ref localReference, newValue ); + } + } + + private void ExecutePropertyChanged( Expression> expression, ref TMember localReference, TMember newValue ) + { + TMember oldValue = localReference; + localReference = newValue; + this.RaisePropertyChanged( expression ); + } + + internal static string GetPropertyName( Expression> expression, Type ownerType ) + { + var body = expression.Body as MemberExpression; + if( body == null ) + throw new ArgumentException( "The expression must target a property or field.", "expression" ); + + return NotifyPropertyChangedHelper.GetPropertyName( body, ownerType ); + } + + private static bool PropertyChanged( MemberExpression expression, Type ownerType, PropertyChangedEventArgs e, bool targetPropertyOnly ) + { + var propertyName = NotifyPropertyChangedHelper.GetPropertyName( expression, ownerType ); + + return NotifyPropertyChangedHelper.PropertyChanged( propertyName, e, targetPropertyOnly ); + } + + private static string GetPropertyName( MemberExpression expression, Type ownerType ) + { + var targetType = expression.Expression.Type; + if( !targetType.IsAssignableFrom( ownerType ) ) + throw new ArgumentException( "The expression must target a property or field on the appropriate owner.", "expression" ); + + return ReflectionHelper.GetPropertyOrFieldName( expression ); + } + + private void InvokeDelegate( string propertyName ) + { + m_delegate.Invoke( propertyName ); + } + + #region Private Fields + + private readonly INotifyPropertyChanged m_owner; + private readonly Action m_delegate; + + #endregion + } +} diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Utilities/ReflectionHelper.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Utilities/ReflectionHelper.cs new file mode 100644 index 00000000..4960c8db --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Utilities/ReflectionHelper.cs @@ -0,0 +1,136 @@ +/************************************************************************ + + Extended WPF Toolkit + + Copyright (C) 2010-2012 Xceed Software Inc. + + This program is provided to you under the terms of the Microsoft Public + License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license + + This program can be provided to you by Xceed Software Inc. under a + proprietary commercial license agreement for use in non-Open Source + projects. The commercial version of Extended WPF Toolkit also includes + priority technical support, commercial updates, and many additional + useful WPF controls if you license Xceed Business Suite for WPF. + + Visit http://xceed.com and follow @datagrid on Twitter. + + **********************************************************************/ + +using System; +using System.ComponentModel; +using System.Diagnostics; +using System.Linq.Expressions; +using System.Reflection; + +namespace Xceed.Wpf.Toolkit.Core.Utilities +{ + internal static class ReflectionHelper + { + /// + /// Check the existence of the specified public instance (i.e. non static) property against + /// the type of the specified source object. If the property is not defined by the type, + /// a debug assertion will fail. Typically used to validate the parameter of a + /// RaisePropertyChanged method. + /// + /// The object for which the type will be checked. + /// The name of the property. + [System.Diagnostics.Conditional( "DEBUG" )] + internal static void ValidatePublicPropertyName( object sourceObject, string propertyName ) + { + if( sourceObject == null ) + throw new ArgumentNullException( "sourceObject" ); + + if( propertyName == null ) + throw new ArgumentNullException( "propertyName" ); + + System.Diagnostics.Debug.Assert( sourceObject.GetType().GetProperty( propertyName, System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.FlattenHierarchy | System.Reflection.BindingFlags.Public ) != null, + string.Format( "Public property {0} not found on object of type {1}.", propertyName, sourceObject.GetType().FullName ) ); + } + + /// + /// Check the existence of the specified instance (i.e. non static) property against + /// the type of the specified source object. If the property is not defined by the type, + /// a debug assertion will fail. Typically used to validate the parameter of a + /// RaisePropertyChanged method. + /// + /// The object for which the type will be checked. + /// The name of the property. + [System.Diagnostics.Conditional( "DEBUG" )] + internal static void ValidatePropertyName( object sourceObject, string propertyName ) + { + if( sourceObject == null ) + throw new ArgumentNullException( "sourceObject" ); + + if( propertyName == null ) + throw new ArgumentNullException( "propertyName" ); + + System.Diagnostics.Debug.Assert( sourceObject.GetType().GetProperty( propertyName, System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.FlattenHierarchy | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic ) != null, + string.Format( "Public property {0} not found on object of type {1}.", propertyName, sourceObject.GetType().FullName ) ); + } + + internal static bool TryGetEnumDescriptionAttributeValue( Enum enumeration, out string description ) + { + try + { + FieldInfo fieldInfo = enumeration.GetType().GetField( enumeration.ToString() ); + DescriptionAttribute[] attributes = fieldInfo.GetCustomAttributes( typeof( DescriptionAttribute ), true ) as DescriptionAttribute[]; + if( ( attributes != null ) && ( attributes.Length > 0 ) ) + { + description = attributes[ 0 ].Description; + return true; + } + } + catch + { + } + + description = String.Empty; + return false; + } + + [DebuggerStepThrough] + internal static string GetPropertyOrFieldName( MemberExpression expression ) + { + string propertyOrFieldName; + if( !ReflectionHelper.TryGetPropertyOrFieldName( expression, out propertyOrFieldName ) ) + throw new InvalidOperationException( "Unable to retrieve the property or field name." ); + + return propertyOrFieldName; + } + + [DebuggerStepThrough] + internal static string GetPropertyOrFieldName( Expression> expression ) + { + string propertyOrFieldName; + if( !ReflectionHelper.TryGetPropertyOrFieldName( expression, out propertyOrFieldName ) ) + throw new InvalidOperationException( "Unable to retrieve the property or field name." ); + + return propertyOrFieldName; + } + + [DebuggerStepThrough] + internal static bool TryGetPropertyOrFieldName( MemberExpression expression, out string propertyOrFieldName ) + { + propertyOrFieldName = null; + + if( expression == null ) + return false; + + propertyOrFieldName = expression.Member.Name; + + return true; + } + + [DebuggerStepThrough] + internal static bool TryGetPropertyOrFieldName( Expression> expression, out string propertyOrFieldName ) + { + propertyOrFieldName = null; + + if( expression == null ) + return false; + + return ReflectionHelper.TryGetPropertyOrFieldName( expression.Body as MemberExpression, out propertyOrFieldName ); + } + } +} diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Utilities/TreeHelper.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Utilities/TreeHelper.cs new file mode 100644 index 00000000..e410dbee --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Utilities/TreeHelper.cs @@ -0,0 +1,238 @@ +/************************************************************************ + + Extended WPF Toolkit + + Copyright (C) 2010-2012 Xceed Software Inc. + + This program is provided to you under the terms of the Microsoft Public + License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license + + This program can be provided to you by Xceed Software Inc. under a + proprietary commercial license agreement for use in non-Open Source + projects. The commercial version of Extended WPF Toolkit also includes + priority technical support, commercial updates, and many additional + useful WPF controls if you license Xceed Business Suite for WPF. + + Visit http://xceed.com and follow @datagrid on Twitter. + + **********************************************************************/ + +using System; +using System.Windows; +using System.Windows.Media; +using System.Windows.Controls.Primitives; + +namespace Xceed.Wpf.Toolkit.Core.Utilities +{ + internal static class TreeHelper + { + /// + /// Tries its best to return the specified element's parent. It will + /// try to find, in this order, the VisualParent, LogicalParent, LogicalTemplatedParent. + /// It only works for Visual, FrameworkElement or FrameworkContentElement. + /// + /// The element to which to return the parent. It will only + /// work if element is a Visual, a FrameworkElement or a FrameworkContentElement. + /// If the logical parent is not found (Parent), we check the TemplatedParent + /// (see FrameworkElement.Parent documentation). But, we never actually witnessed + /// this situation. + public static DependencyObject GetParent( DependencyObject element ) + { + return TreeHelper.GetParent( element, true ); + } + + private static DependencyObject GetParent( DependencyObject element, bool recurseIntoPopup ) + { + if( recurseIntoPopup ) + { + // Case 126732 : To correctly detect parent of a popup we must do that exception case + Popup popup = element as Popup; + + if( ( popup != null ) && ( popup.PlacementTarget != null ) ) + return popup.PlacementTarget; + } + + Visual visual = element as Visual; + DependencyObject parent = ( visual == null ) ? null : VisualTreeHelper.GetParent( visual ); + + if( parent == null ) + { + // No Visual parent. Check in the logical tree. + FrameworkElement fe = element as FrameworkElement; + + if( fe != null ) + { + parent = fe.Parent; + + if( parent == null ) + { + parent = fe.TemplatedParent; + } + } + else + { + FrameworkContentElement fce = element as FrameworkContentElement; + + if( fce != null ) + { + parent = fce.Parent; + + if( parent == null ) + { + parent = fce.TemplatedParent; + } + } + } + } + + return parent; + } + + /// + /// This will search for a parent of the specified type. + /// + /// The type of the element to find + /// The node where the search begins. This element is not checked. + /// Returns the found element. Null if nothing is found. + public static T FindParent( DependencyObject startingObject ) where T : DependencyObject + { + return TreeHelper.FindParent( startingObject, false, null ); + } + + /// + /// This will search for a parent of the specified type. + /// + /// The type of the element to find + /// The node where the search begins. + /// Should the specified startingObject be checked first. + /// Returns the found element. Null if nothing is found. + public static T FindParent( DependencyObject startingObject, bool checkStartingObject ) where T : DependencyObject + { + return TreeHelper.FindParent( startingObject, checkStartingObject, null ); + } + + /// + /// This will search for a parent of the specified type. + /// + /// The type of the element to find + /// The node where the search begins. + /// Should the specified startingObject be checked first. + /// Provide a callback to check additional properties + /// of the found elements. Can be left Null if no additional criteria are needed. + /// Returns the found element. Null if nothing is found. + /// Button button = TreeHelper.FindParent<Button>( this, foundChild => foundChild.Focusable ); + public static T FindParent( DependencyObject startingObject, bool checkStartingObject, Func additionalCheck ) where T : DependencyObject + { + T foundElement; + DependencyObject parent = ( checkStartingObject ? startingObject : TreeHelper.GetParent( startingObject, true ) ); + + while( parent != null ) + { + foundElement = parent as T; + + if( foundElement != null ) + { + if( additionalCheck == null ) + { + return foundElement; + } + else + { + if( additionalCheck( foundElement ) ) + return foundElement; + } + } + + parent = TreeHelper.GetParent( parent, true ); + } + + return null; + } + + /// + /// This will search for a child of the specified type. The search is performed + /// hierarchically, breadth first (as opposed to depth first). + /// + /// The type of the element to find + /// The root of the tree to search for. This element itself is not checked. + /// Returns the found element. Null if nothing is found. + public static T FindChild( DependencyObject parent ) where T : DependencyObject + { + return TreeHelper.FindChild( parent, null ); + } + + /// + /// This will search for a child of the specified type. The search is performed + /// hierarchically, breadth first (as opposed to depth first). + /// + /// The type of the element to find + /// The root of the tree to search for. This element itself is not checked. + /// Provide a callback to check additional properties + /// of the found elements. Can be left Null if no additional criteria are needed. + /// Returns the found element. Null if nothing is found. + /// Button button = TreeHelper.FindChild<Button>( this, foundChild => foundChild.Focusable ); + public static T FindChild( DependencyObject parent, Func additionalCheck ) where T : DependencyObject + { + int childrenCount = VisualTreeHelper.GetChildrenCount( parent ); + T child; + + for( int index = 0; index < childrenCount; index++ ) + { + child = VisualTreeHelper.GetChild( parent, index ) as T; + + if( child != null ) + { + if( additionalCheck == null ) + { + return child; + } + else + { + if( additionalCheck( child ) ) + return child; + } + } + } + + for( int index = 0; index < childrenCount; index++ ) + { + child = TreeHelper.FindChild( VisualTreeHelper.GetChild( parent, index ), additionalCheck ); + + if( child != null ) + return child; + } + + return null; + } + + /// + /// Returns true if the specified element is a child of parent somewhere in the visual + /// tree. This method will work for Visual, FrameworkElement and FrameworkContentElement. + /// + /// The element that is potentially a child of the specified parent. + /// The element that is potentially a parent of the specified element. + public static bool IsDescendantOf( DependencyObject element, DependencyObject parent ) + { + return TreeHelper.IsDescendantOf( element, parent, true ); + } + + /// + /// Returns true if the specified element is a child of parent somewhere in the visual + /// tree. This method will work for Visual, FrameworkElement and FrameworkContentElement. + /// + /// The element that is potentially a child of the specified parent. + /// The element that is potentially a parent of the specified element. + public static bool IsDescendantOf( DependencyObject element, DependencyObject parent, bool recurseIntoPopup ) + { + while( element != null ) + { + if( element == parent ) + return true; + + element = TreeHelper.GetParent( element, recurseIntoPopup ); + } + + return false; + } + } +} diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Utilities/ValueChangeHelper.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Utilities/ValueChangeHelper.cs new file mode 100644 index 00000000..1a94f382 --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Core/Utilities/ValueChangeHelper.cs @@ -0,0 +1,153 @@ +/************************************************************************ + + Extended WPF Toolkit + + Copyright (C) 2010-2012 Xceed Software Inc. + + This program is provided to you under the terms of the Microsoft Public + License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license + + This program can be provided to you by Xceed Software Inc. under a + proprietary commercial license agreement for use in non-Open Source + projects. The commercial version of Extended WPF Toolkit also includes + priority technical support, commercial updates, and many additional + useful WPF controls if you license Xceed Business Suite for WPF. + + Visit http://xceed.com and follow @datagrid on Twitter. + + **********************************************************************/ + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Windows; +using System.Collections; +using System.Windows.Data; + +namespace Xceed.Wpf.Toolkit.Core.Utilities +{ + /// + /// This helper class will raise events when a specific + /// path value on one or many items changes. + /// + internal class ValueChangeHelper : DependencyObject + { + + #region Value Property + /// + /// This private property serves as the target of a binding that monitors the value of the binding + /// of each item in the source. + /// + private static readonly DependencyProperty ValueProperty = DependencyProperty.Register( "Value", typeof( object ), typeof( ValueChangeHelper ), new UIPropertyMetadata( null, OnValueChanged ) ); + private object Value + { + get + { + return ( object )GetValue( ValueProperty ); + } + set + { + SetValue( ValueProperty, value ); + } + } + + private static void OnValueChanged( DependencyObject sender, DependencyPropertyChangedEventArgs args ) + { + ( ( ValueChangeHelper )sender ).RaiseValueChanged(); + } + #endregion + + public event EventHandler ValueChanged; + + #region Constructor + + public ValueChangeHelper(Action changeCallback) + { + if( changeCallback == null ) + throw new ArgumentNullException( "changeCallback" ); + + this.ValueChanged += ( s, args ) => changeCallback(); + } + + #endregion + + #region Methods + + public void UpdateValueSource( object sourceItem, string path ) + { + BindingBase binding = null; + if( sourceItem != null && path != null ) + { + binding = new Binding( path ) { Source = sourceItem }; + } + + this.UpdateBinding( binding ); + } + + public void UpdateValueSource( IEnumerable sourceItems, string path ) + { + BindingBase binding = null; + if( sourceItems != null && path != null ) + { + MultiBinding multiBinding = new MultiBinding(); + multiBinding.Converter = new BlankMultiValueConverter(); + + foreach( var item in sourceItems ) + { + multiBinding.Bindings.Add( new Binding( path ) { Source = item } ); + } + + binding = multiBinding; + } + + this.UpdateBinding( binding ); + } + + private void UpdateBinding( BindingBase binding ) + { + if( binding != null ) + { + BindingOperations.SetBinding( this, ValueChangeHelper.ValueProperty, binding ); + } + else + { + this.ClearBinding(); + } + } + + private void ClearBinding() + { + BindingOperations.ClearBinding( this, ValueChangeHelper.ValueProperty ); + } + + private void RaiseValueChanged() + { + if( this.ValueChanged != null ) + { + this.ValueChanged( this, EventArgs.Empty ); + } + } + + #endregion + + #region BlankMultiValueConverter private class + + private class BlankMultiValueConverter : IMultiValueConverter + { + public object Convert( object[] values, Type targetType, object parameter, System.Globalization.CultureInfo culture ) + { + // We will not use the result anyway. We just want the change notification to kick in. + // Return a new object to have a different value. + return new object(); + } + + public object[] ConvertBack( object value, Type[] targetTypes, object parameter, System.Globalization.CultureInfo culture ) + { + throw new InvalidOperationException(); + } + } + + #endregion + } +} diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/DateTimePicker/Themes/Generic.xaml b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/DateTimePicker/Themes/Generic.xaml index 92bb3a18..ef7cfd18 100644 --- a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/DateTimePicker/Themes/Generic.xaml +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/DateTimePicker/Themes/Generic.xaml @@ -36,7 +36,14 @@ - + + + + + + + + @@ -88,6 +95,7 @@ + + diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Obselete/MaskedTextBox/Implementation/MaskedTextBox.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Obselete/MaskedTextBox/Implementation/MaskedTextBox.cs new file mode 100644 index 00000000..ee15e423 --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Obselete/MaskedTextBox/Implementation/MaskedTextBox.cs @@ -0,0 +1,726 @@ +/************************************************************************ + + Extended WPF Toolkit + + Copyright (C) 2010-2012 Xceed Software Inc. + + This program is provided to you under the terms of the Microsoft Public + License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license + + This program can be provided to you by Xceed Software Inc. under a + proprietary commercial license agreement for use in non-Open Source + projects. The commercial version of Extended WPF Toolkit also includes + priority technical support, commercial updates, and many additional + useful WPF controls if you license Xceed Business Suite for WPF. + + Visit http://xceed.com and follow @datagrid on Twitter. + + **********************************************************************/ + +using System; +using System.ComponentModel; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Input; + +namespace Xceed.Wpf.Toolkit.Obselete +{ + [Obsolete("Legacy implementation of MaskedTextBox. Use Xceed.Wpf.Toolkit.MaskedTextBox instead", false)] + public class MaskedTextBox : TextBox + { + #region Members + + /// + /// Flags if the Text and Value properties are in the process of being sync'd + /// + private bool _isSyncingTextAndValueProperties; + private bool _isInitialized; + private bool _convertExceptionOccurred = false; + + #endregion //Members + + #region Properties + + protected MaskedTextProvider MaskProvider + { + get; + set; + } + + #region IncludePrompt + + public static readonly DependencyProperty IncludePromptProperty = DependencyProperty.Register( "IncludePrompt", typeof( bool ), typeof( MaskedTextBox ), new UIPropertyMetadata( false, OnIncludePromptPropertyChanged ) ); + public bool IncludePrompt + { + get + { + return ( bool )GetValue( IncludePromptProperty ); + } + set + { + SetValue( IncludePromptProperty, value ); + } + } + + private static void OnIncludePromptPropertyChanged( DependencyObject o, DependencyPropertyChangedEventArgs e ) + { + MaskedTextBox maskedTextBox = o as MaskedTextBox; + if( maskedTextBox != null ) + maskedTextBox.OnIncludePromptChanged( ( bool )e.OldValue, ( bool )e.NewValue ); + } + + protected virtual void OnIncludePromptChanged( bool oldValue, bool newValue ) + { + ResolveMaskProvider( Mask ); + } + + #endregion //IncludePrompt + + #region IncludeLiterals + + public static readonly DependencyProperty IncludeLiteralsProperty = DependencyProperty.Register( "IncludeLiterals", typeof( bool ), typeof( MaskedTextBox ), new UIPropertyMetadata( true, OnIncludeLiteralsPropertyChanged ) ); + public bool IncludeLiterals + { + get + { + return ( bool )GetValue( IncludeLiteralsProperty ); + } + set + { + SetValue( IncludeLiteralsProperty, value ); + } + } + + private static void OnIncludeLiteralsPropertyChanged( DependencyObject o, DependencyPropertyChangedEventArgs e ) + { + MaskedTextBox maskedTextBox = o as MaskedTextBox; + if( maskedTextBox != null ) + maskedTextBox.OnIncludeLiteralsChanged( ( bool )e.OldValue, ( bool )e.NewValue ); + } + + protected virtual void OnIncludeLiteralsChanged( bool oldValue, bool newValue ) + { + ResolveMaskProvider( Mask ); + } + + #endregion //IncludeLiterals + + #region Mask + + public static readonly DependencyProperty MaskProperty = DependencyProperty.Register( "Mask", typeof( string ), typeof( MaskedTextBox ), new UIPropertyMetadata( "<>", OnMaskPropertyChanged ) ); + public string Mask + { + get + { + return ( string )GetValue( MaskProperty ); + } + set + { + SetValue( MaskProperty, value ); + } + } + + private static void OnMaskPropertyChanged( DependencyObject o, DependencyPropertyChangedEventArgs e ) + { + MaskedTextBox maskedTextBox = o as MaskedTextBox; + if( maskedTextBox != null ) + maskedTextBox.OnMaskChanged( ( string )e.OldValue, ( string )e.NewValue ); + } + + protected virtual void OnMaskChanged( string oldValue, string newValue ) + { + ResolveMaskProvider( newValue ); + UpdateText( 0 ); + } + + #endregion //Mask + + #region PromptChar + + public static readonly DependencyProperty PromptCharProperty = DependencyProperty.Register( "PromptChar", typeof( char ), typeof( MaskedTextBox ), new UIPropertyMetadata( '_', OnPromptCharChanged ) ); + public char PromptChar + { + get + { + return ( char )GetValue( PromptCharProperty ); + } + set + { + SetValue( PromptCharProperty, value ); + } + } + + private static void OnPromptCharChanged( DependencyObject o, DependencyPropertyChangedEventArgs e ) + { + MaskedTextBox maskedTextBox = o as MaskedTextBox; + if( maskedTextBox != null ) + maskedTextBox.OnPromptCharChanged( ( char )e.OldValue, ( char )e.NewValue ); + } + + protected virtual void OnPromptCharChanged( char oldValue, char newValue ) + { + ResolveMaskProvider( Mask ); + } + + #endregion //PromptChar + + #region SelectAllOnGotFocus + + public static readonly DependencyProperty SelectAllOnGotFocusProperty = DependencyProperty.Register( "SelectAllOnGotFocus", typeof( bool ), typeof( MaskedTextBox ), new PropertyMetadata( false ) ); + public bool SelectAllOnGotFocus + { + get + { + return ( bool )GetValue( SelectAllOnGotFocusProperty ); + } + set + { + SetValue( SelectAllOnGotFocusProperty, value ); + } + } + + #endregion //SelectAllOnGotFocus + + #region Text + + private static void OnTextChanged( DependencyObject o, DependencyPropertyChangedEventArgs e ) + { + MaskedTextBox inputBase = o as MaskedTextBox; + if( inputBase != null ) + inputBase.OnTextChanged( ( string )e.OldValue, ( string )e.NewValue ); + } + + protected virtual void OnTextChanged( string oldValue, string newValue ) + { + if( _isInitialized ) + SyncTextAndValueProperties( MaskedTextBox.TextProperty, newValue ); + } + + #endregion //Text + + #region Value + + public static readonly DependencyProperty ValueProperty = DependencyProperty.Register( "Value", typeof( object ), typeof( MaskedTextBox ), new FrameworkPropertyMetadata( null, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnValueChanged ) ); + public object Value + { + get + { + return ( object )GetValue( ValueProperty ); + } + set + { + SetValue( ValueProperty, value ); + } + } + + private static void OnValueChanged( DependencyObject o, DependencyPropertyChangedEventArgs e ) + { + MaskedTextBox maskedTextBox = o as MaskedTextBox; + if( maskedTextBox != null ) + maskedTextBox.OnValueChanged( ( object )e.OldValue, ( object )e.NewValue ); + } + + protected virtual void OnValueChanged( object oldValue, object newValue ) + { + if( _isInitialized ) + SyncTextAndValueProperties( MaskedTextBox.ValueProperty, newValue ); + + RoutedPropertyChangedEventArgs args = new RoutedPropertyChangedEventArgs( oldValue, newValue ); + args.RoutedEvent = MaskedTextBox.ValueChangedEvent; + RaiseEvent( args ); + } + + #endregion //Value + + #region ValueType + + public static readonly DependencyProperty ValueTypeProperty = DependencyProperty.Register( "ValueType", typeof( Type ), typeof( MaskedTextBox ), new UIPropertyMetadata( typeof( String ), OnValueTypeChanged ) ); + public Type ValueType + { + get + { + return ( Type )GetValue( ValueTypeProperty ); + } + set + { + SetValue( ValueTypeProperty, value ); + } + } + + private static void OnValueTypeChanged( DependencyObject o, DependencyPropertyChangedEventArgs e ) + { + MaskedTextBox maskedTextBox = o as MaskedTextBox; + if( maskedTextBox != null ) + maskedTextBox.OnValueTypeChanged( ( Type )e.OldValue, ( Type )e.NewValue ); + } + + protected virtual void OnValueTypeChanged( Type oldValue, Type newValue ) + { + if( _isInitialized ) + SyncTextAndValueProperties( MaskedTextBox.TextProperty, Text ); + } + + #endregion //ValueType + + #endregion //Properties + + #region Constructors + + static MaskedTextBox() + { + TextProperty.OverrideMetadata( typeof( MaskedTextBox ), new FrameworkPropertyMetadata( OnTextChanged ) ); + } + + public MaskedTextBox() + { + CommandBindings.Add( new CommandBinding( ApplicationCommands.Paste, Paste ) ); //handle paste + CommandBindings.Add( new CommandBinding( ApplicationCommands.Cut, null, CanCut ) ); //surpress cut + } + + #endregion //Constructors + + #region Base Class Overrides + + public override void OnApplyTemplate() + { + base.OnApplyTemplate(); + + ResolveMaskProvider( Mask ); + UpdateText( 0 ); + } + + protected override void OnInitialized( EventArgs e ) + { + base.OnInitialized( e ); + + if( !_isInitialized ) + { + _isInitialized = true; + SyncTextAndValueProperties( ValueProperty, Value ); + } + } + + protected override void OnGotKeyboardFocus( KeyboardFocusChangedEventArgs e ) + { + if( SelectAllOnGotFocus ) + { + SelectAll(); + } + + base.OnGotKeyboardFocus( e ); + } + + protected override void OnPreviewKeyDown( KeyEventArgs e ) + { + if( !e.Handled ) + { + HandlePreviewKeyDown( e ); + } + + base.OnPreviewKeyDown( e ); + } + + protected override void OnPreviewTextInput( TextCompositionEventArgs e ) + { + if( !e.Handled ) + { + HandlePreviewTextInput( e ); + } + + base.OnPreviewTextInput( e ); + } + + #endregion //Base Class Overrides + + #region Events + + public static readonly RoutedEvent ValueChangedEvent = EventManager.RegisterRoutedEvent( "ValueChanged", RoutingStrategy.Bubble, typeof( RoutedPropertyChangedEventHandler ), typeof( MaskedTextBox ) ); + public event RoutedPropertyChangedEventHandler ValueChanged + { + add + { + AddHandler( ValueChangedEvent, value ); + } + remove + { + RemoveHandler( ValueChangedEvent, value ); + } + } + + #endregion //Events + + #region Methods + + #region Private + + private void UpdateText() + { + UpdateText( SelectionStart ); + } + + private void UpdateText( int position ) + { + MaskedTextProvider provider = MaskProvider; + if( provider == null ) + throw new InvalidOperationException(); + + Text = provider.ToDisplayString(); + SelectionLength = 0; + SelectionStart = position; + } + + private int GetNextCharacterPosition( int startPosition ) + { + int position = MaskProvider.FindEditPositionFrom( startPosition, true ); + return position == -1 ? startPosition : position; + } + + private void ResolveMaskProvider( string mask ) + { + //do not create a mask provider if the Mask is empty, which can occur if the IncludePrompt and IncludeLiterals properties + //are set prior to the Mask. + if( String.IsNullOrEmpty( mask ) ) + return; + + MaskProvider = new MaskedTextProvider( mask ) + { + IncludePrompt = this.IncludePrompt, + IncludeLiterals = this.IncludeLiterals, + PromptChar = this.PromptChar, + ResetOnSpace = false //should make this a property + }; + } + + private object ConvertTextToValue( string text ) + { + object convertedValue = null; + + Type dataType = ValueType; + + string valueToConvert = MaskProvider.ToString().Trim(); + + try + { + if( valueToConvert.GetType() == dataType || dataType.IsInstanceOfType( valueToConvert ) ) + { + convertedValue = valueToConvert; + } +#if !VS2008 + else if( String.IsNullOrWhiteSpace( valueToConvert ) ) + { + convertedValue = Activator.CreateInstance( dataType ); + } +#else + else if ( String.IsNullOrEmpty( valueToConvert ) ) + { + convertedValue = Activator.CreateInstance( dataType ); + } +#endif + else if( null == convertedValue && valueToConvert is IConvertible ) + { + convertedValue = Convert.ChangeType( valueToConvert, dataType ); + } + } + catch + { + //if an excpetion occurs revert back to original value + _convertExceptionOccurred = true; + return Value; + } + + return convertedValue; + } + + private string ConvertValueToText( object value ) + { + if( value == null ) + value = string.Empty; + + if( _convertExceptionOccurred ) + { + value = Value; + _convertExceptionOccurred = false; + } + + //I have only seen this occur while in Blend, but we need it here so the Blend designer doesn't crash. + if( MaskProvider == null ) + return value.ToString(); + + MaskProvider.Set( value.ToString() ); + return MaskProvider.ToDisplayString(); + } + + private void SyncTextAndValueProperties( DependencyProperty p, object newValue ) + { + //prevents recursive syncing properties + if( _isSyncingTextAndValueProperties ) + return; + + _isSyncingTextAndValueProperties = true; + + //this only occures when the user typed in the value + if( MaskedTextBox.TextProperty == p ) + { + if( newValue != null ) + SetValue( MaskedTextBox.ValueProperty, ConvertTextToValue( newValue.ToString() ) ); + } + + SetValue( MaskedTextBox.TextProperty, ConvertValueToText( newValue ) ); + + _isSyncingTextAndValueProperties = false; + } + + private void HandlePreviewTextInput( TextCompositionEventArgs e ) + { + if( !IsReadOnly ) + { + this.InsertText( e.Text ); + } + + e.Handled = true; + } + + private void HandlePreviewKeyDown( KeyEventArgs e ) + { + if( e.Key == Key.Delete ) + { + e.Handled = IsReadOnly + || HandleKeyDownDelete(); + } + else if( e.Key == Key.Back ) + { + e.Handled = IsReadOnly + || HandleKeyDownBack(); + } + else if( e.Key == Key.Space ) + { + if( !IsReadOnly ) + { + InsertText( " " ); + } + + e.Handled = true; + } + else if( e.Key == Key.Return || e.Key == Key.Enter ) + { + if( !IsReadOnly && AcceptsReturn ) + { + this.InsertText( "\r" ); + } + + // We don't want the OnPreviewTextInput to be triggered for the Return/Enter key + // when it is not accepted. + e.Handled = true; + } + else if( e.Key == Key.Escape ) + { + // We don't want the OnPreviewTextInput to be triggered at all for the Escape key. + e.Handled = true; + } + else if( e.Key == Key.Tab ) + { + if( AcceptsTab ) + { + if( !IsReadOnly ) + { + this.InsertText( "\t" ); + } + + e.Handled = true; + } + } + } + + private bool HandleKeyDownDelete() + { + ModifierKeys modifiers = Keyboard.Modifiers; + bool handled = true; + + if( modifiers == ModifierKeys.None ) + { + if( !RemoveSelectedText() ) + { + int position = SelectionStart; + + if( position < Text.Length ) + { + RemoveText( position, 1 ); + UpdateText( position ); + } + } + else + { + UpdateText(); + } + } + else if( modifiers == ModifierKeys.Control ) + { + if( !RemoveSelectedText() ) + { + int position = SelectionStart; + + RemoveTextToEnd( position ); + UpdateText( position ); + } + else + { + UpdateText(); + } + } + else if( modifiers == ModifierKeys.Shift ) + { + if( RemoveSelectedText() ) + { + UpdateText(); + } + else + { + handled = false; + } + } + else + { + handled = false; + } + + return handled; + } + + private bool HandleKeyDownBack() + { + ModifierKeys modifiers = Keyboard.Modifiers; + bool handled = true; + + if( modifiers == ModifierKeys.None || modifiers == ModifierKeys.Shift ) + { + if( !RemoveSelectedText() ) + { + int position = SelectionStart; + + if( position > 0 ) + { + int newPosition = position - 1; + + RemoveText( newPosition, 1 ); + UpdateText( newPosition ); + } + } + else + { + UpdateText(); + } + } + else if( modifiers == ModifierKeys.Control ) + { + if( !RemoveSelectedText() ) + { + RemoveTextFromStart( SelectionStart ); + UpdateText( 0 ); + } + else + { + UpdateText(); + } + } + else + { + handled = false; + } + + return handled; + } + + private void InsertText( string text ) + { + int position = SelectionStart; + MaskedTextProvider provider = MaskProvider; + + bool textRemoved = this.RemoveSelectedText(); + + position = GetNextCharacterPosition( position ); + + if( !textRemoved && Keyboard.IsKeyToggled( Key.Insert ) ) + { + if( provider.Replace( text, position ) ) + { + position += text.Length; + } + } + else + { + if( provider.InsertAt( text, position ) ) + { + position += text.Length; + } + } + + position = GetNextCharacterPosition( position ); + + this.UpdateText( position ); + } + + private void RemoveTextFromStart( int endPosition ) + { + RemoveText( 0, endPosition ); + } + + private void RemoveTextToEnd( int startPosition ) + { + RemoveText( startPosition, Text.Length - startPosition ); + } + + private void RemoveText( int position, int length ) + { + if( length == 0 ) + return; + + MaskProvider.RemoveAt( position, position + length - 1 ); + } + + private bool RemoveSelectedText() + { + int length = SelectionLength; + + if( length == 0 ) + return false; + + int position = SelectionStart; + + return MaskProvider.RemoveAt( position, position + length - 1 ); + } + + #endregion //Private + + #endregion //Methods + + #region Commands + + private void Paste( object sender, RoutedEventArgs e ) + { + if( IsReadOnly ) + return; + + object data = Clipboard.GetData( DataFormats.Text ); + if( data != null ) + { + string text = data.ToString().Trim(); + if( text.Length > 0 ) + { + int position = SelectionStart; + + MaskProvider.Set( text ); + + UpdateText( position ); + } + } + } + + private void CanCut( object sender, CanExecuteRoutedEventArgs e ) + { + e.CanExecute = false; + e.Handled = true; + } + + #endregion //Commands + } +} diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Properties/AssemblyInfo.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Properties/AssemblyInfo.cs index ad13a5f6..f541a0f9 100644 --- a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Properties/AssemblyInfo.cs +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/Properties/AssemblyInfo.cs @@ -75,6 +75,8 @@ using System.Windows.Markup; [assembly: XmlnsDefinition("http://schemas.xceed.com/wpf/xaml/toolkit", "Xceed.Wpf.Toolkit")] [assembly: XmlnsDefinition("http://schemas.xceed.com/wpf/xaml/toolkit", "Xceed.Wpf.Toolkit.Core.Converters" )] [assembly: XmlnsDefinition("http://schemas.xceed.com/wpf/xaml/toolkit", "Xceed.Wpf.Toolkit.Core.Input" )] +[assembly: XmlnsDefinition("http://schemas.xceed.com/wpf/xaml/toolkit", "Xceed.Wpf.Toolkit.Core.Utilities")] +[assembly: XmlnsDefinition("http://schemas.xceed.com/wpf/xaml/toolkit", "Xceed.Wpf.Toolkit.Chromes")] [assembly: XmlnsDefinition("http://schemas.xceed.com/wpf/xaml/toolkit", "Xceed.Wpf.Toolkit.Primitives")] [assembly: XmlnsDefinition("http://schemas.xceed.com/wpf/xaml/toolkit", "Xceed.Wpf.Toolkit.PropertyGrid")] [assembly: XmlnsDefinition("http://schemas.xceed.com/wpf/xaml/toolkit", "Xceed.Wpf.Toolkit.PropertyGrid.Attributes")] diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/Converters/SelectedObjectConverter.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/Converters/SelectedObjectConverter.cs new file mode 100644 index 00000000..7b062a58 --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/Converters/SelectedObjectConverter.cs @@ -0,0 +1,92 @@ +/************************************************************************ + + Extended WPF Toolkit + + Copyright (C) 2010-2012 Xceed Software Inc. + + This program is provided to you under the terms of the Microsoft Public + License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license + + This program can be provided to you by Xceed Software Inc. under a + proprietary commercial license agreement for use in non-Open Source + projects. The commercial version of Extended WPF Toolkit also includes + priority technical support, commercial updates, and many additional + useful WPF controls if you license Xceed Business Suite for WPF. + + Visit http://xceed.com and follow @datagrid on Twitter. + + **********************************************************************/ + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Windows.Data; +using System.Globalization; +using System.ComponentModel; +using System.Windows; +using System.Reflection; + +namespace Xceed.Wpf.Toolkit.PropertyGrid.Converters +{ + public class SelectedObjectConverter : IValueConverter + { + private const string ValidParameterMessage = @"parameter must be one of the following strings: 'Type', 'TypeName'"; + #region IValueConverter Members + + public object Convert( object value, Type targetType, object parameter, CultureInfo culture ) + { + if( parameter == null ) + throw new ArgumentNullException( "parameter" ); + + if( !( parameter is string ) ) + throw new ArgumentException( SelectedObjectConverter.ValidParameterMessage ); + + if( this.CompareParam(parameter, "Type") ) + { + return this.ConvertToType( value, culture ); + } + else if( this.CompareParam( parameter, "TypeName" ) ) + { + return this.ConvertToTypeName( value, culture ); + } + else + { + throw new ArgumentException( SelectedObjectConverter.ValidParameterMessage ); + } + } + + private bool CompareParam(object parameter, string parameterValue ) + { + return string.Compare( ( string )parameter, parameterValue, true ) == 0; + } + + private object ConvertToType( object value, CultureInfo culture ) + { + return ( value != null ) + ? value.GetType() + : null; + } + + private object ConvertToTypeName( object value, CultureInfo culture ) + { + if( value == null ) + return string.Empty; + + Type newType = value.GetType(); + + DisplayNameAttribute displayNameAttribute = newType.GetCustomAttributes( false ).OfType().FirstOrDefault(); + + return (displayNameAttribute == null) + ? newType.Name + : displayNameAttribute.DisplayName; + } + + public object ConvertBack( object value, Type targetType, object parameter, CultureInfo culture ) + { + throw new NotImplementedException(); + } + + #endregion + } +} diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/Editors/UpDownEditors.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/Editors/UpDownEditors.cs new file mode 100644 index 00000000..994ad9d8 --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/Editors/UpDownEditors.cs @@ -0,0 +1,52 @@ +/************************************************************************ + + Extended WPF Toolkit + + Copyright (C) 2010-2012 Xceed Software Inc. + + This program is provided to you under the terms of the Microsoft Public + License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license + + This program can be provided to you by Xceed Software Inc. under a + proprietary commercial license agreement for use in non-Open Source + projects. The commercial version of Extended WPF Toolkit also includes + priority technical support, commercial updates, and many additional + useful WPF controls if you license Xceed Business Suite for WPF. + + Visit http://xceed.com and follow @datagrid on Twitter. + + **********************************************************************/ + +using Xceed.Wpf.Toolkit.Primitives; +using System; +namespace Xceed.Wpf.Toolkit.PropertyGrid.Editors +{ + public class UpDownEditor : TypeEditor where TEditor : UpDownBase, new() + { + protected override void SetControlProperties() + { + Editor.BorderThickness = new System.Windows.Thickness( 0 ); + } + protected override void SetValueDependencyProperty() + { + ValueProperty = UpDownBase.ValueProperty; + } + } + + public class ByteUpDownEditor : UpDownEditor { } + + public class DecimalUpDownEditor : UpDownEditor { } + + public class DoubleUpDownEditor : UpDownEditor { } + + public class IntegerUpDownEditor : UpDownEditor { } + + public class LongUpDownEditor : UpDownEditor { } + + public class ShortUpDownEditor : UpDownEditor { } + + public class SingleUpDownEditor : UpDownEditor { } + + public class DateTimeUpDownEditor : UpDownEditor { } + +} diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/IPropertyParent.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/IPropertyParent.cs new file mode 100644 index 00000000..18804b01 --- /dev/null +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/IPropertyParent.cs @@ -0,0 +1,36 @@ +/************************************************************************ + + Extended WPF Toolkit + + Copyright (C) 2010-2012 Xceed Software Inc. + + This program is provided to you under the terms of the Microsoft Public + License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license + + This program can be provided to you by Xceed Software Inc. under a + proprietary commercial license agreement for use in non-Open Source + projects. The commercial version of Extended WPF Toolkit also includes + priority technical support, commercial updates, and many additional + useful WPF controls if you license Xceed Business Suite for WPF. + + Visit http://xceed.com and follow @datagrid on Twitter. + + **********************************************************************/ + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using Xceed.Wpf.Toolkit.PropertyGrid.Attributes; + +namespace Xceed.Wpf.Toolkit.PropertyGrid +{ + internal interface IPropertyParent + { + bool IsReadOnly { get; } + + object ValueInstance { get; } + + EditorDefinitionCollection EditorDefinitions { get; } + } +} diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/PropertyGrid.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/PropertyGrid.cs index 5c0d65c3..c46bdb3e 100644 --- a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/PropertyGrid.cs +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/PropertyGrid.cs @@ -30,20 +30,23 @@ using Xceed.Wpf.Toolkit.PropertyGrid.Commands; using System.Collections.Specialized; using System.Windows.Media; using Xceed.Wpf.Toolkit.PropertyGrid.Attributes; +using System.Collections.ObjectModel; namespace Xceed.Wpf.Toolkit.PropertyGrid { [TemplatePart( Name = PART_DragThumb, Type = typeof( Thumb ) )] - public class PropertyGrid : Control, ISupportInitialize + public class PropertyGrid : Control, ISupportInitialize, IPropertyParent { private const string PART_DragThumb = "PART_DragThumb"; #region Members private Thumb _dragThumb; - private List _propertyItemsCache; private bool _hasPendingSelectedObjectChanged; private int _initializationCount; + private PropertyItemCollection _properties; + private PropertyDefinitionCollection _propertyDefinitions; + private EditorDefinitionCollection _editorDefinitions; #endregion //Members @@ -68,7 +71,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid #region AutoGenerateProperties - public static readonly DependencyProperty AutoGeneratePropertiesProperty = DependencyProperty.Register( "AutoGenerateProperties", typeof( bool ), typeof( PropertyGrid ), new UIPropertyMetadata( true ) ); + public static readonly DependencyProperty AutoGeneratePropertiesProperty = DependencyProperty.Register( "AutoGenerateProperties", typeof( bool ), typeof( PropertyGrid ), new UIPropertyMetadata( true, OnAutoGeneratePropertiesChanged ) ); public bool AutoGenerateProperties { get @@ -81,8 +84,16 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid } } + private static void OnAutoGeneratePropertiesChanged( DependencyObject o, DependencyPropertyChangedEventArgs e ) + { + ( ( PropertyGrid )o ).UpdateProperties( true ); + } + #endregion //AutoGenerateProperties + + + #region ShowSummary public static readonly DependencyProperty ShowSummaryProperty = DependencyProperty.Register( "ShowSummary", typeof( bool ), typeof( PropertyGrid ), new UIPropertyMetadata( true ) ); @@ -102,26 +113,20 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid #region EditorDefinitions - public static readonly DependencyProperty EditorDefinitionsProperty = DependencyProperty.Register( "EditorDefinitions", typeof( EditorDefinitionCollection ), typeof( PropertyGrid ), new UIPropertyMetadata( null, OnEditorDefinitionsChanged) ); public EditorDefinitionCollection EditorDefinitions { get { - return ( EditorDefinitionCollection )GetValue( EditorDefinitionsProperty ); + return _editorDefinitions; } set { - SetValue( EditorDefinitionsProperty, value ); + EditorDefinitionCollection oldValue = _editorDefinitions; + _editorDefinitions = value; + this.OnEditorDefinitionsChanged( oldValue, value ); } } - private static void OnEditorDefinitionsChanged( DependencyObject o, DependencyPropertyChangedEventArgs e ) - { - PropertyGrid propertyGrid = o as PropertyGrid; - if( propertyGrid != null ) - propertyGrid.OnEditorDefinitionsChanged( ( EditorDefinitionCollection )e.OldValue, ( EditorDefinitionCollection )e.NewValue ); - } - protected virtual void OnEditorDefinitionsChanged( EditorDefinitionCollection oldValue, EditorDefinitionCollection newValue ) { if( oldValue != null ) @@ -130,7 +135,12 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid if( newValue != null ) newValue.CollectionChanged += new NotifyCollectionChangedEventHandler( OnEditorDefinitionsCollectionChanged ); - RefreshPropertyGrid(); + UpdateProperties( true ); + } + + private void OnEditorDefinitionsCollectionChanged( object sender, NotifyCollectionChangedEventArgs e ) + { + UpdateProperties( true ); } #endregion //EditorDefinitions @@ -159,8 +169,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid protected virtual void OnFilterChanged( string oldValue, string newValue ) { - if( Properties != null ) - Properties.Filter( newValue ); + Properties.Filter( newValue ); } #endregion //Filter @@ -206,7 +215,9 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid protected virtual void OnIsCategorizedChanged( bool oldValue, bool newValue ) { - InitializePropertyGrid( newValue ); + this.UpdateProperties( false ); + this.UpdateThumb(); + } #endregion //IsCategorized @@ -235,23 +246,19 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid protected virtual void OnNameColumnWidthChanged( double oldValue, double newValue ) { - ( ( TranslateTransform )_dragThumb.RenderTransform ).X = newValue; + if( _dragThumb != null ) + ( ( TranslateTransform )_dragThumb.RenderTransform ).X = newValue; } #endregion //NameColumnWidth #region Properties - private static readonly DependencyPropertyKey PropertiesPropertyKey = DependencyProperty.RegisterReadOnly( "Properties", typeof( PropertyItemCollection ), typeof( PropertyGrid ), new UIPropertyMetadata( null ) ); public PropertyItemCollection Properties { get { - return ( PropertyItemCollection )GetValue( PropertiesPropertyKey.DependencyProperty ); - } - private set - { - SetValue( PropertiesPropertyKey, value ); + return _properties; } } @@ -259,26 +266,20 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid #region PropertyDefinitions - public static readonly DependencyProperty PropertyDefinitionsProperty = DependencyProperty.Register( "PropertyDefinitions", typeof( PropertyDefinitionCollection ), typeof( PropertyGrid ), new UIPropertyMetadata( null, OnPropertyDefinitionsChanged ) ); public PropertyDefinitionCollection PropertyDefinitions { get { - return ( PropertyDefinitionCollection )GetValue( PropertyDefinitionsProperty ); + return _propertyDefinitions; } set { - SetValue( PropertyDefinitionsProperty, value ); + PropertyDefinitionCollection oldValue = _propertyDefinitions; + _propertyDefinitions = value; + this.OnPropertyDefinitionsChanged( oldValue, value ); } } - private static void OnPropertyDefinitionsChanged( DependencyObject o, DependencyPropertyChangedEventArgs e ) - { - PropertyGrid propertyGrid = o as PropertyGrid; - if( propertyGrid != null ) - propertyGrid.OnPropertyDefinitionsChanged( ( PropertyDefinitionCollection )e.OldValue, ( PropertyDefinitionCollection )e.NewValue ); - } - protected virtual void OnPropertyDefinitionsChanged( PropertyDefinitionCollection oldValue, PropertyDefinitionCollection newValue ) { if( oldValue != null ) @@ -287,11 +288,45 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid if( newValue != null ) newValue.CollectionChanged += new NotifyCollectionChangedEventHandler( OnPropertyDefinitionsCollectionChanged ); - RefreshPropertyGrid(); + UpdateProperties( true ); + } + + private void OnPropertyDefinitionsCollectionChanged( object sender, NotifyCollectionChangedEventArgs e ) + { + UpdateProperties( true ); } #endregion //PropertyDefinitions + #region IsReadOnly + + public static readonly DependencyProperty IsReadOnlyProperty = DependencyProperty.Register( "IsReadOnly", typeof( bool ), typeof( PropertyGrid ), new UIPropertyMetadata( false, OnIsReadOnlyChanged ) ); + public bool IsReadOnly + { + get + { + return ( bool )GetValue( IsReadOnlyProperty ); + } + set + { + SetValue( IsReadOnlyProperty, value ); + } + } + + private static void OnIsReadOnlyChanged( DependencyObject o, DependencyPropertyChangedEventArgs e ) + { + PropertyGrid propertyGrid = o as PropertyGrid; + if( propertyGrid != null ) + { + foreach( PropertyItem propertyItem in propertyGrid.Properties ) + { + propertyItem.Editor.IsEnabled = !propertyGrid.IsReadOnly; + } + } + } + + #endregion //ReadOnly + #region SelectedObject public static readonly DependencyProperty SelectedObjectProperty = DependencyProperty.Register( "SelectedObject", typeof( object ), typeof( PropertyGrid ), new UIPropertyMetadata( null, OnSelectedObjectChanged ) ); @@ -317,20 +352,15 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid protected virtual void OnSelectedObjectChanged( object oldValue, object newValue ) { // We do not want to process the change now if the grid is initializing (ie. BeginInit/EndInit). - _hasPendingSelectedObjectChanged = IsInitializing(); - - if( IsInitializing() ) - return; - - if( newValue == null ) - ResetPropertyGrid(); - else + if( _initializationCount != 0 ) { - SetSelectedObjectNameBinding( newValue ); - SelectedObjectType = newValue.GetType(); - _propertyItemsCache = GetObjectProperties( newValue ); - InitializePropertyGrid( IsCategorized ); + _hasPendingSelectedObjectChanged = true; + return; } + + this.UpdateProperties( true ); + + RaiseEvent( new RoutedPropertyChangedEventArgs( oldValue, newValue, PropertyGrid.SelectedObjectChangedEvent ) ); } #endregion //SelectedObject @@ -344,7 +374,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid { return ( Type )GetValue( SelectedObjectTypeProperty ); } - private set + set { SetValue( SelectedObjectTypeProperty, value ); } @@ -359,13 +389,6 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid protected virtual void OnSelectedObjectTypeChanged( Type oldValue, Type newValue ) { - if( newValue == null ) - SelectedObjectTypeName = string.Empty; - else - { - DisplayNameAttribute displayNameAttribute = newValue.GetCustomAttributes( false ).OfType().FirstOrDefault(); - SelectedObjectTypeName = displayNameAttribute == null ? newValue.Name : displayNameAttribute.DisplayName; - } } #endregion //SelectedObjectType @@ -379,7 +402,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid { return ( string )GetValue( SelectedObjectTypeNameProperty ); } - private set + set { SetValue( SelectedObjectTypeNameProperty, value ); } @@ -389,19 +412,31 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid #region SelectedObjectName - public static readonly DependencyProperty SelectedObjectNameProperty = DependencyProperty.Register( "SelectedObjectName", typeof( string ), typeof( PropertyGrid ), new UIPropertyMetadata( string.Empty, OnSelectedObjectNameChanged ) ); + public static readonly DependencyProperty SelectedObjectNameProperty = DependencyProperty.Register( "SelectedObjectName", typeof( string ), typeof( PropertyGrid ), new UIPropertyMetadata( string.Empty, OnSelectedObjectNameChanged, OnCoerceSelectedObjectName ) ); public string SelectedObjectName { get { return ( string )GetValue( SelectedObjectNameProperty ); } - private set + set { SetValue( SelectedObjectNameProperty, value ); } } + private static object OnCoerceSelectedObjectName( DependencyObject o, object baseValue ) + { + PropertyGrid propertyGrid = o as PropertyGrid; + if( propertyGrid != null ) + { + if( (propertyGrid.SelectedObject is FrameworkElement) && ( String.IsNullOrEmpty( ( String )baseValue ) )) + return ""; + } + + return baseValue; + } + private static void OnSelectedObjectNameChanged( DependencyObject o, DependencyPropertyChangedEventArgs e ) { PropertyGrid propertyGrid = o as PropertyGrid; @@ -411,7 +446,6 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid protected virtual void SelectedObjectNameChanged( string oldValue, string newValue ) { - } #endregion //SelectedObjectName @@ -443,10 +477,10 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid if( oldValue != null ) oldValue.IsSelected = false; - //if (newValue != null) - // newValue.IsSelected = true; + if( newValue != null ) + newValue.IsSelected = true; - RaiseEvent( new RoutedEventArgs( PropertyGrid.SelectedPropertyItemChangedEvent, newValue ) ); + RaiseEvent( new RoutedPropertyChangedEventArgs( oldValue, newValue, PropertyGrid.SelectedPropertyItemChangedEvent ) ); } #endregion //SelectedPropertyItem @@ -530,8 +564,11 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid public PropertyGrid() { + _properties = new PropertyItemCollection( new ObservableCollection() ); EditorDefinitions = new EditorDefinitionCollection(); PropertyDefinitions = new PropertyDefinitionCollection(); + + AddHandler( PropertyItem.ItemSelectionChangedEvent, new RoutedEventHandler( OnItemSelectionChanged ) ); CommandBindings.Add( new CommandBinding( PropertyGridCommands.ClearFilter, ClearFilter, CanClearFilter ) ); } @@ -560,6 +597,8 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid TranslateTransform _moveTransform = new TranslateTransform(); _moveTransform.X = NameColumnWidth; _dragThumb.RenderTransform = _moveTransform; + + this.UpdateThumb(); } protected override void OnPreviewKeyDown( KeyEventArgs e ) @@ -579,7 +618,23 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid #region Event Handlers - void DragThumb_DragDelta( object sender, DragDeltaEventArgs e ) + private void OnItemSelectionChanged( object sender, RoutedEventArgs args ) + { + PropertyItem item = ( PropertyItem )args.OriginalSource; + if( item.IsSelected ) + { + SelectedPropertyItem = item; + } + else + { + if( object.ReferenceEquals( item, SelectedPropertyItem ) ) + { + SelectedPropertyItem = null; + } + } + } + + private void DragThumb_DragDelta( object sender, DragDeltaEventArgs e ) { NameColumnWidth = Math.Max( 0, NameColumnWidth + e.HorizontalChange ); } @@ -602,123 +657,77 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid #region Methods - private void InitializePropertyGrid( bool isCategorized ) - { - LoadProperties( isCategorized ); - SetDragThumbMargin( isCategorized ); - } - - private void LoadProperties( bool isCategorized ) + private void UpdateProperties( bool regenerateItems ) { - if( _propertyItemsCache == null ) - return; + IEnumerable newProperties = null; + if( regenerateItems ) + { + newProperties = this.GeneratePropertyItems( this.SelectedObject ); - //clear any filters first - Filter = String.Empty; + string defaultPropertyName = PropertyGridUtilities.GetDefaultPropertyName( this.SelectedObject ); + this.SelectedPropertyItem = newProperties.FirstOrDefault( ( prop ) => prop.Name.Equals( defaultPropertyName ) ); + } - if( isCategorized ) - Properties = PropertyGridUtilities.GetCategorizedProperties( _propertyItemsCache ); - else - Properties = PropertyGridUtilities.GetAlphabetizedProperties( _propertyItemsCache ); + Properties.Update( newProperties, IsCategorized, Filter ); } - private List GetObjectProperties( object instance ) + private List GeneratePropertyItems(object instance) { var propertyItems = new List(); - if( instance == null ) - return propertyItems; - try + if( instance != null ) { - PropertyDescriptorCollection descriptors = PropertyGridUtilities.GetPropertyDescriptors( instance ); - - if( !AutoGenerateProperties ) + try { - List specificProperties = new List(); - if( PropertyDefinitions != null ) + PropertyDescriptorCollection descriptors = PropertyGridUtilities.GetPropertyDescriptors( instance ); + + if( !AutoGenerateProperties ) { - foreach( PropertyDefinition pd in PropertyDefinitions ) + List specificProperties = new List(); + if( PropertyDefinitions != null ) { - foreach( PropertyDescriptor descriptor in descriptors ) + foreach( PropertyDefinition pd in PropertyDefinitions ) { - if( descriptor.Name == pd.Name ) + foreach( PropertyDescriptor descriptor in descriptors ) { - specificProperties.Add( descriptor ); - break; + if( descriptor.Name == pd.Name ) + { + specificProperties.Add( descriptor ); + break; + } } } } + + descriptors = new PropertyDescriptorCollection( specificProperties.ToArray() ); } - descriptors = new PropertyDescriptorCollection( specificProperties.ToArray() ); + foreach( PropertyDescriptor descriptor in descriptors ) + { + if( descriptor.IsBrowsable ) + propertyItems.Add( PropertyGridUtilities.CreatePropertyItem( descriptor, this ) ); + } } - - foreach( PropertyDescriptor descriptor in descriptors ) + catch( Exception ) { - if( descriptor.IsBrowsable ) - propertyItems.Add( PropertyGridUtilities.CreatePropertyItem( descriptor, instance, this, descriptor.Name ) ); + //TODO: handle this some how } } - catch( Exception ) - { - //TODO: handle this some how - } return propertyItems; } - private void SetSelectedObjectNameBinding( object selectedObject ) + private void UpdateThumb() { - if( selectedObject is FrameworkElement ) + if( _dragThumb != null ) { - var binding = new Binding( "Name" ); - binding.Source = selectedObject; - binding.Mode = BindingMode.OneWay; - BindingOperations.SetBinding( this, PropertyGrid.SelectedObjectNameProperty, binding ); + if( IsCategorized ) + _dragThumb.Margin = new Thickness( 6, 0, 0, 0 ); + else + _dragThumb.Margin = new Thickness( -1, 0, 0, 0 ); } } - private void SetDragThumbMargin( bool isCategorized ) - { - if( _dragThumb == null ) - return; - - if( isCategorized ) - _dragThumb.Margin = new Thickness( 6, 0, 0, 0 ); - else - _dragThumb.Margin = new Thickness( -1, 0, 0, 0 ); - } - - private void ResetPropertyGrid() - { - SelectedObjectName = String.Empty; - SelectedObjectType = null; - _propertyItemsCache = null; - SelectedPropertyItem = null; - Properties = null; - } - - private void OnEditorDefinitionsCollectionChanged( object sender, NotifyCollectionChangedEventArgs e ) - { - RefreshPropertyGrid(); - } - - private void OnPropertyDefinitionsCollectionChanged( object sender, NotifyCollectionChangedEventArgs e ) - { - RefreshPropertyGrid(); - } - - private void RefreshPropertyGrid() - { - _propertyItemsCache = GetObjectProperties( SelectedObject ); - InitializePropertyGrid( IsCategorized ); - } - - private bool IsInitializing() - { - return _initializationCount != 0; - } - /// /// Updates all property values in the PropertyGrid with the data from the SelectedObject /// @@ -747,8 +756,8 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid } } - public static readonly RoutedEvent SelectedPropertyItemChangedEvent = EventManager.RegisterRoutedEvent( "SelectedPropertyItemChanged", RoutingStrategy.Bubble, typeof( RoutedEventHandler ), typeof( PropertyGrid ) ); - public event RoutedEventHandler SelectedPropertyItemChanged + public static readonly RoutedEvent SelectedPropertyItemChangedEvent = EventManager.RegisterRoutedEvent( "SelectedPropertyItemChanged", RoutingStrategy.Bubble, typeof( RoutedPropertyChangedEventHandler ), typeof( PropertyGrid ) ); + public event RoutedPropertyChangedEventHandler SelectedPropertyItemChanged { add { @@ -760,6 +769,19 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid } } + public static readonly RoutedEvent SelectedObjectChangedEvent = EventManager.RegisterRoutedEvent( "SelectedObjectChanged", RoutingStrategy.Bubble, typeof( RoutedPropertyChangedEventHandler ), typeof( PropertyGrid ) ); + public event RoutedPropertyChangedEventHandler SelectedObjectChanged + { + add + { + AddHandler( SelectedObjectChangedEvent, value ); + } + remove + { + RemoveHandler( SelectedObjectChangedEvent, value ); + } + } + #endregion //Events #region Interfaces @@ -786,12 +808,32 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid if( _hasPendingSelectedObjectChanged ) { //This will update SelectedObject, Type, Name based on the actual config. - OnSelectedObjectChanged( SelectedObject, SelectedObject ); + this.UpdateProperties( true ); + _hasPendingSelectedObjectChanged = false; } } #endregion + #region IPropertyParent Members + + bool IPropertyParent.IsReadOnly + { + get { return this.IsReadOnly; } + } + + object IPropertyParent.ValueInstance + { + get { return this.SelectedObject; } + } + + EditorDefinitionCollection IPropertyParent.EditorDefinitions + { + get { return this.EditorDefinitions; } + } + + #endregion + #endregion } diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/PropertyGridUtilities.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/PropertyGridUtilities.cs index b8ffc753..2cf14c37 100644 --- a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/PropertyGridUtilities.cs +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/PropertyGridUtilities.cs @@ -34,34 +34,17 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid { internal static T GetAttribute( PropertyDescriptor property ) where T : Attribute { - foreach( Attribute att in property.Attributes ) - { - var tAtt = att as T; - if( tAtt != null ) - return tAtt; - } - return null; + return property.Attributes.OfType().FirstOrDefault(); } - internal static PropertyItemCollection GetAlphabetizedProperties( List propertyItems ) - { - PropertyItemCollection propertyCollection = new PropertyItemCollection( propertyItems ); - propertyCollection.SortBy( "DisplayName", ListSortDirection.Ascending ); - return propertyCollection; - } - internal static PropertyItemCollection GetCategorizedProperties( List propertyItems ) + internal static string GetDefaultPropertyName( object instance ) { - PropertyItemCollection propertyCollection = new PropertyItemCollection( propertyItems ); - propertyCollection.GroupBy( "Category" ); - propertyCollection.SortBy( "Category", ListSortDirection.Ascending ); - - propertyCollection.SortBy( "PropertyOrder", ListSortDirection.Ascending ); - propertyCollection.SortBy( "DisplayName", ListSortDirection.Ascending ); - return propertyCollection; + AttributeCollection attributes = TypeDescriptor.GetAttributes( instance ); + DefaultPropertyAttribute defaultPropertyAttribute =( DefaultPropertyAttribute )attributes[ typeof( DefaultPropertyAttribute ) ]; + return defaultPropertyAttribute != null ? defaultPropertyAttribute.Name : null; } - internal static PropertyDescriptorCollection GetPropertyDescriptors( object instance ) { PropertyDescriptorCollection descriptors; @@ -83,33 +66,31 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid return descriptors; } - internal static PropertyItem CreatePropertyItem( PropertyDescriptor property, object instance, PropertyGrid grid, string bindingPath ) + internal static PropertyItem CreatePropertyItem( PropertyDescriptor property, IPropertyParent propertyParent ) { - return CreatePropertyItem(property, instance, grid, bindingPath, 0); + return CreatePropertyItem( property, propertyParent, 0 ); } - internal static PropertyItem CreatePropertyItem( PropertyDescriptor property, object instance, PropertyGrid grid, string bindingPath, int level ) + internal static PropertyItem CreatePropertyItem( PropertyDescriptor property, IPropertyParent propertyParent, int level ) { - PropertyItem propertyItem = new PropertyItem( instance, property, grid, bindingPath, level ); + PropertyItem propertyItem = new PropertyItem( property, propertyParent, level ); - var binding = new Binding( bindingPath ) + var binding = new Binding( property.Name ) { - Source = instance, + Source = propertyParent.ValueInstance, ValidatesOnExceptions = true, ValidatesOnDataErrors = true, Mode = propertyItem.IsReadOnly ? BindingMode.OneWay : BindingMode.TwoWay }; propertyItem.SetBinding( PropertyItem.ValueProperty, binding ); - propertyItem.Editor = PropertyGridUtilities.GetTypeEditor( propertyItem - , grid.EditorDefinitions - ); + propertyItem.Editor = PropertyGridUtilities.GetTypeEditor( propertyItem, propertyParent.EditorDefinitions ); return propertyItem; } - internal static FrameworkElement GetTypeEditor( PropertyItem propertyItem - , EditorDefinitionCollection editorDefinitions - ) + internal static FrameworkElement GetTypeEditor( + PropertyItem propertyItem, + EditorDefinitionCollection editorDefinitions ) { FrameworkElement editor = null; @@ -125,6 +106,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid if( editor == null ) editor = PropertyGridUtilities.CreateDefaultEditor( propertyItem ); + editor.IsEnabled = !propertyItem.PropertyParent.IsReadOnly; return editor; } @@ -188,6 +170,22 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid editor = new DoubleUpDownEditor(); else if( propertyItem.PropertyType == typeof( int ) || propertyItem.PropertyType == typeof( int? ) ) editor = new IntegerUpDownEditor(); + else if( propertyItem.PropertyType == typeof( short ) || propertyItem.PropertyType == typeof( short? ) ) + editor = new ShortUpDownEditor(); + else if( propertyItem.PropertyType == typeof( long ) || propertyItem.PropertyType == typeof( long? ) ) + editor = new LongUpDownEditor(); + else if( propertyItem.PropertyType == typeof( float ) || propertyItem.PropertyType == typeof( float? ) ) + editor = new SingleUpDownEditor(); + else if( propertyItem.PropertyType == typeof( byte ) || propertyItem.PropertyType == typeof( byte? ) ) + editor = new ByteUpDownEditor(); + else if( propertyItem.PropertyType == typeof( sbyte ) || propertyItem.PropertyType == typeof( sbyte? ) ) + editor = new UpDownEditor(); + else if( propertyItem.PropertyType == typeof( uint ) || propertyItem.PropertyType == typeof( uint? ) ) + editor = new UpDownEditor(); + else if( propertyItem.PropertyType == typeof( ulong ) || propertyItem.PropertyType == typeof( ulong? ) ) + editor = new UpDownEditor(); + else if( propertyItem.PropertyType == typeof( ushort ) || propertyItem.PropertyType == typeof( ushort? ) ) + editor = new UpDownEditor(); else if( propertyItem.PropertyType == typeof( DateTime ) || propertyItem.PropertyType == typeof( DateTime? ) ) editor = new DateTimeUpDownEditor(); else if( ( propertyItem.PropertyType == typeof( Color ) ) ) @@ -198,11 +196,16 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid editor = new TimeSpanEditor(); else if( propertyItem.PropertyType == typeof( FontFamily ) || propertyItem.PropertyType == typeof( FontWeight ) || propertyItem.PropertyType == typeof( FontStyle ) || propertyItem.PropertyType == typeof( FontStretch ) ) editor = new FontComboBoxEditor(); + else if( propertyItem.PropertyType == typeof( object ) ) + // If any type of object is possible in the property, default to the TextBoxEditor. + // Useful in some case (e.g., Button.Content). + // Can be reconsidered but was the legacy behavior on the PropertyGrid. + editor = new TextBoxEditor(); else { - Type listType = CollectionEditor.GetListItemType(propertyItem.PropertyType); + Type listType = CollectionEditor.GetListItemType( propertyItem.PropertyType ); - if(listType != null) + if( listType != null ) { if( !listType.IsPrimitive && !listType.Equals( typeof( String ) ) ) editor = new Xceed.Wpf.Toolkit.PropertyGrid.Editors.CollectionEditor(); @@ -210,7 +213,15 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid editor = new Xceed.Wpf.Toolkit.PropertyGrid.Editors.PrimitiveTypeCollectionEditor(); } else - editor = new TextBoxEditor(); + { + // If the type is not supported, check if there is a converter that supports + // string conversion to the object type. Use TextBox in theses cases. + // Otherwise, return a TextBlock editor since no valid editor exists. + TypeConverter typeConverter = propertyItem.PropertyDescriptor.Converter; + editor = ( typeConverter != null && typeConverter.CanConvertFrom( typeof( string ) ) ) + ? ( ITypeEditor )new TextBoxEditor() + : ( ITypeEditor )new TextBlockEditor(); + } } return editor.ResolveEditor( propertyItem ); diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/PropertyItem.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/PropertyItem.cs index 1684b3e4..0ecdb32a 100644 --- a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/PropertyItem.cs +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/PropertyItem.cs @@ -28,50 +28,73 @@ using System.Windows.Input; using System.Windows.Markup.Primitives; using Xceed.Wpf.Toolkit.PropertyGrid.Attributes; using Xceed.Wpf.Toolkit.PropertyGrid.Commands; +using System.Collections.ObjectModel; +using Xceed.Wpf.Toolkit.Core.Utilities; namespace Xceed.Wpf.Toolkit.PropertyGrid { - public class PropertyItem : Control + public class PropertyItem : Control, INotifyPropertyChanged, IPropertyParent { #region Members - private DependencyPropertyDescriptor _dpDescriptor; - private MarkupObject _markupObject; + private readonly DependencyPropertyDescriptor _dpDescriptor; + private readonly MarkupObject _markupObject; + private readonly NotifyPropertyChangedHelper _propertyChangedHelper; + + private string _displayName; + private string _description; + private string _category; + private int _categoryOrder; + private int _propertyOrder; #endregion //Members #region Properties - public string BindingPath - { - get; - private set; - } #region Category - public static readonly DependencyProperty CategoryProperty = DependencyProperty.Register( "Category", typeof( string ), typeof( PropertyItem ), new UIPropertyMetadata( string.Empty ) ); public string Category { get { - return ( string )GetValue( CategoryProperty ); + return _category; } set { - SetValue( CategoryProperty, value ); + _propertyChangedHelper.HandleEqualityChanged( () => Category, ref _category, value ); } } #endregion //Category + #region CategoryOrder + + public int CategoryOrder + { + get + { + return _categoryOrder; + } + set + { + _propertyChangedHelper.HandleEqualityChanged( () => CategoryOrder, ref _categoryOrder, value ); + } + } + + #endregion // CategoryOrder + #region Description public string Description { get { - return PropertyDescriptor.Description; + return _description; + } + set + { + _propertyChangedHelper.HandleEqualityChanged( () => Description, ref _description, value ); } } @@ -79,16 +102,15 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid #region DisplayName - public static readonly DependencyProperty DisplayNameProperty = DependencyProperty.Register( "DisplayName", typeof( string ), typeof( PropertyItem ), new UIPropertyMetadata( null ) ); public string DisplayName { get { - return ( string )GetValue( DisplayNameProperty ); + return _displayName; } set { - SetValue( DisplayNameProperty, value ); + _propertyChangedHelper.HandleEqualityChanged( () => DisplayName, ref _displayName, value ); } } @@ -129,18 +151,10 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid #region Instance - private object _instance; public object Instance { - get - { - return _instance; - } - private set - { - _instance = value; - _markupObject = MarkupWriter.GetMarkupObjectFor( _instance ); - } + get; + private set; } #endregion //Instance @@ -154,7 +168,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid { get { - var dependencyObject = Instance as DependencyObject; + var dependencyObject = PropertyParent.ValueInstance as DependencyObject; if( dependencyObject != null && _dpDescriptor != null ) return BindingOperations.GetBindingExpressionBase( dependencyObject, _dpDescriptor.DependencyProperty ) != null; @@ -203,7 +217,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid protected virtual void OnIsExpandedChanged( bool oldValue, bool newValue ) { - if( newValue && ( Properties == null || Properties.Count == 0 ) ) + if( newValue && Properties.Count == 0 ) { GetChildProperties(); } @@ -247,8 +261,10 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid public bool IsReadOnly { - get; - private set; + get + { + return PropertyDescriptor.IsReadOnly; + } } #region IsSelected @@ -275,75 +291,66 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid protected virtual void OnIsSelectedChanged( bool oldValue, bool newValue ) { - if( newValue ) - PropertyGrid.SelectedPropertyItem = this; + this.RaiseItemSelectionChangedEvent(); } #endregion //IsSelected #region Level - public static readonly DependencyProperty LevelProperty = DependencyProperty.Register( "Level", typeof( int ), typeof( PropertyItem ), new UIPropertyMetadata( 0 ) ); public int Level { - get - { - return ( int )GetValue( LevelProperty ); - } - set - { - SetValue( LevelProperty, value ); - } + get; + private set; } #endregion //Level #region Properties - public static readonly DependencyProperty PropertiesProperty = DependencyProperty.Register( "Properties", typeof( PropertyItemCollection ), typeof( PropertyItem ), new UIPropertyMetadata( null ) ); public PropertyItemCollection Properties { - get - { - return ( PropertyItemCollection )GetValue( PropertiesProperty ); - } - set - { - SetValue( PropertiesProperty, value ); - } + get; + private set; } #endregion //Properties #region PropertyDescriptor - private PropertyDescriptor _propertyDescriptor; public PropertyDescriptor PropertyDescriptor { - get - { - return _propertyDescriptor; - } - private set - { - _propertyDescriptor = value; - _dpDescriptor = DependencyPropertyDescriptor.FromProperty( _propertyDescriptor ); - } + get; + private set; } #endregion //PropertyDescriptor - public PropertyGrid PropertyGrid + #region PropertyParent + + internal IPropertyParent PropertyParent { get; private set; } + #endregion + + #region PropertyOrder + public int PropertyOrder { - get; - set; - } //maybe make a DP + get + { + return _propertyOrder; + } + set + { + _propertyChangedHelper.HandleEqualityChanged( () => PropertyOrder, ref _propertyOrder, value ); + } + } + + #endregion #region PropertyType @@ -357,12 +364,16 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid #endregion //PropertyType + #region ResetValueCommand + public ICommand ResetValueCommand { get; private set; } + #endregion + #region Value public static readonly DependencyProperty ValueProperty = DependencyProperty.Register( "Value", typeof( object ), typeof( PropertyItem ), new UIPropertyMetadata( null, OnValueChanged ) ); @@ -391,7 +402,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid { if( IsInitialized ) { - PropertyGrid.RaiseEvent( new PropertyValueChangedEventArgs( PropertyGrid.PropertyValueChangedEvent, this, oldValue, newValue ) ); + RaiseEvent( new PropertyValueChangedEventArgs( PropertyGrid.PropertyValueChangedEvent, this, oldValue, newValue ) ); } } @@ -406,7 +417,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid { get { - var dependencyObject = Instance as DependencyObject; + var dependencyObject = PropertyParent.ValueInstance as DependencyObject; if( _dpDescriptor != null && dependencyObject != null ) return DependencyPropertyHelper.GetValueSource( dependencyObject, _dpDescriptor.DependencyProperty ).BaseValueSource; @@ -418,6 +429,25 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid #endregion //Properties + #region Events + + public event PropertyChangedEventHandler PropertyChanged; + + #region ItemSelectionChanged + + internal static readonly RoutedEvent ItemSelectionChangedEvent = EventManager.RegisterRoutedEvent( + "ItemSelectedEvent", RoutingStrategy.Bubble, typeof( RoutedEventHandler ), typeof( PropertyItem ) ); + + // This method raises the Tap event + private void RaiseItemSelectionChangedEvent() + { + RaiseEvent( new RoutedEventArgs( PropertyItem.ItemSelectionChangedEvent ) ); + } + + #endregion + + #endregion + #region Constructors static PropertyItem() @@ -425,18 +455,26 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid DefaultStyleKeyProperty.OverrideMetadata( typeof( PropertyItem ), new FrameworkPropertyMetadata( typeof( PropertyItem ) ) ); } - public PropertyItem( object instance, PropertyDescriptor property, PropertyGrid propertyGrid, string bindingPath, int level ) + internal PropertyItem( PropertyDescriptor property, IPropertyParent propertyParent, int level ) { + _propertyChangedHelper = new NotifyPropertyChangedHelper( this, RaisePropertyChanged ); + Properties = new PropertyItemCollection( new ObservableCollection() ); + PropertyParent = propertyParent; PropertyDescriptor = property; - PropertyGrid = propertyGrid; - Instance = instance; - BindingPath = bindingPath; Level = level; - SetPropertyDescriptorProperties(); - ResolveParenthesisPropertyName(); - ResolveExpandableObject(); - ResolvePropertyOrder(); + + Name = PropertyDescriptor.Name; + Category = PropertyDescriptor.Category; + CategoryOrder = 0; + + Description = ResolveDescription(); + DisplayName = ResolveDisplayName(); + HasChildProperties = ResolveExpandableObject(); + PropertyOrder = ResolvePropertyOrder(); + + _dpDescriptor = DependencyPropertyDescriptor.FromProperty( PropertyDescriptor ); + _markupObject = MarkupWriter.GetMarkupObjectFor( PropertyParent.ValueInstance ); CommandBindings.Add( new CommandBinding( PropertyItemCommands.ResetValue, ExecuteResetValueCommand, CanExecuteResetValueCommand ) ); AddHandler( Mouse.PreviewMouseDownEvent, new MouseButtonEventHandler( PropertyItem_PreviewMouseDown ), true ); @@ -457,8 +495,8 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid private void ExecuteResetValueCommand( object sender, ExecutedRoutedEventArgs e ) { - if( PropertyDescriptor.CanResetValue( Instance ) ) - PropertyDescriptor.ResetValue( Instance ); + if( PropertyDescriptor.CanResetValue( PropertyParent.ValueInstance ) ) + PropertyDescriptor.ResetValue( PropertyParent.ValueInstance ); //TODO: notify UI that the ValueSource may have changed to update the icon } @@ -467,7 +505,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid { bool canExecute = false; - if( PropertyDescriptor.CanResetValue( Instance ) && !PropertyDescriptor.IsReadOnly ) + if( PropertyDescriptor.CanResetValue( PropertyParent.ValueInstance ) && !PropertyDescriptor.IsReadOnly ) { canExecute = true; } @@ -479,6 +517,14 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid #region Methods + private void RaisePropertyChanged( string propertyName ) + { + if( this.PropertyChanged != null ) + { + this.PropertyChanged( this, new PropertyChangedEventArgs( propertyName ) ); + } + } + private void GetChildProperties() { if( Value == null ) @@ -494,7 +540,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid { if( descriptor.IsBrowsable ) { - PropertyItem childPropertyItem = PropertyGridUtilities.CreatePropertyItem( descriptor, Instance, PropertyGrid, String.Format( "{0}.{1}", BindingPath, descriptor.Name ), Level + 1 ); + PropertyItem childPropertyItem = PropertyGridUtilities.CreatePropertyItem( descriptor, this, Level + 1 ); propertyItems.Add( childPropertyItem ); } } @@ -504,45 +550,89 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid //TODO: handle this some how } - Properties = PropertyGridUtilities.GetAlphabetizedProperties( propertyItems ); + Properties.Update( propertyItems, false, null ); } - private void ResolveParenthesisPropertyName() + private string ResolveDescription() { - var attribute = PropertyGridUtilities.GetAttribute( PropertyDescriptor ); + //We do not simply rely on the "Description" property of PropertyDescriptor + //since this value is cached bye PropertyDescriptor and the localized version + //(eg. LocalizedDescriptionAttribute) value can dynamicaly change + DescriptionAttribute descriptionAtt = GetAttribute(); + return ( descriptionAtt != null ) + ? descriptionAtt.Description + : PropertyDescriptor.Description; + } + + + + + + + + + private string ResolveDisplayName() + { + string displayName = PropertyDescriptor.DisplayName; + var attribute = GetAttribute(); if( (attribute != null) && attribute.NeedParenthesis ) { - DisplayName = "(" + DisplayName + ")"; + displayName = "(" + displayName + ")"; } + + return displayName; } - private void ResolveExpandableObject() + private bool ResolveExpandableObject() { - var attribute = PropertyGridUtilities.GetAttribute( PropertyDescriptor ); + bool isExpandable = false; + var attribute = GetAttribute(); if( attribute != null ) { - HasChildProperties = true; - IsReadOnly = true; + isExpandable = true; } + + return isExpandable; } - private void ResolvePropertyOrder() + private int ResolvePropertyOrder() { - var attrs = PropertyDescriptor.Attributes.OfType(); - if( attrs.Any() ) - PropertyOrder = attrs.First().Order; - else - PropertyOrder = 0; + var attribute = GetAttribute(); + + // Max Value. Properties with no order will be displayed last. + return ( attribute != null ) + ? attribute.Order + : int.MaxValue; } - private void SetPropertyDescriptorProperties() + private T GetAttribute() where T : Attribute { - Name = PropertyDescriptor.Name; - DisplayName = PropertyDescriptor.DisplayName; - Category = PropertyDescriptor.Category; - IsReadOnly = PropertyDescriptor.IsReadOnly; + return PropertyGridUtilities.GetAttribute( PropertyDescriptor ); } #endregion //Methods + + #region Interfaces + + #region IPropertyParent Members + + bool IPropertyParent.IsReadOnly + { + get { return PropertyParent.IsReadOnly; } + } + + object IPropertyParent.ValueInstance + { + get { return Value; } + } + + EditorDefinitionCollection IPropertyParent.EditorDefinitions + { + get { return PropertyParent.EditorDefinitions; } + } + + #endregion + + #endregion } } diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/PropertyItemCollection.cs b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/PropertyItemCollection.cs index 53961ee1..f18b064c 100644 --- a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/PropertyItemCollection.cs +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/PropertyItemCollection.cs @@ -21,26 +21,23 @@ using System.Collections.Generic; using System.Collections.ObjectModel; using System.ComponentModel; using System.Windows.Data; +using System; +using System.Collections.Specialized; +using System.Diagnostics; namespace Xceed.Wpf.Toolkit.PropertyGrid { - public class PropertyItemCollection : ObservableCollection + public class PropertyItemCollection : ReadOnlyObservableCollection { - public PropertyItemCollection() - { - - } + private bool _preventNotification; - public PropertyItemCollection( List list ) - : base( list ) + public PropertyItemCollection(ObservableCollection editableCollection) + :base(editableCollection) { - + EditableCollection = editableCollection; } - public PropertyItemCollection( IEnumerable collection ) - : base( collection ) - { - } + public ObservableCollection EditableCollection { get; private set; } private ICollectionView GetDefaultView() { @@ -68,5 +65,52 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid return property.DisplayName.ToLower().StartsWith( text.ToLower() ); }; } + + protected override void OnCollectionChanged( NotifyCollectionChangedEventArgs args ) + { + if( _preventNotification ) + return; + + base.OnCollectionChanged( args ); + } + + internal void Update( IEnumerable newItems, bool isCategorized, string filter ) + { + using( GetDefaultView().DeferRefresh() ) + { + _preventNotification = true; + + // Replace the collection content with the new items. + if( newItems != null ) + { + EditableCollection.Clear(); + foreach( var item in newItems ) + { + this.EditableCollection.Add( item ); + } + } + + // Clear view values + ICollectionView view = this.GetDefaultView(); + view.GroupDescriptions.Clear(); + view.SortDescriptions.Clear(); + view.Filter = null; + + // Update view values + if( isCategorized ) + { + GroupBy( "Category" ); + SortBy( "Category", ListSortDirection.Ascending ); + } + + SortBy( "PropertyOrder", ListSortDirection.Ascending ); + SortBy( "DisplayName", ListSortDirection.Ascending ); + + Filter( filter ); + + _preventNotification = false; + OnCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Reset ) ); + } + } } } diff --git a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Themes/Generic.xaml b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Themes/Generic.xaml index 2f8c6e0c..41db4dfd 100644 --- a/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Themes/Generic.xaml +++ b/ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Themes/Generic.xaml @@ -24,7 +24,8 @@ xmlns:conv="clr-namespace:Xceed.Wpf.Toolkit.Core.Converters" xmlns:pgconv="clr-namespace:Xceed.Wpf.Toolkit.PropertyGrid.Converters" xmlns:utilities="clr-namespace:Xceed.Wpf.Toolkit.Core.Utilities" - xmlns:commands="clr-namespace:Xceed.Wpf.Toolkit.PropertyGrid.Commands"> + xmlns:commands="clr-namespace:Xceed.Wpf.Toolkit.PropertyGrid.Commands" + xmlns:sys="clr-namespace:System;assembly=mscorlib"> @@ -36,6 +37,8 @@ + + @@ -358,7 +361,7 @@ - + @@ -392,18 +395,27 @@ - + + + + + + + + + + + + + + + +Here, you can test various expression that will be parsed. +The result of the parsing will be shown in the second TextBox. +Don't forget to check the Output Window for errors that could have occured during the +automated tests. Untested expressions by the automated tests should be added when found. + + + + + + + + + + + + + + + + + + + + + + + + + + + Invariant + fr-FR + en-US + + + + + + + + + + + + + + + +