From 12e64152ff1d0271e9ce8c9d5e44a8659c8907b5 Mon Sep 17 00:00:00 2001 From: Beatriz Stollnitz Date: Mon, 5 Aug 2019 17:17:48 -0700 Subject: [PATCH] Added 5th post. --- .../DisplayMemberPathSample.csproj | 94 + .../DisplayMemberPathSample.csproj.user | 5 + .../DisplayMemberPathSample.sln | 20 + .../DisplayMemberPathSample.suo | Bin 0 -> 20992 bytes .../GreekGod.cs | 40 + .../GreekGods.cs | 27 + .../MyApp.xaml | 9 + .../MyApp.xaml.cs | 23 + .../Properties/AssemblyInfo.cs | 54 + .../Properties/Resources.Designer.cs | 63 + .../Properties/Resources.resx | 117 ++ .../Properties/Settings.Designer.cs | 26 + .../Properties/Settings.settings | 7 + .../Window1.xaml | 24 + .../Window1.xaml.cs | 19 + .../DisplayMemberPathSample.sln | 20 + .../DisplayMemberPathSample.suo | Bin 0 -> 16896 bytes .../DisplayMemberPathSample.csproj | 81 + .../DisplayMemberPathSample.csproj.user | 5 + .../DisplayMemberPathSample.sln | 20 + .../DisplayMemberPathSample.suo | Bin 0 -> 16384 bytes .../DisplayMemberPathSample.csproj | 80 + .../DisplayMemberPathSample.csproj.user | 5 + .../DisplayMemberPathSample/GreekGod.cs | 40 + .../DisplayMemberPathSample/GreekGods.cs | 27 + .../DisplayMemberPathSample/MyApp.xaml | 9 + .../DisplayMemberPathSample/MyApp.xaml.cs | 23 + .../Properties/AssemblyInfo.cs | 54 + .../Properties/Resources.cs | 70 + .../Properties/Resources.resx | 117 ++ .../Properties/Settings.cs | 42 + .../Properties/Settings.settings | 7 + .../DisplayMemberPathSample/Window1.xaml | 25 + .../DisplayMemberPathSample/Window1.xaml.cs | 19 + .../DisplayMemberPathSample/GreekGod.cs | 40 + .../DisplayMemberPathSample/GreekGods.cs | 27 + .../DisplayMemberPathSample/MyApp.xaml | 8 + .../DisplayMemberPathSample/MyApp.xaml.cs | 21 + .../Properties/AssemblyInfo.cs | 36 + .../Properties/Resources.cs | 70 + .../Properties/Resources.resx | 117 ++ .../Properties/Settings.cs | 42 + .../Properties/Settings.settings | 7 + .../DisplayMemberPathSample/Window1.xaml | 18 + .../DisplayMemberPathSample/Window1.xaml.cs | 30 + .../settings/currentsettings.vssettings | 1759 +++++++++++++++++ .../Images/DisplayMemberPathSample.png | Bin 0 -> 286866 bytes 05-DisplayMemberPath/README.md | 21 + .../settings/currentsettings.vssettings | 395 ++++ 49 files changed, 3763 insertions(+) create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/DisplayMemberPathSample.csproj create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/DisplayMemberPathSample.csproj.user create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/DisplayMemberPathSample.sln create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/DisplayMemberPathSample.suo create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/GreekGod.cs create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/GreekGods.cs create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/MyApp.xaml create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/MyApp.xaml.cs create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Properties/AssemblyInfo.cs create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Properties/Resources.Designer.cs create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Properties/Resources.resx create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Properties/Settings.Designer.cs create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Properties/Settings.settings create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Window1.xaml create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample - Orcas Beta 2/Window1.xaml.cs create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample.sln create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample.suo create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample.csproj create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample.csproj.user create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample.sln create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample.suo create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample.csproj create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample.csproj.user create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/GreekGod.cs create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/GreekGods.cs create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/MyApp.xaml create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/MyApp.xaml.cs create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Properties/AssemblyInfo.cs create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Resources.cs create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Resources.resx create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Settings.cs create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Settings.settings create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Window1.xaml create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/DisplayMemberPathSample/Window1.xaml.cs create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/GreekGod.cs create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/GreekGods.cs create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/MyApp.xaml create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/MyApp.xaml.cs create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Properties/AssemblyInfo.cs create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Resources.cs create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Resources.resx create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Settings.cs create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Properties/Settings.settings create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Window1.xaml create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/DisplayMemberPathSample/Window1.xaml.cs create mode 100644 05-DisplayMemberPath/DisplayMemberPathSample/Visual Studio 2005/settings/currentsettings.vssettings create mode 100644 05-DisplayMemberPath/Images/DisplayMemberPathSample.png create mode 100644 05-DisplayMemberPath/README.md create mode 100644 05-DisplayMemberPath/visual studio 2005/settings/currentsettings.vssettings 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 0000000000000000000000000000000000000000..39e8816026f703919d11da87ec540ecc2d9c3e0e GIT binary patch literal 20992 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 Lzhz + { + 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 0000000000000000000000000000000000000000..d8b5709aa3e2baa0b6ed17cd6f77b981fe0946ff GIT binary patch literal 16896 zcmeI3`*&1V701s6h)}DxP_Y(lM+AymQbI@wAhmf?ErFB(#dfp~lgVUY9x*e41gLFA zZL8Mz+xnXciJ$Me_hcTKxpOB8(Uk10@7#OO z-S_VE*n6LS_PP1ftGE8`g;}_XRvzJ8uyl(tEu09~W@l%;LSr~x zr4`fzuT$5x4Bk7zI-v1>6Ic&6fVY5~z?;F%;H}_o;8uVNm@Qx<*aU6^ZwH&fJHYMW z4j}#5>L1_5@lJ4;f4zdb>J3@d6DH4J(L~LF$#I-CGmK1l+Kkq?j*)%@(UZMf9^CQg z-$&NKbpLxj&S50x%{lWSq>phnV5Wm!G4I}HJdl&G<2;5s1=3y7NfS2(bKV>^X^us6 zir*x4a^(e&t?uu3(-M&_$Zo>Qmk*VFiB2Q$q#c8dIm>a{j9B>>s852kMzoFg%N|`H zG~(BN`E1#|NVe&qGWmdGe!24jvVX@Tf8cz8`cQ2zw}0`;{vE&kihO|lgnU4`{YSZe zH%Ni2U_00Wc7nUXE+92|A9z2w2e|j%%lRJA4n7S!z&_9ky1;(W4Gw^V;1GBixaS|^ z{C>~_dO;u1y#bDc;0SoYFZ(dZ2fb|I1C;FC%_0e3G|NB97n+!@DcC`cof9I zN5RLyv*6<(4$cBS_dSjp@iG5;oMRfC1Lr{oWI+z(!36jOm;}<(BA5afz(pWSk~Lof zm%$bAIQS%Z0z3(RTlmX=jvYLF^p|JiPrvk!l)9rSdaZ9mQ~cM1S^nf|r0-y?KcAS& zCUeC?G@cucjwFl4bS_nh^(N!R$@Hbz&`flWBi5VAr(zxb>B2-NJ~Nceo=r{;$BW~! zc_kz9>_jG6xBTIBZZvoYS z8>7~*6e&w{o#IXmy-%W}S@dcct^_(3=T6cbN3+D2hck@-Lv`mUOmj3|_sR)D{m45@ zjZ;?gBsLmHcEXHP-bl8dk1oLfxAL4~6;ZYPUaToe9nRASdD~a&#rm`h|F3vSK2e=e zpR;sF{D1H-tL1C{liv?J0y}B{THYmJ9ag?#Iq{3s+mp2O68bQNw}{rzA!$m6-blgI z$$ia~6O_c^AEK^VMo@F6w5Z6)Ne>(GjKG_PuY5EMygNfUqpJRSs<+b-3)JQ9s4iIpRszCr~W}C z{g+%vLA>ss=2~}N-F{D>^R#>hU*z>gp4qgX54dLm^0h`%tRRxT7p?W=toD>N%|*sZ z#;%C|$Qz5(^XuNzifz39*Lq8R;L3xJ;w{n^*QxAXUzIBg z7gJX8qU(H79Wj*a{4hFKzy^Y1fj#Ko7V4-uC9MA44)3FW*cc?=t;PDWj3TH-Z40o! zZMX{jb(wVdd|J*Xd`giA1>cx?_`hWzE$Vnln4QtHnfOz1B-SpVP}d zdfA@0XysEux3yemlI&*bb$}4z00Bdf+06p2pGI|XwvUBcmn}PB_Hwt6vJU?Gae&?v z{ao#btA{0urlsZri01g)a03cqywt-Lt`t0vq6+nbXC(zHgJ*?2QVth9Wo_^@{~a*~ zxD-4oC@2L_3e#QiG-2PS;HfcB0p3#Z)GWVLEy>?`lrE37g7Ny}3jKbW{_kRR_A_Gp zIPbQjIAG5;ii6ziqO9AFwKv9Hl<(!bgYoXh2mk)yhm{H4t|B z5z!xizHj5dul;LQ<%-pJ+0x2#72N`qe;C42GuBQOdBtg-;;#wfQEz~aIZQTNbcpI{ zExdH9+C~Rnv=LuPuD5%;wTbU)+~v_^f0Gt z)zC+8pF)wwFm9QJR&ZK1$gz}q|AR|jpHlqRY+dBFd#I=U`vuz4N8MAlw(G4oum9#l zW%{G+(PCWPLs4U1yTKfgw~MqkBDbq`=wQT)L91hd#@UN<2OMVgstKpu0WZz!wedSE zSG##T=WCVhav#mEnA>pwaaxkY;!?i*_G0?hCi}7v8>4(SFRPA17@z=B{#(9P z`INBnNBR28`Dm?!lvB{kOSuHkTWY-%Ovtx6W#yd1%5Q^ry&nLbq7NlCj;BfjS0B$W z*IV_K>ZJU;=dDFea+KFOO(?U6V6@HtmU?df*_l^0k1U*S z3QIMiwal*KGR_Bj4p;2ZVyK?4&5Khe%-p-#m>E)b5q@`7i$UpTBc{!0U^~;}K?#2=c!xt^ca$ zOSkwp<`=I&{)F;9>NydoA*k7S^NkvB6pJsN(3Ix&oqA6RPI*OTMrCY@(B$=%vCwXz z%GMcnr?nB?Id9v!?uK(E=jz&NiPlbuU%#SUQ)&FT2tj-@;C~=c@gcx-k!^gBFg%%0 zO~$j)!E`2Bhz+F^llek^tQb9=E=`P|+; zdpg^u3!~ej4c>EO_$JM6i;Z+wnx_t$>Et`S{s`Zy>$7v;Z0;kdRrBZXa{qaZHfxtf z{#5x?&!;YS{;q3>`krUb3XOT{fAxLQ&`i(7#N5|K;{^Yexqm+Y@%Cqi>5~fDxVk5^ zV)taO-;PWNtBSHcnVmKEWYD5|I<?p9o>8l(94;=C+M(SrTRLgoBK*|>Wh(fKmFOwb3HZ*>VG>B z<{MK~rs8`6T`M|Nl<2-A(0+BjRpO2F*+;GEAUOZpsm^Rb3(0@p$2-I1f4dsU)@{k( zs`mkzjLI6(=V1twf9-DcBJNB6T^u)ou<{e|jz{=`g7V+{J(j><_S!pi>X&f< literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..81effeca1d5155932473f4169e052f29d4843922 GIT binary patch literal 16384 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�iAW7 zCg)rFhl0l9&MGZ@=}dJQgR>jn036 zYqwt0Zf(riZ?`H?F-qj!2lNj-{hL4$joOqE)G32b=JfA$wLJhtqx1Y7Ky9Ny9qAlE z{|r@|H0f5LC`hMkT3xCtrL}&+`cvCe_~W}5pKeBT{KaTCQV7bwcUM{O$|mKX@1d~~ z{r?g4M + + 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 0000000000000000000000000000000000000000..a62b95b8b1b6435e50b4bc09ae2997b1b15372fb GIT binary patch literal 286866 zcmeHw3w%|@)$b&M2zvEvrEs-cDJn_VgCvy#bXp9kmt*sSv# zHnV51Su^urv;SE$duH$S$v>XoMX0}f@vk5LtxgakLH#FgP?N=+_Uq1*_Cww`#Opmc zFanGKBM@Q)-s>f{-J*u=&LhPGI3l~J5P&u{%eMjzUK-+6r>FX>$av1^Eti*?0IqL& z3|otW??!QGaJR$bueHwj+Mx%oKA6_UQz#!Lyo9n;5#lgPlz9&2slrnT zxEh`mBHdd}Ji`)rO#;;!n1Q@B-20`#8t6smWfaCve+aa>rZ9%DxcY{@xiM+g)^Cg10%o)Fall>0KJslrTY1jTZmW` z{xJfK03#3t0-znx3v){l5OP*VfDv$m0CS5QP&kPZU<86jfVm}T2w4FmzzDcOfVssD zD4fIyFakj%z}ylvgsgxOUU~UN-LRP>CFamB6Xy+Eq+Bsg| z;sz#8VgwigKM`PV@e?o>X9O4lpAcYf@d+jtVgwigKM`PV@e?o>X9O4lpAcYf@d+jt zVgwigKM`PV@e?o>X9O4lpAgV<%aE)1IgwAmu@ED`2zW(6<(5(EOT*gVvB2Eo6)wKW z2rvRZBEa0@BTy{H2rvSEA;8??7hEjN2rvRZBEa0@BTy{H2rvSEA;8??7hEjN2rvRZ zBEa0@BTy{H2rvSEA;8??7hEjN2rvRZBB1A%!QFU$i;vK;7$d+4ctJqr7QE-5-?88Y zBfi84FarJ~5CLvE_t!sjU<4R}xIn;v3h|gD0^CxyG>rozzzD;Nd2*fM`M1B5Kh{qfe;}(xK;0ufZBM<`!Ft@~j5x5GBfB_K*H@6%d9Qt=GguKoM zv@17>5r{SdA-_*)Otih@88mZCv@Oi#GXl{;fVm|)xO1tDfYA|PZZW!rxqXa4bP!-} zi4N{uDkETY1PsG1!dxOWKeG^uvU}yOHcCqnqOvfpRZ&DvF;dbJg=wYPx+Ohja~TO_ zBnhQztI@3;)9qsm#Kwi{EHR>Y{6(DAEt7{%`Jz*un*c(o$-gyT40hu zner>(tH@JCa*A8`uI_?Jo1&QV$}6{|BMxVVycgycEml#9vjw99dzcFKbe{%X9G*d! zj}qJDd;TNHEmjP9Oa)4bnJPajzd|!e61y#lI&PscQIZf$Q2+@qT zDkE_Vuq?1DW?@p462vhk+HDz40Fw`+;}(pGlCyUzrMZyV)q?4k0utt96cJzxMiKnb z7Hu$Y0XU`tYl#^XFX~UuBhI_-_3n3N@N48)rSRwd27>`?k ziEh{)JW8w~!U(VhBMf*riZcwi;E$blcE$P3s4^UgvCc3dz!nS>u+dU$7;cFcfLtyk zzzDcSApG3I`=H$d&xwqH!4U`(x5$0ahxi=}2Jb=KJVwAh0?aM$ap6=(fDs4|0p^zA z@Z;Q!03+ZY0mE?1=CanU874)klI?84!|3dt^zaDl`Q_Svq|nYpZA!8b*ie*|y%TG6 zWkxJ|F_}!XY8M-hNL6k!7SEJoVN6C+Hf?WoEn3!rBfcZx3ZpaxkY@|}j%18T8kk$a z23s?dz&2&AN>a+^ime&CorzKawlME(k=!EF(YJ|hB$E&wLG8|#D(05Z_F-3Uk%nLk zh8F6`XfrCefEMI>ejtfnN?Q@7uTqkmtQCL^F^Lu4&*n1nRUk}pnH^%_nOx*-DP?X6 zZ5P#X3tKR>@J3#nk+?;O6gdKN?U{RWld<1fuI-0_95Epm(&5;^OJQz_d?%z5!7XgT zXn`M&a>KzbW!MMZ@h9>%tqJ7f~Qj$croQff*C>#d5a&)o<4Q6ZOaSIGYy%al}rDsC-J_td(Gf|F@XsQql zL)@ZGmwpbIiku=jmz$oHow5S&w`-pnHdx1qd~+nXumvLzemF`r9=AxpC3v``-x9nk z)^J$_B)6~yFN;-N2pEZ5v7K{MS5i7zl+!7ANm|Mbu zY9w{C1tW>Jt}Nyj9Uy$l2rvR6L4dg>BrviPMt~8}A;8?C1B6c*0Y)Gs2!w-M%2T7T zz9l4Ruo6aq5eO9m%q^iplJzhGjDQva!*GjS9YL*=i*n_9IV^I+qW;ZgR$6llF`0$d z<U~v zatr#i+=__!o?P>)yfS{HLRh<~TW(0K9;nPh$AGs5A!^A-RPu7(UFys@X`~qV0sl1MsMG(>H6G1Y@FPkwT*+bmokt6pVBr zCQ>#NZ%~)UIB09e3UW@60zNWzywnB4r9b1ZyN143!W?YD(8C%%jp5>!&Tq{}=o=z# z|LOr(ITJ|lv4og8IYnffak_ce&&=s2k+MSTnUEMV%C1hklZbyHi646};pnhz!Em4& zMV*G{mMCJ&Mf-(-CvNde2@A�?aM3V~Z=iCd@4c>i~w~7K7P^o5KjiI|9rt@oqt` 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 literal 0 HcmV?d00001 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