diff --git a/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/DisplayMemberPathSample.csproj b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/DisplayMemberPathSample.csproj new file mode 100644 index 0000000..80b4af4 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/DisplayMemberPathSample.csproj @@ -0,0 +1,94 @@ + + + Debug + AnyCPU + {2B163AD0-ADD4-4019-AE95-8380CFE36E71} + DisplayMemberPathSample + DisplayMemberPathSample + 4 + winexe + 1.0.0.* + + 8.0.50215 + 2.0 + v3.0 + {60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + + + 2.0 + + + + + true + full + false + .\bin\Debug\ + DEBUG;TRACE + + + false + true + .\bin\Release\ + TRACE + + + + + + + + + + + + + + + + + + + + MSBuild:Compile + Designer + + + MSBuild:Compile + Designer + + + MyApp.xaml + Code + + + Window1.xaml + Code + + + + + + + + ResXFileCodeGenerator + Resources.Designer.cs + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + True + True + Resources.resx + + + True + True + Settings.settings + + + + + \ No newline at end of file diff --git a/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/DisplayMemberPathSample.csproj.user b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/DisplayMemberPathSample.csproj.user new file mode 100644 index 0000000..6481ba3 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/DisplayMemberPathSample.csproj.user @@ -0,0 +1,5 @@ + + + 8.0.50215 + + \ No newline at end of file diff --git a/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/DisplayMemberPathSample.sln b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/DisplayMemberPathSample.sln new file mode 100644 index 0000000..830761c --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/DisplayMemberPathSample.sln @@ -0,0 +1,20 @@ + +Microsoft Visual Studio Solution File, Format Version 10.00 +# Visual Studio 2008 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DisplayMemberPathSample", "DisplayMemberPathSample.csproj", "{2B163AD0-ADD4-4019-AE95-8380CFE36E71}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {2B163AD0-ADD4-4019-AE95-8380CFE36E71}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {2B163AD0-ADD4-4019-AE95-8380CFE36E71}.Debug|Any CPU.Build.0 = Debug|Any CPU + {2B163AD0-ADD4-4019-AE95-8380CFE36E71}.Release|Any CPU.ActiveCfg = Release|Any CPU + {2B163AD0-ADD4-4019-AE95-8380CFE36E71}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/DisplayMemberPathSample.suo b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/DisplayMemberPathSample.suo new file mode 100644 index 0000000..39e8816 Binary files /dev/null and b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/DisplayMemberPathSample.suo differ diff --git a/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/GreekGod.cs b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/GreekGod.cs new file mode 100644 index 0000000..8d7cc29 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/GreekGod.cs @@ -0,0 +1,40 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace DisplayMemberPathSample +{ + public class GreekGod + { + private string name; + + public string Name + { + get { return name; } + set { name = value; } + } + + private string description; + + public string Description + { + get { return description; } + set { description = value; } + } + + private string romanName; + + public string RomanName + { + get { return romanName; } + set { romanName = value; } + } + + public GreekGod(string name, string description, string romanName) + { + this.name = name; + this.description = description; + this.romanName = romanName; + } + } +} diff --git a/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/GreekGods.cs b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/GreekGods.cs new file mode 100644 index 0000000..b958efe --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/GreekGods.cs @@ -0,0 +1,27 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Windows.Data; +using System.Collections.ObjectModel; + +namespace DisplayMemberPathSample +{ + public class GreekGods : ObservableCollection + { + public GreekGods() + { + this.Add(new GreekGod("Aphrodite", "Goddess of love, beauty and fertility", "Venus")); + this.Add(new GreekGod("Apollo", "God of prophesy, music and healing", "Apollo")); + this.Add(new GreekGod("Ares", "God of war", "Mars")); + this.Add(new GreekGod("Artemis", "Virgin goddess of the hunt", "Diana")); + this.Add(new GreekGod("Athena", "Goddess of crafts and the domestic arts", "Athena")); + this.Add(new GreekGod("Demeter", "Goddess of agriculture", "Ceres")); + this.Add(new GreekGod("Dionysus", "God of wine", "Bacchus")); + this.Add(new GreekGod("Hephaestus", "God of fire and crafts", "Vulcan")); + this.Add(new GreekGod("Hera", "Goddess of marriage", "Juno")); + this.Add(new GreekGod("Hermes", "Messenger of the Gods", "Mercury")); + this.Add(new GreekGod("Poseidon", "God of the sea, earthquakes and horses", "Neptune")); + this.Add(new GreekGod("Zeus", "Supreme God of the Olympians", "Jupiter")); + } + } +} diff --git a/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/MyApp.xaml b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/MyApp.xaml new file mode 100644 index 0000000..606eb69 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/MyApp.xaml @@ -0,0 +1,9 @@ + + + + + diff --git a/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/MyApp.xaml.cs b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/MyApp.xaml.cs new file mode 100644 index 0000000..4c8ab52 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/MyApp.xaml.cs @@ -0,0 +1,23 @@ +using System; +using System.Windows; +using System.Data; +using System.Xml; +using System.Configuration; + +namespace DisplayMemberPathSample +{ + /// + /// Interaction logic for MyApp.xaml + /// + + public partial class MyApp : Application + { + + void AppStartup(object sender, StartupEventArgs args) + { + Window1 mainWindow = new Window1(); + mainWindow.Show(); + } + + } +} \ No newline at end of file diff --git a/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Properties/AssemblyInfo.cs b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..7242164 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Properties/AssemblyInfo.cs @@ -0,0 +1,54 @@ +#region Using directives + +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Resources; +using System.Globalization; +using System.Windows; +using System.Runtime.InteropServices; + +#endregion + +// 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("DisplayMemberPathSample")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("DisplayMemberPathSample")] +[assembly: AssemblyCopyright("Copyright @ 2005")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] +[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 Revision and Build Numbers +// by using the '*' as shown below: +[assembly: AssemblyVersion("1.0.*")] diff --git a/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Properties/Resources.Designer.cs b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Properties/Resources.Designer.cs new file mode 100644 index 0000000..c91f734 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Properties/Resources.Designer.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:2.0.50727.1318 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace DisplayMemberPathSample.Properties { + using System; + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "2.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("DisplayMemberPathSample.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + } +} diff --git a/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Properties/Resources.resx b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Properties/Resources.resx new file mode 100644 index 0000000..3e18af9 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Properties/Resources.resx @@ -0,0 +1,117 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Properties/Settings.Designer.cs b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Properties/Settings.Designer.cs new file mode 100644 index 0000000..8fad115 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Properties/Settings.Designer.cs @@ -0,0 +1,26 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:2.0.50727.1318 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace DisplayMemberPathSample.Properties { + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "9.0.0.0")] + internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase { + + private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings()))); + + public static Settings Default { + get { + return defaultInstance; + } + } + } +} diff --git a/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Properties/Settings.settings b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Properties/Settings.settings new file mode 100644 index 0000000..4024694 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file diff --git a/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Window1.xaml b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Window1.xaml new file mode 100644 index 0000000..4ef4d5a --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Window1.xaml @@ -0,0 +1,24 @@ + + + + + + + + + + + + + + + + diff --git a/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Window1.xaml.cs b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Window1.xaml.cs new file mode 100644 index 0000000..c296272 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Window1.xaml.cs @@ -0,0 +1,19 @@ +using System; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Data; +using System.Windows.Documents; +using System.Windows.Media; +using System.Windows.Shapes; + + +namespace DisplayMemberPathSample +{ + public partial class Window1 : Window + { + public Window1() + { + InitializeComponent(); + } + } +} \ No newline at end of file diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample.sln b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample.sln new file mode 100644 index 0000000..296e842 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample.sln @@ -0,0 +1,20 @@ + +Microsoft Visual Studio Solution File, Format Version 9.00 +# Visual Studio 2005 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DisplayMemberPathSample", "DisplayMemberPathSample\DisplayMemberPathSample.csproj", "{F86959BA-0DC3-416A-92BC-33DE959D371A}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {F86959BA-0DC3-416A-92BC-33DE959D371A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F86959BA-0DC3-416A-92BC-33DE959D371A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F86959BA-0DC3-416A-92BC-33DE959D371A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F86959BA-0DC3-416A-92BC-33DE959D371A}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample.suo b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample.suo new file mode 100644 index 0000000..d8b5709 Binary files /dev/null and b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample.suo differ diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample.csproj b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample.csproj new file mode 100644 index 0000000..6975ff1 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample.csproj @@ -0,0 +1,81 @@ + + + Debug + AnyCPU + {F86959BA-0DC3-416A-92BC-33DE959D371A} + DisplayMemberPathSample + DisplayMemberPathSample + 4 + winexe + 1.0.0.* + + 8.0.50215 + 2.0 + + + true + full + false + .\bin\Debug\ + DEBUG;TRACE + + + false + true + .\bin\Release\ + TRACE + + + en-US + + + + + + + + + + + + + + + + + + + + MyApp.xaml + Code + + + Window1.xaml + Code + + + + + + + + ResXFileCodeGenerator + Resources.cs + + + True + Resources.resx + + + SettingsSingleFileGenerator + Settings.cs + + + True + Settings.settings + + + + + + \ No newline at end of file diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample.csproj.user b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample.csproj.user new file mode 100644 index 0000000..6481ba3 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample.csproj.user @@ -0,0 +1,5 @@ + + + 8.0.50215 + + \ No newline at end of file diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample.sln b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample.sln new file mode 100644 index 0000000..dad2e86 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample.sln @@ -0,0 +1,20 @@ + +Microsoft Visual Studio Solution File, Format Version 9.00 +# Visual Studio 2005 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DisplayMemberPathSample", "DisplayMemberPathSample\DisplayMemberPathSample.csproj", "{2B163AD0-ADD4-4019-AE95-8380CFE36E71}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {2B163AD0-ADD4-4019-AE95-8380CFE36E71}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {2B163AD0-ADD4-4019-AE95-8380CFE36E71}.Debug|Any CPU.Build.0 = Debug|Any CPU + {2B163AD0-ADD4-4019-AE95-8380CFE36E71}.Release|Any CPU.ActiveCfg = Release|Any CPU + {2B163AD0-ADD4-4019-AE95-8380CFE36E71}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample.suo b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample.suo new file mode 100644 index 0000000..81effec Binary files /dev/null and b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample.suo differ diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample.csproj b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample.csproj new file mode 100644 index 0000000..d046469 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample.csproj @@ -0,0 +1,80 @@ + + + Debug + AnyCPU + {2B163AD0-ADD4-4019-AE95-8380CFE36E71} + DisplayMemberPathSample + DisplayMemberPathSample + 4 + winexe + 1.0.0.* + + 8.0.50215 + 2.0 + + + true + full + false + .\bin\Debug\ + DEBUG;TRACE + + + false + true + .\bin\Release\ + TRACE + + + + + + + + + + + + + + + + + + + + + + MyApp.xaml + Code + + + Window1.xaml + Code + + + + + + + + ResXFileCodeGenerator + Resources.cs + + + True + Resources.resx + + + SettingsSingleFileGenerator + Settings.cs + + + True + Settings.settings + + + + + + \ No newline at end of file diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample.csproj.user b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample.csproj.user new file mode 100644 index 0000000..6481ba3 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample.csproj.user @@ -0,0 +1,5 @@ + + + 8.0.50215 + + \ No newline at end of file diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/GreekGod.cs b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/GreekGod.cs new file mode 100644 index 0000000..8d7cc29 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/GreekGod.cs @@ -0,0 +1,40 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace DisplayMemberPathSample +{ + public class GreekGod + { + private string name; + + public string Name + { + get { return name; } + set { name = value; } + } + + private string description; + + public string Description + { + get { return description; } + set { description = value; } + } + + private string romanName; + + public string RomanName + { + get { return romanName; } + set { romanName = value; } + } + + public GreekGod(string name, string description, string romanName) + { + this.name = name; + this.description = description; + this.romanName = romanName; + } + } +} diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/GreekGods.cs b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/GreekGods.cs new file mode 100644 index 0000000..b958efe --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/GreekGods.cs @@ -0,0 +1,27 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Windows.Data; +using System.Collections.ObjectModel; + +namespace DisplayMemberPathSample +{ + public class GreekGods : ObservableCollection + { + public GreekGods() + { + this.Add(new GreekGod("Aphrodite", "Goddess of love, beauty and fertility", "Venus")); + this.Add(new GreekGod("Apollo", "God of prophesy, music and healing", "Apollo")); + this.Add(new GreekGod("Ares", "God of war", "Mars")); + this.Add(new GreekGod("Artemis", "Virgin goddess of the hunt", "Diana")); + this.Add(new GreekGod("Athena", "Goddess of crafts and the domestic arts", "Athena")); + this.Add(new GreekGod("Demeter", "Goddess of agriculture", "Ceres")); + this.Add(new GreekGod("Dionysus", "God of wine", "Bacchus")); + this.Add(new GreekGod("Hephaestus", "God of fire and crafts", "Vulcan")); + this.Add(new GreekGod("Hera", "Goddess of marriage", "Juno")); + this.Add(new GreekGod("Hermes", "Messenger of the Gods", "Mercury")); + this.Add(new GreekGod("Poseidon", "God of the sea, earthquakes and horses", "Neptune")); + this.Add(new GreekGod("Zeus", "Supreme God of the Olympians", "Jupiter")); + } + } +} diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/MyApp.xaml b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/MyApp.xaml new file mode 100644 index 0000000..472a815 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/MyApp.xaml @@ -0,0 +1,9 @@ + + + + + diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/MyApp.xaml.cs b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/MyApp.xaml.cs new file mode 100644 index 0000000..4c8ab52 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/MyApp.xaml.cs @@ -0,0 +1,23 @@ +using System; +using System.Windows; +using System.Data; +using System.Xml; +using System.Configuration; + +namespace DisplayMemberPathSample +{ + /// + /// Interaction logic for MyApp.xaml + /// + + public partial class MyApp : Application + { + + void AppStartup(object sender, StartupEventArgs args) + { + Window1 mainWindow = new Window1(); + mainWindow.Show(); + } + + } +} \ No newline at end of file diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Properties/AssemblyInfo.cs b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..3a21178 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Properties/AssemblyInfo.cs @@ -0,0 +1,54 @@ +#region Using directives + +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Resources; +using System.Globalization; +using System.Windows; +using System.Runtime.InteropServices; + +#endregion + +// 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("DisplayMemberPathSample")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("DisplayMemberPathSample")] +[assembly: AssemblyCopyright("Copyright @ 2005")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] +[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( + DictionaryLocation.None, //where theme specific resource dictionaries are located + //(used if a resource is not found in the page, + // or application resource dictionaries) + DictionaryLocation.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 Revision and Build Numbers +// by using the '*' as shown below: +[assembly: AssemblyVersion("1.0.*")] diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Resources.cs b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Resources.cs new file mode 100644 index 0000000..bf060fb --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Resources.cs @@ -0,0 +1,70 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:2.0.50215.44 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace DisplayMemberPathSample.Properties +{ + using System; + using System.IO; + using System.Resources; + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the Strongly Typed Resource Builder + // class via a tool like ResGen or Visual Studio.NET. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + class Resources + { + + private static System.Resources.ResourceManager _resMgr; + + private static System.Globalization.CultureInfo _resCulture; + + /*FamANDAssem*/ + internal Resources() + { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)] + public static System.Resources.ResourceManager ResourceManager + { + get + { + if ((_resMgr == null)) + { + System.Resources.ResourceManager temp = new System.Resources.ResourceManager("Resources", typeof(Resources).Assembly); + _resMgr = temp; + } + return _resMgr; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)] + public static System.Globalization.CultureInfo Culture + { + get + { + return _resCulture; + } + set + { + _resCulture = value; + } + } + } +} diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Resources.resx b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Resources.resx new file mode 100644 index 0000000..3e18af9 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Resources.resx @@ -0,0 +1,117 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Settings.cs b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Settings.cs new file mode 100644 index 0000000..5256a0f --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Settings.cs @@ -0,0 +1,42 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:2.0.50215.44 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace DisplayMemberPathSample.Properties +{ + public partial class Settings : System.Configuration.ApplicationSettingsBase + { + private static Settings m_Value; + + private static object m_SyncObject = new object(); + + public static Settings Value + { + get + { + if ((Settings.m_Value == null)) + { + System.Threading.Monitor.Enter(Settings.m_SyncObject); + if ((Settings.m_Value == null)) + { + try + { + Settings.m_Value = new Settings(); + } + finally + { + System.Threading.Monitor.Exit(Settings.m_SyncObject); + } + } + } + return Settings.m_Value; + } + } + } +} diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Settings.settings b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Settings.settings new file mode 100644 index 0000000..4024694 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Window1.xaml b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Window1.xaml new file mode 100644 index 0000000..3a4139b --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Window1.xaml @@ -0,0 +1,25 @@ + + + + + + + + + + + + + + + + + diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Window1.xaml.cs b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Window1.xaml.cs new file mode 100644 index 0000000..c296272 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Window1.xaml.cs @@ -0,0 +1,19 @@ +using System; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Data; +using System.Windows.Documents; +using System.Windows.Media; +using System.Windows.Shapes; + + +namespace DisplayMemberPathSample +{ + public partial class Window1 : Window + { + public Window1() + { + InitializeComponent(); + } + } +} \ No newline at end of file diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/GreekGod.cs b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/GreekGod.cs new file mode 100644 index 0000000..8d7cc29 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/GreekGod.cs @@ -0,0 +1,40 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace DisplayMemberPathSample +{ + public class GreekGod + { + private string name; + + public string Name + { + get { return name; } + set { name = value; } + } + + private string description; + + public string Description + { + get { return description; } + set { description = value; } + } + + private string romanName; + + public string RomanName + { + get { return romanName; } + set { romanName = value; } + } + + public GreekGod(string name, string description, string romanName) + { + this.name = name; + this.description = description; + this.romanName = romanName; + } + } +} diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/GreekGods.cs b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/GreekGods.cs new file mode 100644 index 0000000..b958efe --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/GreekGods.cs @@ -0,0 +1,27 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Windows.Data; +using System.Collections.ObjectModel; + +namespace DisplayMemberPathSample +{ + public class GreekGods : ObservableCollection + { + public GreekGods() + { + this.Add(new GreekGod("Aphrodite", "Goddess of love, beauty and fertility", "Venus")); + this.Add(new GreekGod("Apollo", "God of prophesy, music and healing", "Apollo")); + this.Add(new GreekGod("Ares", "God of war", "Mars")); + this.Add(new GreekGod("Artemis", "Virgin goddess of the hunt", "Diana")); + this.Add(new GreekGod("Athena", "Goddess of crafts and the domestic arts", "Athena")); + this.Add(new GreekGod("Demeter", "Goddess of agriculture", "Ceres")); + this.Add(new GreekGod("Dionysus", "God of wine", "Bacchus")); + this.Add(new GreekGod("Hephaestus", "God of fire and crafts", "Vulcan")); + this.Add(new GreekGod("Hera", "Goddess of marriage", "Juno")); + this.Add(new GreekGod("Hermes", "Messenger of the Gods", "Mercury")); + this.Add(new GreekGod("Poseidon", "God of the sea, earthquakes and horses", "Neptune")); + this.Add(new GreekGod("Zeus", "Supreme God of the Olympians", "Jupiter")); + } + } +} diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/MyApp.xaml b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/MyApp.xaml new file mode 100644 index 0000000..9b16c39 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/MyApp.xaml @@ -0,0 +1,8 @@ + + + + + diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/MyApp.xaml.cs b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/MyApp.xaml.cs new file mode 100644 index 0000000..e0cbbf3 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/MyApp.xaml.cs @@ -0,0 +1,21 @@ +using System; +using System.Windows; +using System.Data; +using System.Xml; +using System.Configuration; + +namespace DisplayMemberPathSample +{ + /// + /// Interaction logic for MyApp.xaml + /// + + public partial class MyApp : Application + { + protected override void OnStartup(StartupEventArgs e) + { + Window1 mainWindow = new Window1(); + mainWindow.Show(); + } + } +} \ No newline at end of file diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Properties/AssemblyInfo.cs b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..c0a24bf --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +#region Using directives + +using System.Reflection; +using System.Runtime.CompilerServices; + +#endregion + +// 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("DisplayMemberPathSample")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("DisplayMemberPathSample")] +[assembly: AssemblyCopyright("Copyright @ 2005")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +//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", UltimateFallbackResourceLocation.Satellite)] + + +// 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 Revision and Build Numbers +// by using the '*' as shown below: +[assembly: AssemblyVersion("1.0.*")] diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Resources.cs b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Resources.cs new file mode 100644 index 0000000..bf060fb --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Resources.cs @@ -0,0 +1,70 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:2.0.50215.44 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace DisplayMemberPathSample.Properties +{ + using System; + using System.IO; + using System.Resources; + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the Strongly Typed Resource Builder + // class via a tool like ResGen or Visual Studio.NET. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + class Resources + { + + private static System.Resources.ResourceManager _resMgr; + + private static System.Globalization.CultureInfo _resCulture; + + /*FamANDAssem*/ + internal Resources() + { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)] + public static System.Resources.ResourceManager ResourceManager + { + get + { + if ((_resMgr == null)) + { + System.Resources.ResourceManager temp = new System.Resources.ResourceManager("Resources", typeof(Resources).Assembly); + _resMgr = temp; + } + return _resMgr; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)] + public static System.Globalization.CultureInfo Culture + { + get + { + return _resCulture; + } + set + { + _resCulture = value; + } + } + } +} diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Resources.resx b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Resources.resx new file mode 100644 index 0000000..3e18af9 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Resources.resx @@ -0,0 +1,117 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Settings.cs b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Settings.cs new file mode 100644 index 0000000..5256a0f --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Settings.cs @@ -0,0 +1,42 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:2.0.50215.44 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace DisplayMemberPathSample.Properties +{ + public partial class Settings : System.Configuration.ApplicationSettingsBase + { + private static Settings m_Value; + + private static object m_SyncObject = new object(); + + public static Settings Value + { + get + { + if ((Settings.m_Value == null)) + { + System.Threading.Monitor.Enter(Settings.m_SyncObject); + if ((Settings.m_Value == null)) + { + try + { + Settings.m_Value = new Settings(); + } + finally + { + System.Threading.Monitor.Exit(Settings.m_SyncObject); + } + } + } + return Settings.m_Value; + } + } + } +} diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Settings.settings b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Settings.settings new file mode 100644 index 0000000..4024694 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Window1.xaml b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Window1.xaml new file mode 100644 index 0000000..a5308b4 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Window1.xaml @@ -0,0 +1,18 @@ + + + + + + + + + + + + diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Window1.xaml.cs b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Window1.xaml.cs new file mode 100644 index 0000000..e46a2e7 --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Window1.xaml.cs @@ -0,0 +1,30 @@ +using System; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Data; +using System.Windows.Documents; +using System.Windows.Media; +using System.Windows.Shapes; + + +namespace DisplayMemberPathSample +{ + /// + /// Interaction logic for Window1.xaml + /// + + public partial class Window1 : Window + { + public Window1() + { + InitializeComponent(); + } + + // To use Loaded event put Loaded="WindowLoaded" attribute in root element of .xaml file. + // private void WindowLoaded(object sender, EventArgs e) {} + + // Sample event handler: + // private void ButtonClick(object sender, RoutedEventArgs e) {} + + } +} \ No newline at end of file diff --git a/05-DisplayMemberPath/DisplayMemberPathSample/Visual Studio 2005/settings/currentsettings.vssettings b/05-DisplayMemberPath/DisplayMemberPathSample/Visual Studio 2005/settings/currentsettings.vssettings new file mode 100644 index 0000000..aea1bef --- /dev/null +++ b/05-DisplayMemberPath/DisplayMemberPathSample/Visual Studio 2005/settings/currentsettings.vssettings @@ -0,0 +1,1759 @@ + + + + 1 + 1 + + + 0 + 2000 + 1 + 0 + 1 + 0 + + 1 + 1 + 1000 + 1000 + 7799040 + 1 + 0 + 1 + 1500 + Function: $FUNCTION, Thread: $TID $TNAME + 1 + 67577 + 0 + 2 + 1 + 1 + 1 + 1 + 1 + 0 + 1 + 1 + 0 + 1 + 0 + 0 + 10000 + 1 + 0 + 1 + 1000 + 10000 + 0 + 1 + 0 + 0 + 0 + 5000 + 0 + 0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 0 + + 15000 + 2000 + 1 + 5000 + + 10000 + 0 + 0 + 1 + 0 + 0 + 0 + 0 + 0 + 0 + + 0 + 0 + 1 + 1 + + + + 1 + 1 + 1 + 1 + 0 + 0 + 1 + 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + true + true + false + + + false + false + false + true + true + true + true + true + false + false + false + true + false + true + true + true + true + false + true + false + false + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + true + + + dll>1>{CFF630F8-2DB3-44BA-9FC9-6489665DE5B8}>NoGuid + 1 + 0 + + + {00000000-0000-0000-0000-000000000000} + 0 + 1 + + + + + + + 0 + %VSSPV_VS_INSTALL_DIRECTORY%\Common7\Tools\guidgen.exe + %VSSPV_VS_INSTALL_DIRECTORY%\Common7\Tools\ + -1 + 14453 + {DA9FB551-C724-11d0-AE1F-00A0C90FFFC3} + 0 + -1 + Create GUID + 0 + 0 + 0 + + 0 + %VSSPV_VS_INSTALL_DIRECTORY%\Application\PreEmptive Solutions\Dotfuscator Community Edition\Dotfuscator.exe + $(TargetDir) + 0 + 0 + -1 + Dot&fuscator Community Edition + 0 + -1 + 0 + Create &GUID, Dot&fuscator Community Edition + + + false + true + false + {B1BA9461-FC54-45B3-A484-CB6DD0B95C94} + 2 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 2 + + + + + Ctrl+W + Ctrl+D + F6 + Shift+Alt+C + Ctrl+Shift+W + Ctrl+/ + Ctrl+W, S + Ctrl+W, Ctrl+S + Ctrl+W, P + Ctrl+W, Ctrl+P + Ctrl+W, J + Ctrl+W, Ctrl+J + Ctrl+W, X + Ctrl+W, Ctrl+X + Ctrl+R, Ctrl+M + Ctrl+R, Ctrl+F + Ctrl+R, Ctrl+I + Ctrl+R, Ctrl+O + Ctrl+R, Ctrl+V + Ctrl+R, Ctrl+R + F2 + Ctrl+R, Ctrl+P + Ctrl+K, Ctrl+S + Ctrl+K, Ctrl+X + F6 + Ctrl+D, B + Ctrl+D, Ctrl+B + Ctrl+D, W + Ctrl+D, Ctrl+W + Ctrl+D, A + Ctrl+D, Ctrl+A + Ctrl+D, L + Ctrl+D, Ctrl+L + Ctrl+D, I + Ctrl+D, Ctrl+I + Ctrl+D, C + Ctrl+D, Ctrl+C + Ctrl+D, T + Ctrl+D, Ctrl+T + Ctrl+D, M + Ctrl+D, Ctrl+M + Ctrl+D, P + Ctrl+D, Ctrl+P + Ctrl+D, Y + Ctrl+D, Ctrl+Y + Ctrl+D, D + Ctrl+D, Ctrl+D + Ctrl+D, R + Ctrl+D, Ctrl+R + Ctrl+D, O + Ctrl+D, Ctrl+O + Ctrl+D, E + Ctrl+D, Ctrl+E + Ctrl+D, Q + Ctrl+D, Ctrl+Q + Ctrl+D, N + Ctrl+D, Ctrl+N + Ctrl+F1, H + Ctrl+F1, Ctrl+H + Ctrl+W, C + Ctrl+W, Ctrl+C + Ctrl+W, L + Ctrl+W, Ctrl+L + Ctrl+W, R + Ctrl+W, Ctrl+R + Ctrl+W, U + Ctrl+W, Ctrl+U + Ctrl+W, T + Ctrl+W, E + Ctrl+W, M + Ctrl+W, Ctrl+M + Ctrl+W, O + Ctrl+W, Ctrl+O + Ctrl+W, D + Ctrl+W, Ctrl+D + Ctrl+W, Q + Ctrl+W, Ctrl+Q + Ctrl+B, E + Ctrl+B, Ctrl+E + Ctrl+W, B + Ctrl+W, Ctrl+B + Ctrl+F1, D + Ctrl+F1, Ctrl+D + Ctrl+W, W + Ctrl+W, Ctrl+W + Ctrl+F1, C + Ctrl+F1, Ctrl+C + Ctrl+F1, I + Ctrl+F1, Ctrl+I + Ctrl+F1, S + Ctrl+F1, Ctrl+S + Ctrl+F1, R + Ctrl+F1, Ctrl+R + Ctrl+F1, T + Ctrl+F1, Ctrl+T + Ctrl+F1, F + Ctrl+F1, Ctrl+F + Ctrl+K, M + Ctrl+K, Ctrl+M + Ctrl+K, Ctrl+R + Shift+F12 + Ctrl+E, A + Ctrl+E, Ctrl+A + Ctrl+E, \ + Ctrl+E, Ctrl+\ + Ctrl+B, C + Ctrl+B, Ctrl+C + Ctrl+B, T + Ctrl+B, Ctrl+T + Ctrl+B, N + Ctrl+B, Ctrl+N + Ctrl+B, P + Ctrl+B, Ctrl+P + Ctrl+K, P + Ctrl+K, Ctrl+P + Ctrl+E, S + Ctrl+E, Ctrl+S + Ctrl+K, W + Ctrl+K, Ctrl+W + Ctrl+K, L + Ctrl+K, Ctrl+L + Ctrl+E, F + Ctrl+E, Ctrl+F + Ctrl+E, T + Ctrl+E, Ctrl+T + Ctrl+K, I + Ctrl+E, W + Ctrl+M, M + Ctrl+M, L + Ctrl+M, P + Ctrl+M, O + Ctrl+E, C + Ctrl+E, Ctrl+C + Ctrl+E, U + Ctrl+E, Ctrl+U + Ctrl+E, D + Ctrl+E, Ctrl+D + Ctrl+W, G + Ctrl+F1 + Ctrl+W, Ctrl+G + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + false + -1 + VC# + + + VC# + false + false + false + true + true + true + true + true + {A5A527EA-CF0A-4ABF-B501-EAFE6B3BA5C6} + false + false + false + true + false + true + true + false + false + true + false + false + false + + + false + + + 0 + 1 + + + false + false + false + + + + + + + + + {F3192B88-EA73-480f-9471-04524118D767} + {F3192B88-EA73-480f-9471-04524118D767} + {F3192B88-EA73-480f-9471-04524118D767} + {F3192B88-EA73-480f-9471-04524118D767} + {F3192B88-EA73-480f-9471-04524118D767} + {F3192B88-EA73-480f-9471-04524118D767} + 20480 + 20481 + 20482 + 20483 + 20484 + 20485 + {00000000-0000-0000-0000-000000000000} + 0 + {00000000-0000-0000-0000-000000000000} + 0 + http://msdn.microsoft.com/vcsharp/rss.xml + + + {00000000-0000-0000-0000-000000000000} + 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + 0 + 0 + false + 0 + 1 + + + 0 + MatchCase=0 WholeWord=0 Hidden=1 Up=0 Selection=0 Block=0 KeepCase=0 SubFolders=0 KeepOpen=0 NameOnly=0 MarkAll=0 Plain Document Find + MatchCase=0 WholeWord=0 Hidden=0 Up=0 Selection=0 Block=0 KeepCase=0 SubFolders=1 KeepOpen=0 NameOnly=0 MarkAll=0 Plain Files Find + 1 + 0 + 1 + 0 + MatchCase=0 WholeWord=0 Hidden=0 Up=0 Selection=0 Block=0 KeepCase=0 SubFolders=1 KeepOpen=0 NameOnly=0 MarkAll=0 Plain Files Find + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + Regex + + 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3060434244 + + + + + + + ms-help://MS.VSCC.v80 + Visual C# + + + CSHowDoI80 + http://go.microsoft.com/fwlink/?LinkId=33452 + true + 9 + CSharp + true + true + false + false + false + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 64 + 3 + 0 + 0 + 64 + + + %VSSPV_LOCAL_APPLICATIONDATA%\VSEqtDeploymentRoot + True + True + True + + + + True + 8, 8 + (Default) + SnapLines + True + True + True + + + None + True + True + True + True + True + True + True + True + True + %VsInstallDir%\xml\Schemas + + + #4611 + {FAE04EC1-301F-11D3-BF4B-00C04F79EFBC} + + + #4610 + {FAE04EC1-301F-11D3-BF4B-00C04F79EFBC} + + + + + true + false + true + true + true + true + true + true + 0 + false + false + false + + + 7 + true + false + true + 10 + true + 10 + + + %vsspv_settings_directory%\CurrentSettings.vssettings + + false + + + true + 1 + 1 + 0 + 4 + 4 + false + %vsspv_visualstudio_dir%\templates\itemtemplates + %vsspv_visualstudio_dir%\templates\projecttemplates + %vsspv_visualstudio_dir%\projects + true + true + true + 0 + true + 0 + + + 5 + http://go.microsoft.com/fwlink/?linkid=35587&clcid=0x409 + true + 60 + + + + TODO:2 + UNDONE:2 + HACK:2 + UnresolvedMergeConflict:3 + + true + true + true + + + http://go.microsoft.com/fwlink/?LinkId=36568&clcid=%VSSPV_LCID_HEX% + http://search.microsoft.com/search/search.aspx?view=msdn/ + true + true + %systemroot%\system32\notepad.exe + 1 + + + + + 0 + 1 + 0 + + + Win32|$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(VCInstallDir)PlatformSDK\include;$(VCInstallDir)PlatformSDK\common\include;$(FrameworkSDKDir)include;$(FrameworkDir)$(FrameworkVersion);$(VCInstallDir)atlmfc\lib|Pocket PC 2003 (ARMV4)|$(VCInstallDir)ce\include;$(VSInstallDir)SmartDevices\SDK\PocketPC2003\include;$(VCInstallDir)ce\atlmfc\include;$(VSInstallDir)SmartDevices\SDK\SQL Server\Mobile\v3.0;;|Smartphone 2003 (ARMV4)|$(VCInstallDir)ce\include;$(VSInstallDir)SmartDevices\SDK\SmartPhone2003\include;$(VCInstallDir)ce\atlmfc\include;$(VSInstallDir)SmartDevices\SDK\SQL Server\Mobile\v3.0;; + Win32|$(VCInstallDir)bin;$(VCInstallDir)PlatformSDK\bin;$(VCInstallDir)PlatformSDK\common\bin;$(VSInstallDir)Common7\Tools\bin;$(VSInstallDir)Common7\tools;$(VSInstallDir)Common7\ide;$(ProgramFiles)\HTML Help Workshop;$(FrameworkSDKDir)bin;$(FrameworkDir)$(FrameworkVersion);$(VSInstallDir);$(SystemRoot)\SysWow64;$(FxCopDir);$(PATH)|Pocket PC 2003 (ARMV4)|$(VCInstallDir)ce\bin\x86_arm;$(VCInstallDir)bin;$(VSInstallDir)Common7\Tools;$(VSInstallDir)Common7\IDE;$(VSInstallDir)Common\Tools;$(VSInstallDir)Common\IDE;$(VSInstallDir);$(FrameworkSDKDir)Bin;$(PATH);|Smartphone 2003 (ARMV4)|$(VCInstallDir)ce\bin\x86_arm;$(VCInstallDir)bin;$(VSInstallDir)Common7\Tools;$(VSInstallDir)Common7\IDE;$(VSInstallDir)Common\Tools;$(VSInstallDir)Common\IDE;$(VSInstallDir);$(FrameworkSDKDir)Bin;$(PATH); + Win32|$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(VCInstallDir)PlatformSDK\include;$(VCInstallDir)PlatformSDK\common\include;$(FrameworkSDKDir)include|Pocket PC 2003 (ARMV4)|$(VCInstallDir)ce\include;$(VSInstallDir)SmartDevices\SDK\PocketPC2003\include;$(VCInstallDir)ce\atlmfc\include;$(VSInstallDir)SmartDevices\SDK\SQL Server\Mobile\v3.0;|Smartphone 2003 (ARMV4)|$(VCInstallDir)ce\include;$(VSInstallDir)SmartDevices\SDK\SmartPhone2003\include;$(VCInstallDir)ce\atlmfc\include;$(VSInstallDir)SmartDevices\SDK\SQL Server\Mobile\v3.0; + Win32|$(VCInstallDir)lib;$(VCInstallDir)atlmfc\lib;$(VCInstallDir)atlmfc\lib\i386;$(VCInstallDir)PlatformSDK\lib;$(VCInstallDir)PlatformSDK\common\lib;$(FrameworkSDKDir)lib;$(VSInstallDir);$(VSInstallDir)lib|Pocket PC 2003 (ARMV4)|$(VSInstallDir)SmartDevices\SDK\PocketPC2003\lib\ARMV4;$(VCInstallDir)ce\atlmfc\lib\ARMV4;$(VCInstallDir)ce\lib\ARMV4;|Smartphone 2003 (ARMV4)|$(VSInstallDir)SmartDevices\SDK\SmartPhone2003\lib\ARMV4;$(VCInstallDir)ce\atlmfc\lib\ARMV4;$(VCInstallDir)ce\lib\ARMV4; + Win32|$(FrameworkDir)$(FrameworkVersion);$(VCInstallDir)atlmfc\lib|Pocket PC 2003 (ARMV4)||Smartphone 2003 (ARMV4)| + Win32|$(VCInstallDir)atlmfc\src\mfc;$(VCInstallDir)atlmfc\src\atl;$(VCInstallDir)crt\src|Pocket PC 2003 (ARMV4)|$(VCInstallDir)ce\atlmfc\src\atl\;$(VCInstallDir)ce\atlmfc\src\mfc\;$(VCInstallDir)ce\crt\src\|Smartphone 2003 (ARMV4)|$(VCInstallDir)ce\atlmfc\src\atl\;$(VCInstallDir)ce\atlmfc\src\mfc\;$(VCInstallDir)ce\crt\src\ + + + true + false + *.cpp;*.cxx;*.cc;*.c + 0 + .suo;.sln;.ncb;.vcproj;.csproj;.user;.vbproj;.scc;.vsscc;.vspscc;.old + .cpp;.cxx;.cc;.c;.inl;.h;.hpp;.hxx;.hm;.inc;.rc;.resx;.idl;.rc2;.def;.odl;.asm;.asmx;.xsd;.bin;.rgs;.html;.htm;.manifest + false + true + true + + true + + + + + + true + true + true + true + false + 4 + 2 + false + false + false + 4 + false + false + true + + + true + true + true + true + true + true + + + true + true + true + true + true + 4 + 2 + true + false + true + 4 + false + false + true + + + true + false + true + true + true + false + + + true + true + true + true + true + 4 + 2 + true + false + false + 4 + false + false + true + + + 1 + 1 + 1 + 1 + 2 + + + true + true + true + true + true + 4 + 2 + false + false + true + 4 + false + false + true + + + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 80 + 1 + 1 + 1 + 1 + 0 + 1 + 1 + {}[]().,:;+-*/%&|^!~=<>?@#'"\ + 0 + 1 + 1 + 1 + 1 + 0 + 0 + 0 + 1 + 0 + 1 + 1 + 4096 + 1 + 1 + 1 + 1 + 0 + 1 + 1 + 1 + 1 + 1 + 0 + 1 + 1 + 0 + 1 + 10 + 0 + 1 + 0 + 1 + 1 + 1 + 1 + 1 + 1 + 0 + 1 + 1 + 2 + 1 + 1 + 0 + 1 + 1 + 1 + 0 + 0 + 1 + 0 + 1 + 1 + 0 + 1 + 1 + 1 + 1 + 0 + 1 + 0 + 0 + 0 + 1 + 1 + 1 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 1 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 1 + 1 + 1 + 5 + 16 + 1 + 1 + 0 + 0 + 0 + 1 + 1 + + + + true + true + true + 0 + false + true + true + true + true + false + true + + + true + true + true + true + true + 4 + 1 + false + false + true + 4 + false + false + true + + + 0 + 1 + 1 + 0 + 0 + 1 + 2 + 2 + 0 + 0 + 8 + 1 + 1 + 0 + 0 + 3 + 3 + 1 + 0 + 1 + 1 + 0 + 2 + 0 + Internet Explorer 6.0 + 8 + 1 + 80 + + + true + true + true + true + true + 4 + 1 + true + false + false + 4 + false + false + true + + + true + true + true + true + true + 4 + 1 + true + false + false + 4 + false + false + true + + + true + true + true + true + true + 4 + 1 + true + false + false + 4 + false + false + true + + + true + true + true + true + true + 4 + 1 + true + false + false + 4 + false + false + true + + + true + true + true + true + true + 4 + 1 + true + false + false + 4 + false + false + true + + + true + true + true + true + true + 4 + 1 + true + false + false + 4 + false + false + true + + + 1 + 1 + 1 + 1 + 1 + 1 + {}[]().,:;+-*/%&|^!~=<>?@#'"\ + 1 + 1 + 1 + 1 + 1 + + + 1 + 1 + 1 + 0 + 80 + 1 + 1 + 1 + 1 + 0 + 0 + 0 + 0 + 0 + 0 + 1 + 0 + 1 + 1 + 1 + 1 + 1 + 1 + 4096 + 0 + 1 + 1 + 0 + 1 + 1 + 1 + 0 + 1 + 0 + 1 + 1 + 0 + 0 + + + 1 + 0 + 1 + 1 + 0 + 1 + 1 + 0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 0 + 1 + 0 + 0 + 0 + 1 + 1 + 1 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 1 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 1 + 1 + + + 1 + 1 + 1 + 1 + 1 + 0 + 0 + 1 + 0 + 1 + 1 + 5 + 16 + 0 + + + true + true + true + true + true + 4 + 2 + true + false + true + 4 + false + false + true + + + true + true + true + true + true + 4 + 2 + true + false + false + 4 + false + false + true + + + + diff --git a/05-DisplayMemberPath/Images/DisplayMemberPathSample.png b/05-DisplayMemberPath/Images/DisplayMemberPathSample.png new file mode 100644 index 0000000..a62b95b Binary files /dev/null and b/05-DisplayMemberPath/Images/DisplayMemberPathSample.png differ diff --git a/05-DisplayMemberPath/README.md b/05-DisplayMemberPath/README.md new file mode 100644 index 0000000..7b5851e --- /dev/null +++ b/05-DisplayMemberPath/README.md @@ -0,0 +1,21 @@ +# New feature in September PDC: DisplayMemberPath + +As I've shown in previous posts, binding an ItemsControl to an IEnumerable data source is really easy (remember that ListBox and ComboBox derive from ItemsControl). With the introduction of DisplayMemberPath in September PDC, it became even easier for the scenario where you want to display only one property of each data item as text. Before DisplayMemberPath, this scenario required the use of a DataTemplate that would specify the property we're interested in, like in the following xaml: + + + + + + + + + +The Data Binding team realized that this was a very common scenario and could be simplified, which was the motivation for introducing the DisplayMemberPath property in ItemsControl. The scenario above can now be done in a single line of xaml: + + + +It's that easy :) + +The image below shows both versions of the ItemsControl, the one on the left is using DataTemplate and the one on the right is using DisplayMemberPath. + +![](Images/DisplayMemberPathSample.png) diff --git a/05-DisplayMemberPath/visual studio 2005/settings/currentsettings.vssettings b/05-DisplayMemberPath/visual studio 2005/settings/currentsettings.vssettings new file mode 100644 index 0000000..a3757d3 --- /dev/null +++ b/05-DisplayMemberPath/visual studio 2005/settings/currentsettings.vssettings @@ -0,0 +1,395 @@ +falsefalsetruefalsetruetruefalsetruetruetruetrue0710truetruefalsetrue10false%vsspv_settings_directory%\currentsettings.vssettings%vsspv_visualstudio_dir%projectstruefalsefalse44true%vsspv_visualstudio_dir%templates\itemtemplatesfalsetrue10%vsspv_visualstudio_dir%templates\projecttemplatestrue1true5truehttp://go.microsoft.com/fwlink/?linkid=35587&clcid=0x40960trueTODO:2HACK:2UNDONE:2UnresolvedMergeConflict:3truetrue + http://go.microsoft.com/fwlink/?LinkId=36568&clcid=%VSSPV_LCID_HEX% + http://search.microsoft.com/search/search.aspx?view=msdn/ + true + true + %systemroot%\system32\notepad.exe + 1 + + 0 + 1 + 0 + + Win32|$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(VCInstallDir)PlatformSDK\include;$(VCInstallDir)PlatformSDK\common\include;$(FrameworkSDKDir)include;$(FrameworkDir)$(FrameworkVersion);$(VCInstallDir)atlmfc\lib|Pocket PC 2003 (ARMV4)|$(VCInstallDir)ce\include;$(VSInstallDir)SmartDevices\SDK\PocketPC2003\include;$(VCInstallDir)ce\atlmfc\include;$(VSInstallDir)SmartDevices\SDK\SQL Server\Mobile\v3.0;;|Smartphone 2003 (ARMV4)|$(VCInstallDir)ce\include;$(VSInstallDir)SmartDevices\SDK\SmartPhone2003\include;$(VCInstallDir)ce\atlmfc\include;$(VSInstallDir)SmartDevices\SDK\SQL Server\Mobile\v3.0;; + Win32|$(VCInstallDir)bin;$(VCInstallDir)PlatformSDK\bin;$(VCInstallDir)PlatformSDK\common\bin;$(VSInstallDir)Common7\Tools\bin;$(VSInstallDir)Common7\tools;$(VSInstallDir)Common7\ide;$(ProgramFiles)\HTML Help Workshop;$(FrameworkSDKDir)bin;$(FrameworkDir)$(FrameworkVersion);$(VSInstallDir);$(SystemRoot)\SysWow64;$(FxCopDir);$(PATH)|Pocket PC 2003 (ARMV4)|$(VCInstallDir)ce\bin\x86_arm;$(VCInstallDir)bin;$(VSInstallDir)Common7\Tools;$(VSInstallDir)Common7\IDE;$(VSInstallDir)Common\Tools;$(VSInstallDir)Common\IDE;$(VSInstallDir);$(FrameworkSDKDir)Bin;$(PATH);|Smartphone 2003 (ARMV4)|$(VCInstallDir)ce\bin\x86_arm;$(VCInstallDir)bin;$(VSInstallDir)Common7\Tools;$(VSInstallDir)Common7\IDE;$(VSInstallDir)Common\Tools;$(VSInstallDir)Common\IDE;$(VSInstallDir);$(FrameworkSDKDir)Bin;$(PATH); + Win32|$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(VCInstallDir)PlatformSDK\include;$(VCInstallDir)PlatformSDK\common\include;$(FrameworkSDKDir)include|Pocket PC 2003 (ARMV4)|$(VCInstallDir)ce\include;$(VSInstallDir)SmartDevices\SDK\PocketPC2003\include;$(VCInstallDir)ce\atlmfc\include;$(VSInstallDir)SmartDevices\SDK\SQL Server\Mobile\v3.0;|Smartphone 2003 (ARMV4)|$(VCInstallDir)ce\include;$(VSInstallDir)SmartDevices\SDK\SmartPhone2003\include;$(VCInstallDir)ce\atlmfc\include;$(VSInstallDir)SmartDevices\SDK\SQL Server\Mobile\v3.0; + Win32|$(VCInstallDir)lib;$(VCInstallDir)atlmfc\lib;$(VCInstallDir)atlmfc\lib\i386;$(VCInstallDir)PlatformSDK\lib;$(VCInstallDir)PlatformSDK\common\lib;$(FrameworkSDKDir)lib;$(VSInstallDir);$(VSInstallDir)lib|Pocket PC 2003 (ARMV4)|$(VSInstallDir)SmartDevices\SDK\PocketPC2003\lib\ARMV4;$(VCInstallDir)ce\atlmfc\lib\ARMV4;$(VCInstallDir)ce\lib\ARMV4;|Smartphone 2003 (ARMV4)|$(VSInstallDir)SmartDevices\SDK\SmartPhone2003\lib\ARMV4;$(VCInstallDir)ce\atlmfc\lib\ARMV4;$(VCInstallDir)ce\lib\ARMV4; + Win32|$(FrameworkDir)$(FrameworkVersion);$(VCInstallDir)atlmfc\lib|Pocket PC 2003 (ARMV4)||Smartphone 2003 (ARMV4)| + Win32|$(VCInstallDir)atlmfc\src\mfc;$(VCInstallDir)atlmfc\src\atl;$(VCInstallDir)crt\src|Pocket PC 2003 (ARMV4)|$(VCInstallDir)ce\atlmfc\src\atl\;$(VCInstallDir)ce\atlmfc\src\mfc\;$(VCInstallDir)ce\crt\src\|Smartphone 2003 (ARMV4)|$(VCInstallDir)ce\atlmfc\src\atl\;$(VCInstallDir)ce\atlmfc\src\mfc\;$(VCInstallDir)ce\crt\src\ + + true + false + *.cpp;*.cxx;*.cc;*.c + 0 + .suo;.sln;.ncb;.vcproj;.csproj;.user;.vbproj;.scc;.vsscc;.vspscc;.old + .cpp;.cxx;.cc;.c;.inl;.h;.hpp;.hxx;.hm;.inc;.rc;.resx;.idl;.rc2;.def;.odl;.asm;.asmx;.xsd;.bin;.rgs;.html;.htm;.manifest + false + true + true + + true + 4true2falsefalsefalsefalsetruetruefalsefalse4truetruetruetruetruetruetruetrue4true2truetruefalsetruetruetruefalsefalse4truetruetruefalsetruetruefalsetrue4true2truefalsefalsetruetruetruefalsefalse4truetrue211114true2truetruefalsefalsetruetruefalsefalse4truetrue + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 80 + 1 + 1 + 1 + 1 + 0 + 1 + 1 + {}[]().,:;+-*/%&|^!~=<>?@#'"\ + 0 + 1 + 1 + 1 + 1 + 0 + 0 + 0 + 1 + 0 + 1 + 1 + 4096 + 1 + 1 + 1 + 1 + 0 + 1 + 1 + 1 + 1 + 1 + 0 + 1 + 1 + 0 + 1 + 10 + 0 + 1 + 0 + 1 + 1 + 1 + 1 + 1 + 1 + 0 + 1 + 1 + 2 + 1 + 1 + 0 + 1 + 1 + 1 + 0 + 0 + 1 + 0 + 1 + 1 + 0 + 1 + 1 + 1 + 1 + 0 + 1 + 0 + 0 + 0 + 1 + 1 + 1 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 1 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 1 + 1 + 1 + 5 + 16 + 1 + 1 + 0 + 0 + 0 + 1 + 1 + truetrue0truetruefalsetruefalsetruetruetrue4true1truetruefalsefalsetruetruefalsefalse4truetrue002110180000101338811102Internet Explorer 6.01204true1truefalsefalsetruetruetruefalsefalse4truetrue4true1truefalsefalsetruetruetruefalsefalse4truetrue4true1truefalsefalsetruetruetruefalsefalse4truetrue4true1truefalsefalsetruetruetruefalsefalse4truetrue4true1truefalsefalsetruetruetruefalsefalse4truetrue4true1truefalsefalsetruetruetruefalsefalse4truetrue + 1 + 1 + 1 + 1 + 1 + 1 + {}[]().,:;+-*/%&|^!~=<>?@#'"\ + 1 + 1 + 1 + 1 + 1 + + 1 + 1 + 1 + 0 + 80 + 1 + 1 + 1 + 1 + 0 + 0 + 0 + 0 + 0 + 0 + 1 + 0 + 1 + 1 + 1 + 1 + 1 + 1 + 4096 + 0 + 1 + 1 + 0 + 1 + 1 + 1 + 0 + 1 + 0 + 1 + 1 + 0 + 0 + + 1 + 0 + 1 + 1 + 0 + 1 + 1 + 0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 0 + 1 + 0 + 0 + 0 + 1 + 1 + 1 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 1 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 1 + 1 + + 1 + 1 + 1 + 1 + 1 + 0 + 0 + 1 + 0 + 1 + 1 + 5 + 16 + 0 + 4true2truetruefalsetruetruetruefalsefalse4truetrue4true2truefalsefalsetruetruetruefalsefalse4truetrue011510110111111500111011{}[]().,:;+-*/%&|^!~=<>?@#'"\110111010111101010001811104096011110011101801011010111000001011010011111010011011011010110011000111100201151010111111500111011{}[]().,:;+-/%&|^!~=<>?@#'"\1101110101111010100081110409601111001118010110101110000010110100111110101011011001100110001111002 + 1 + 1 + 1110111101110001010111000011011110000016757777990400021110000500015000150010001000100020002000500010000100000001011111111100001100Function: $FUNCTION, Thread: $TID $TNAMEtruefalsetruetruetruetruefalsefalsefalsetruefalsefalsefalsefalsetruetruetruetruefalsetruetruefalsetruefalse + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + true + 01dll>1>{CFF630F8-2DB3-44BA-9FC9-6489665DE5B8}>NoGuid1truefalsetrue{00000000-0000-0000-0000-000000000000}%vsspv_vs_install_directory%\common7\tools\guidgen.exe%vsspv_vs_install_directory%\common7\tools\Create GUIDfalsefalsefalsetruetruefalsefalse{DA9FB551-C724-11D0-AE1F-00A0C90FFFC3}14453%vsspv_vs_install_directory%\application\preemptive solutions\dotfuscator community edition\dotfuscator.exe$(targetdir)Dot&fuscator Community Editiontruefalsefalsefalsetruefalsefalse{00000000-0000-0000-0000-000000000000}0Create &GUID, Dot&fuscator Community Editionfalsetruefalse2{B1BA9461-FC54-45B3-A484-CB6DD0B95C94}28.0.0.0Shift+Alt+CCtrl+Shift+WCtrl+/Ctrl+W, SCtrl+W, Ctrl+SCtrl+W, PCtrl+W, Ctrl+PCtrl+W, JCtrl+W, Ctrl+JCtrl+W, XCtrl+W, Ctrl+XCtrl+R, Ctrl+MCtrl+R, Ctrl+FCtrl+R, Ctrl+ICtrl+R, Ctrl+OCtrl+R, Ctrl+VCtrl+R, Ctrl+RF2Ctrl+R, Ctrl+PCtrl+K, Ctrl+SCtrl+K, Ctrl+XF6Ctrl+D, BCtrl+D, Ctrl+BCtrl+D, WCtrl+D, Ctrl+WCtrl+D, ACtrl+D, Ctrl+ACtrl+D, LCtrl+D, Ctrl+LCtrl+D, ICtrl+D, Ctrl+ICtrl+D, CCtrl+D, Ctrl+CCtrl+D, TCtrl+D, Ctrl+TCtrl+D, MCtrl+D, Ctrl+MCtrl+D, PCtrl+D, Ctrl+PCtrl+D, YCtrl+D, Ctrl+YCtrl+D, DCtrl+D, Ctrl+DCtrl+D, RCtrl+D, Ctrl+RCtrl+D, OCtrl+D, Ctrl+OCtrl+D, ECtrl+D, Ctrl+ECtrl+D, QCtrl+D, Ctrl+QCtrl+D, NCtrl+D, Ctrl+NCtrl+F1, HCtrl+F1, Ctrl+HCtrl+W, CCtrl+W, Ctrl+CCtrl+W, LCtrl+W, Ctrl+LCtrl+W, RCtrl+W, Ctrl+RCtrl+W, UCtrl+W, Ctrl+UCtrl+W, TCtrl+W, ECtrl+W, MCtrl+W, Ctrl+MCtrl+W, OCtrl+W, Ctrl+OCtrl+W, DCtrl+W, Ctrl+DCtrl+W, QCtrl+W, Ctrl+QCtrl+B, ECtrl+B, Ctrl+ECtrl+W, BCtrl+W, Ctrl+BCtrl+F1, DCtrl+F1, Ctrl+DCtrl+W, WCtrl+W, Ctrl+WCtrl+F1, CCtrl+F1, Ctrl+CCtrl+F1, ICtrl+F1, Ctrl+ICtrl+F1, SCtrl+F1, Ctrl+SCtrl+F1, RCtrl+F1, Ctrl+RCtrl+F1, TCtrl+F1, Ctrl+TCtrl+F1, FCtrl+F1, Ctrl+FCtrl+K, MCtrl+K, Ctrl+MCtrl+K, Ctrl+RShift+F12Ctrl+E, ACtrl+E, Ctrl+ACtrl+E, \Ctrl+E, Ctrl+\Ctrl+B, CCtrl+B, Ctrl+CCtrl+B, TCtrl+B, Ctrl+TCtrl+B, NCtrl+B, Ctrl+NCtrl+B, PCtrl+B, Ctrl+PCtrl+K, PCtrl+K, Ctrl+PCtrl+E, SCtrl+E, Ctrl+SCtrl+K, WCtrl+K, Ctrl+WCtrl+K, LCtrl+K, Ctrl+LCtrl+E, FCtrl+E, Ctrl+FCtrl+E, TCtrl+E, Ctrl+TCtrl+K, ICtrl+E, WCtrl+M, MCtrl+M, LCtrl+M, PCtrl+M, OCtrl+E, CCtrl+E, Ctrl+CCtrl+E, UCtrl+E, Ctrl+UCtrl+E, DCtrl+E, Ctrl+DCtrl+W, GCtrl+W, Ctrl+GCtrl+WCtrl+DF6Ctrl+F1trueVC#falsefalsefalsetruefalsefalsefalsetruefalsefalsefalsefalsetruetruetruetruefalsetruetruefalsetruefalse{A5A527EA-CF0A-4ABF-B501-EAFE6B3BA5C6}VC#false01falsefalsefalsehttp://go.microsoft.com/fwlink/?linkid=35587&clcid=0x409{00000000-0000-0000-0000-000000000000}0{00000000-0000-0000-0000-000000000000}0{F3192B88-EA73-480F-9471-04524118D767}20480{F3192B88-EA73-480F-9471-04524118D767}20481{F3192B88-EA73-480F-9471-04524118D767}20482{F3192B88-EA73-480F-9471-04524118D767}20483{F3192B88-EA73-480F-9471-04524118D767}20484{F3192B88-EA73-480F-9471-04524118D767}204851{00000000-0000-0000-0000-000000000000}false10000MatchCase=0 WholeWord=0 Hidden=0 Up=0 Selection=0 Block=0 KeepCase=0 SubFolders=1 KeepOpen=0 NameOnly=0 MarkAll=0 Plain Files FindMatchCase=0 WholeWord=0 Hidden=1 Up=0 Selection=0 Block=0 KeepCase=0 SubFolders=0 KeepOpen=0 NameOnly=0 MarkAll=0 Plain Document FindMatchCase=0 WholeWord=0 Hidden=0 Up=0 Selection=0 Block=0 KeepCase=0 SubFolders=1 KeepOpen=0 NameOnly=0 MarkAll=0 Plain Files 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 + + + + ms-help://MS.VSCC.v80 + Visual C# + + CSHowDoI80 + http://go.microsoft.com/fwlink/?LinkId=33452 + true + 9 + CSharp + true + true + false + false + false + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 64 + 3 + 0 + 0 + 64 + + %VSSPV_LOCAL_APPLICATIONDATA%\VSEqtDeploymentRoot + True + True + True + + True + 8, 8 + (Default) + SnapLines + True + True + True + NoneTrueTrueTrueTrueTrueTrueTrueTrueTrue%VsInstallDir%\xml\Schemas \ No newline at end of file