Corrected then broke again data binding...

Lib now uses more nuget packages

ModernKeePass/MainPage.xaml.cs

@@ -3,6 +3,7 @@ using Windows.UI.Xaml.Controls;
 using Windows.UI.Xaml.Input;
 
 using ModernKeePass.Pages;
+using ModernKeePass.ViewModels;
 
 // The Blank Page item template is documented at http://go.microsoft.com/fwlink/?LinkId=234238
 
@@ -31,7 +32,9 @@ namespace ModernKeePass
             {
                 // Application now has read/write access to the picked file
                 textBlock.Text = "Opened database: " + file.Name;
-                Frame.Navigate(typeof(DatabaseDetailPage), file);
+                var database = new DatabaseVm();
+                database.Open(file, "test");
+                Frame.Navigate(typeof(GroupDetailPage), database.RootGroup);
             }
             else
             {

ModernKeePass/ModernKeePass.csproj

@@ -114,8 +114,8 @@
     <Compile Include="MainPage.xaml.cs">
       <DependentUpon>MainPage.xaml</DependentUpon>
     </Compile>
-    <Compile Include="Pages\DatabaseDetailPage.xaml.cs">
-      <DependentUpon>DatabaseDetailPage.xaml</DependentUpon>
+    <Compile Include="Pages\GroupDetailPage.xaml.cs">
+      <DependentUpon>GroupDetailPage.xaml</DependentUpon>
     </Compile>
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="ViewModels\DatabaseVm.cs" />
@@ -144,14 +144,14 @@
       <Generator>MSBuild:Compile</Generator>
       <SubType>Designer</SubType>
     </Page>
-    <Page Include="Pages\DatabaseDetailPage.xaml">
+    <Page Include="Pages\GroupDetailPage.xaml">
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
     </Page>
   </ItemGroup>
   <ItemGroup>
-    <Reference Include="ModernKeePassLib, Version=2.19.0.26202, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\ModernKeePassLib.2.19.0.26202\lib\netstandard1.2\ModernKeePassLib.dll</HintPath>
+    <Reference Include="ModernKeePassLib, Version=2.19.0.27564, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\ModernKeePassLib.2.19.0.27564\lib\netstandard1.2\ModernKeePassLib.dll</HintPath>
       <Private>True</Private>
     </Reference>
     <Reference Include="System.Runtime.InteropServices.RuntimeInformation, Version=4.0.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">

ModernKeePass/Pages/GroupDetailPage.xaml

@@ -7,23 +7,11 @@
     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
     xmlns:ViewModels="using:ModernKeePass.ViewModels"
     x:Name="pageRoot"
-    x:Class="ModernKeePass.Pages.DatabaseDetailPage"
-    DataContext="{Binding ViewModel, RelativeSource={RelativeSource Self}}"
+    x:Class="ModernKeePass.Pages.GroupDetailPage"
+    DataContext="{Binding ViewModel, Mode=OneWay, RelativeSource={RelativeSource Mode=Self}}"
     mc:Ignorable="d">
-    <!--<Page.DataContext>
-        <ViewModels:DatabaseVm />
-    </Page.DataContext>-->
-    <Page.Resources>
-        <!-- Collection of items displayed by this page -->
-        <CollectionViewSource
-            x:Name="itemsViewSource"
-            Source="{Binding Groups}"/>
-    </Page.Resources>
 
     <Grid>
-        <Grid.DataContext>
-            <ViewModels:DatabaseVm/>
-        </Grid.DataContext>
         <Grid.ChildrenTransitions>
             <TransitionCollection>
                 <EntranceThemeTransition/>
@@ -34,6 +22,11 @@
             <RowDefinition Height="*"/>
         </Grid.RowDefinitions>
 
+        <Grid.Resources>
+            <CollectionViewSource
+                x:Name="itemsViewSource"
+                Source="{Binding Groups}"/>
+        </Grid.Resources>
         <!-- Horizontal scrolling grid -->
         <GridView
             x:Name="itemGridView"
@@ -48,9 +41,6 @@
             <GridView.ItemTemplate>
                 <DataTemplate>
                     <Grid Height="110" Width="480" Margin="10">
-                        <Grid.DataContext>
-                            <ViewModels:GroupVm/>
-                        </Grid.DataContext>
                         <Grid.ColumnDefinitions>
                             <ColumnDefinition Width="Auto"/>
                             <ColumnDefinition Width="*"/>
@@ -59,9 +49,9 @@
                             <Image Stretch="UniformToFill" AutomationProperties.Name="{Binding Title}"/>
                         </Border>
                         <StackPanel Grid.Column="1" VerticalAlignment="Top" Margin="10,0,0,0">
-                            <TextBlock Style="{StaticResource TitleTextBlockStyle}" TextWrapping="NoWrap" Text="{Binding Name}"/>
+                            <TextBlock Text="{Binding Name}" Style="{StaticResource TitleTextBlockStyle}" TextWrapping="NoWrap"/>
                             <TextBlock Style="{StaticResource CaptionTextBlockStyle}" TextWrapping="NoWrap"/>
-                            <TextBlock Style="{StaticResource BodyTextBlockStyle}" MaxHeight="60"/>
+                            <TextBlock Text="{Binding EntryCount}" Style="{StaticResource BodyTextBlockStyle}" MaxHeight="60"/>
                         </StackPanel>
                     </Grid>
                 </DataTemplate>

ModernKeePass/Pages/GroupDetailPage.xaml.cs

@@ -2,7 +2,6 @@
 using Windows.UI.Xaml.Controls;
 using Windows.UI.Xaml.Navigation;
 using ModernKeePass.ViewModels;
-using Windows.Storage;
 
 // The Group Detail Page item template is documented at http://go.microsoft.com/fwlink/?LinkId=234229
 
@@ -12,14 +11,14 @@ namespace ModernKeePass.Pages
     /// A page that displays an overview of a single group, including a preview of the items
     /// within the group.
     /// </summary>
-    public sealed partial class DatabaseDetailPage : Page
+    public sealed partial class GroupDetailPage : Page
     {
         private NavigationHelper navigationHelper;
-        private DatabaseVm viewModel = new DatabaseVm();
+        private GroupVm viewModel;
 
-        public DatabaseVm ViewModel
+        public GroupVm ViewModel
         {
-            get { return this.viewModel; }
+            get { return viewModel; }
         }
 
         /// <summary>
@@ -32,7 +31,7 @@ namespace ModernKeePass.Pages
         }
 
 
-        public DatabaseDetailPage()
+        public GroupDetailPage()
         {
             this.InitializeComponent();
             this.navigationHelper = new NavigationHelper(this);
@@ -71,10 +70,9 @@ namespace ModernKeePass.Pages
         {
             navigationHelper.OnNavigatedTo(e);
             
-            if (e.Parameter is StorageFile)
+            if (e.Parameter is GroupVm)
             {
-                var file = e.Parameter as StorageFile;
-                viewModel.Open(file, "test");
+                viewModel = e.Parameter as GroupVm;
             }
         }
 

ModernKeePass/ViewModels/DatabaseVm.cs

@@ -15,7 +15,7 @@ namespace ModernKeePass.ViewModels
         private PwDatabase _database = new PwDatabase();
 
         public string Name { get; set; }
-        public ObservableCollection<GroupVm> Groups { get; set; }
+        public GroupVm RootGroup { get; set; }
 
         public async void Open(StorageFile databaseFile, string password)
         {
@@ -26,7 +26,7 @@ namespace ModernKeePass.ViewModels
                 await _database.Open(IOConnectionInfo.FromFile(databaseFile), key, new NullStatusLogger());
                 if (!_database.IsOpen) return;
                 Name = databaseFile.DisplayName;
-                Groups = new ObservableCollection<GroupVm>(_database.RootGroup.Groups.Select(g => new GroupVm { Name = g.Name }));
+                RootGroup = new GroupVm (_database.RootGroup);
             }
             finally
             {

ModernKeePass/ViewModels/EntryVm.cs

@@ -3,10 +3,23 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using ModernKeePassLib;
 
 namespace ModernKeePass.ViewModels
 {
     public class EntryVm
     {
+        public string Title { get; private set; }
+        public string UserName { get; private set; }
+        public string URL { get; private set; }
+        public string Notes { get; private set; }
+
+        public EntryVm(PwEntry entry)
+        {
+            Title = entry.Strings.GetSafe(PwDefs.TitleField).ReadString();
+            UserName = entry.Strings.GetSafe(PwDefs.UserNameField).ReadString();
+            URL = entry.Strings.GetSafe(PwDefs.UrlField).ReadString();
+            Notes = entry.Strings.GetSafe(PwDefs.NotesField).ReadString();
+        }
     }
 }

ModernKeePass/ViewModels/GroupVm.cs

@@ -1,14 +1,27 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using ModernKeePassLib;
 
 namespace ModernKeePass.ViewModels
 {
     public class GroupVm
     {
-        public List<EntryVm> Entries { get; set; }
+        public ObservableCollection<EntryVm> Entries { get; set; }
+        public ObservableCollection<GroupVm> Groups { get; set; }
         public string Name { get; set; }
+
+        public string EntryCount {
+            get
+            {
+                return $"{Entries?.Count} entries.";
+            }
+        }
+
+        public GroupVm(PwGroup group)
+        {
+            Name = group.Name;
+            Entries = new ObservableCollection<EntryVm>(group.Entries.Select(e => new EntryVm(e)));
+            Groups = new ObservableCollection<GroupVm>(group.Groups.Select(g => new GroupVm(g)));
+        }
     }
 }

ModernKeePass/obj/Debug/XamlSaveStateFile.xml

@@ -1,7 +1,7 @@
 <XamlCompilerSaveState>
   <ReferenceAssemblyList>
-    <LocalAssembly PathName="c:\users\gbe\source\repos\modernkeepass\modernkeepass\obj\debug\intermediatexaml\modernkeepass.exe" HashGuid="76dc0cd8-3905-4d82-b50e-0e7de053066f" />
-    <ReferenceAssembly PathName="c:\users\gbe\source\repos\modernkeepass\packages\modernkeepasslib.2.19.0.26202\lib\netstandard1.2\modernkeepasslib.dll" HashGuid="29b95f3b-9b53-5341-fc4d-d6dbb7ef4dbc" />
+    <LocalAssembly PathName="c:\users\gbe\source\repos\modernkeepass\modernkeepass\obj\debug\intermediatexaml\modernkeepass.exe" HashGuid="1f15d3c6-6641-2a67-6c8d-dce14934fe26" />
+    <ReferenceAssembly PathName="c:\users\gbe\source\repos\modernkeepass\packages\modernkeepasslib.2.19.0.27564\lib\netstandard1.2\modernkeepasslib.dll" HashGuid="29b95f3b-9b53-5341-fc4d-d6dbb7ef4dbc" />
     <ReferenceAssembly PathName="c:\users\gbe\source\repos\modernkeepass\packages\system.runtime.interopservices.runtimeinformation.4.3.0\lib\win8\system.runtime.interopservices.runtimeinformation.dll" HashGuid="6560d00f-0bb0-0755-5423-c4e1bf779127" />
   </ReferenceAssemblyList>
 </XamlCompilerSaveState>

ModernKeePass/obj/Debug/XamlTypeInfo.g.cs

@@ -0,0 +1,599 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+
+
+namespace ModernKeePass
+{
+    public partial class App : global::Windows.UI.Xaml.Markup.IXamlMetadataProvider
+    {
+        private global::ModernKeePass.ModernKeePass_XamlTypeInfo.XamlTypeInfoProvider _provider;
+
+        public global::Windows.UI.Xaml.Markup.IXamlType GetXamlType(global::System.Type type)
+        {
+            if(_provider == null)
+            {
+                _provider = new global::ModernKeePass.ModernKeePass_XamlTypeInfo.XamlTypeInfoProvider();
+            }
+            return _provider.GetXamlTypeByType(type);
+        }
+
+        public global::Windows.UI.Xaml.Markup.IXamlType GetXamlType(string fullName)
+        {
+            if(_provider == null)
+            {
+                _provider = new global::ModernKeePass.ModernKeePass_XamlTypeInfo.XamlTypeInfoProvider();
+            }
+            return _provider.GetXamlTypeByName(fullName);
+        }
+
+        public global::Windows.UI.Xaml.Markup.XmlnsDefinition[] GetXmlnsDefinitions()
+        {
+            return new global::Windows.UI.Xaml.Markup.XmlnsDefinition[0];
+        }
+    }
+}
+
+namespace ModernKeePass.ModernKeePass_XamlTypeInfo
+{
+    
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Windows.UI.Xaml.Build.Tasks", "4.0.0.0")]    
+    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    internal partial class XamlTypeInfoProvider
+    {
+        public global::Windows.UI.Xaml.Markup.IXamlType GetXamlTypeByType(global::System.Type type)
+        {
+            global::Windows.UI.Xaml.Markup.IXamlType xamlType;
+            if (_xamlTypeCacheByType.TryGetValue(type, out xamlType))
+            {
+                return xamlType;
+            }
+            int typeIndex = LookupTypeIndexByType(type);
+            if(typeIndex != -1)
+            {
+                xamlType = CreateXamlType(typeIndex);
+            }
+            if (xamlType != null)
+            {
+                _xamlTypeCacheByName.Add(xamlType.FullName, xamlType);
+                _xamlTypeCacheByType.Add(xamlType.UnderlyingType, xamlType);
+            }
+            return xamlType;
+        }
+
+        public global::Windows.UI.Xaml.Markup.IXamlType GetXamlTypeByName(string typeName)
+        {
+            if (string.IsNullOrEmpty(typeName))
+            {
+                return null;
+            }
+            global::Windows.UI.Xaml.Markup.IXamlType xamlType;
+            if (_xamlTypeCacheByName.TryGetValue(typeName, out xamlType))
+            {
+                return xamlType;
+            }
+            int typeIndex = LookupTypeIndexByName(typeName);
+            if(typeIndex != -1)
+            {
+                xamlType = CreateXamlType(typeIndex);
+            }
+            if (xamlType != null)
+            {
+                _xamlTypeCacheByName.Add(xamlType.FullName, xamlType);
+                _xamlTypeCacheByType.Add(xamlType.UnderlyingType, xamlType);
+            }
+            return xamlType;
+        }
+
+        public global::Windows.UI.Xaml.Markup.IXamlMember GetMemberByLongName(string longMemberName)
+        {
+            if (string.IsNullOrEmpty(longMemberName))
+            {
+                return null;
+            }
+            global::Windows.UI.Xaml.Markup.IXamlMember xamlMember;
+            if (_xamlMembers.TryGetValue(longMemberName, out xamlMember))
+            {
+                return xamlMember;
+            }
+            xamlMember = CreateXamlMember(longMemberName);
+            if (xamlMember != null)
+            {
+                _xamlMembers.Add(longMemberName, xamlMember);
+            }
+            return xamlMember;
+        }
+
+        global::System.Collections.Generic.Dictionary<string, global::Windows.UI.Xaml.Markup.IXamlType>
+                _xamlTypeCacheByName = new global::System.Collections.Generic.Dictionary<string, global::Windows.UI.Xaml.Markup.IXamlType>();
+
+        global::System.Collections.Generic.Dictionary<global::System.Type, global::Windows.UI.Xaml.Markup.IXamlType>
+                _xamlTypeCacheByType = new global::System.Collections.Generic.Dictionary<global::System.Type, global::Windows.UI.Xaml.Markup.IXamlType>();
+
+        global::System.Collections.Generic.Dictionary<string, global::Windows.UI.Xaml.Markup.IXamlMember>
+                _xamlMembers = new global::System.Collections.Generic.Dictionary<string, global::Windows.UI.Xaml.Markup.IXamlMember>();
+
+        string[] _typeNameTable = null;
+        global::System.Type[] _typeTable = null;
+
+        private void InitTypeTables()
+        {
+            _typeNameTable = new string[8];
+            _typeNameTable[0] = "ModernKeePass.MainPage";
+            _typeNameTable[1] = "Windows.UI.Xaml.Controls.Page";
+            _typeNameTable[2] = "Windows.UI.Xaml.Controls.UserControl";
+            _typeNameTable[3] = "ModernKeePass.Pages.GroupDetailPage";
+            _typeNameTable[4] = "ModernKeePass.ViewModels.GroupVm";
+            _typeNameTable[5] = "Object";
+            _typeNameTable[6] = "ModernKeePass.Common.NavigationHelper";
+            _typeNameTable[7] = "Windows.UI.Xaml.DependencyObject";
+
+            _typeTable = new global::System.Type[8];
+            _typeTable[0] = typeof(global::ModernKeePass.MainPage);
+            _typeTable[1] = typeof(global::Windows.UI.Xaml.Controls.Page);
+            _typeTable[2] = typeof(global::Windows.UI.Xaml.Controls.UserControl);
+            _typeTable[3] = typeof(global::ModernKeePass.Pages.GroupDetailPage);
+            _typeTable[4] = typeof(global::ModernKeePass.ViewModels.GroupVm);
+            _typeTable[5] = typeof(global::System.Object);
+            _typeTable[6] = typeof(global::ModernKeePass.Common.NavigationHelper);
+            _typeTable[7] = typeof(global::Windows.UI.Xaml.DependencyObject);
+        }
+
+        private int LookupTypeIndexByName(string typeName)
+        {
+            if (_typeNameTable == null)
+            {
+                InitTypeTables();
+            }
+            for (int i=0; i<_typeNameTable.Length; i++)
+            {
+                if(0 == string.CompareOrdinal(_typeNameTable[i], typeName))
+                {
+                    return i;
+                }
+            }
+            return -1;
+        }
+
+        private int LookupTypeIndexByType(global::System.Type type)
+        {
+            if (_typeTable == null)
+            {
+                InitTypeTables();
+            }
+            for(int i=0; i<_typeTable.Length; i++)
+            {
+                if(type == _typeTable[i])
+                {
+                    return i;
+                }
+            }
+            return -1;
+        }
+
+        private object Activate_0_MainPage() { return new global::ModernKeePass.MainPage(); }
+        private object Activate_3_GroupDetailPage() { return new global::ModernKeePass.Pages.GroupDetailPage(); }
+
+        private global::Windows.UI.Xaml.Markup.IXamlType CreateXamlType(int typeIndex)
+        {
+            global::ModernKeePass.ModernKeePass_XamlTypeInfo.XamlSystemBaseType xamlType = null;
+            global::ModernKeePass.ModernKeePass_XamlTypeInfo.XamlUserType userType;
+            string typeName = _typeNameTable[typeIndex];
+            global::System.Type type = _typeTable[typeIndex];
+
+            switch (typeIndex)
+            {
+
+            case 0:   //  ModernKeePass.MainPage
+                userType = new global::ModernKeePass.ModernKeePass_XamlTypeInfo.XamlUserType(this, typeName, type, GetXamlTypeByName("Windows.UI.Xaml.Controls.Page"));
+                userType.Activator = Activate_0_MainPage;
+                userType.SetIsLocalType();
+                xamlType = userType;
+                break;
+
+            case 1:   //  Windows.UI.Xaml.Controls.Page
+                xamlType = new global::ModernKeePass.ModernKeePass_XamlTypeInfo.XamlSystemBaseType(typeName, type);
+                break;
+
+            case 2:   //  Windows.UI.Xaml.Controls.UserControl
+                xamlType = new global::ModernKeePass.ModernKeePass_XamlTypeInfo.XamlSystemBaseType(typeName, type);
+                break;
+
+            case 3:   //  ModernKeePass.Pages.GroupDetailPage
+                userType = new global::ModernKeePass.ModernKeePass_XamlTypeInfo.XamlUserType(this, typeName, type, GetXamlTypeByName("Windows.UI.Xaml.Controls.Page"));
+                userType.Activator = Activate_3_GroupDetailPage;
+                userType.AddMemberName("ViewModel");
+                userType.AddMemberName("NavigationHelper");
+                userType.SetIsLocalType();
+                xamlType = userType;
+                break;
+
+            case 4:   //  ModernKeePass.ViewModels.GroupVm
+                userType = new global::ModernKeePass.ModernKeePass_XamlTypeInfo.XamlUserType(this, typeName, type, GetXamlTypeByName("Object"));
+                userType.SetIsReturnTypeStub();
+                userType.SetIsLocalType();
+                xamlType = userType;
+                break;
+
+            case 5:   //  Object
+                xamlType = new global::ModernKeePass.ModernKeePass_XamlTypeInfo.XamlSystemBaseType(typeName, type);
+                break;
+
+            case 6:   //  ModernKeePass.Common.NavigationHelper
+                userType = new global::ModernKeePass.ModernKeePass_XamlTypeInfo.XamlUserType(this, typeName, type, GetXamlTypeByName("Windows.UI.Xaml.DependencyObject"));
+                userType.SetIsReturnTypeStub();
+                userType.SetIsLocalType();
+                xamlType = userType;
+                break;
+
+            case 7:   //  Windows.UI.Xaml.DependencyObject
+                xamlType = new global::ModernKeePass.ModernKeePass_XamlTypeInfo.XamlSystemBaseType(typeName, type);
+                break;
+            }
+            return xamlType;
+        }
+
+
+        private object get_0_GroupDetailPage_ViewModel(object instance)
+        {
+            var that = (global::ModernKeePass.Pages.GroupDetailPage)instance;
+            return that.ViewModel;
+        }
+        private object get_1_GroupDetailPage_NavigationHelper(object instance)
+        {
+            var that = (global::ModernKeePass.Pages.GroupDetailPage)instance;
+            return that.NavigationHelper;
+        }
+
+        private global::Windows.UI.Xaml.Markup.IXamlMember CreateXamlMember(string longMemberName)
+        {
+            global::ModernKeePass.ModernKeePass_XamlTypeInfo.XamlMember xamlMember = null;
+            global::ModernKeePass.ModernKeePass_XamlTypeInfo.XamlUserType userType;
+
+            switch (longMemberName)
+            {
+            case "ModernKeePass.Pages.GroupDetailPage.ViewModel":
+                userType = (global::ModernKeePass.ModernKeePass_XamlTypeInfo.XamlUserType)GetXamlTypeByName("ModernKeePass.Pages.GroupDetailPage");
+                xamlMember = new global::ModernKeePass.ModernKeePass_XamlTypeInfo.XamlMember(this, "ViewModel", "ModernKeePass.ViewModels.GroupVm");
+                xamlMember.Getter = get_0_GroupDetailPage_ViewModel;
+                xamlMember.SetIsReadOnly();
+                break;
+            case "ModernKeePass.Pages.GroupDetailPage.NavigationHelper":
+                userType = (global::ModernKeePass.ModernKeePass_XamlTypeInfo.XamlUserType)GetXamlTypeByName("ModernKeePass.Pages.GroupDetailPage");
+                xamlMember = new global::ModernKeePass.ModernKeePass_XamlTypeInfo.XamlMember(this, "NavigationHelper", "ModernKeePass.Common.NavigationHelper");
+                xamlMember.Getter = get_1_GroupDetailPage_NavigationHelper;
+                xamlMember.SetIsReadOnly();
+                break;
+            }
+            return xamlMember;
+        }
+    }
+
+    
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Windows.UI.Xaml.Build.Tasks", "4.0.0.0")]    
+    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    internal class XamlSystemBaseType : global::Windows.UI.Xaml.Markup.IXamlType
+    {
+        string _fullName;
+        global::System.Type _underlyingType;
+
+        public XamlSystemBaseType(string fullName, global::System.Type underlyingType)
+        {
+            _fullName = fullName;
+            _underlyingType = underlyingType;
+        }
+
+        public string FullName { get { return _fullName; } }
+
+        public global::System.Type UnderlyingType
+        {
+            get
+            {
+                return _underlyingType;
+            }
+        }
+
+        virtual public global::Windows.UI.Xaml.Markup.IXamlType BaseType { get { throw new global::System.NotImplementedException(); } }
+        virtual public global::Windows.UI.Xaml.Markup.IXamlMember ContentProperty { get { throw new global::System.NotImplementedException(); } }
+        virtual public global::Windows.UI.Xaml.Markup.IXamlMember GetMember(string name) { throw new global::System.NotImplementedException(); }
+        virtual public bool IsArray { get { throw new global::System.NotImplementedException(); } }
+        virtual public bool IsCollection { get { throw new global::System.NotImplementedException(); } }
+        virtual public bool IsConstructible { get { throw new global::System.NotImplementedException(); } }
+        virtual public bool IsDictionary { get { throw new global::System.NotImplementedException(); } }
+        virtual public bool IsMarkupExtension { get { throw new global::System.NotImplementedException(); } }
+        virtual public bool IsBindable { get { throw new global::System.NotImplementedException(); } }
+        virtual public bool IsReturnTypeStub { get { throw new global::System.NotImplementedException(); } }
+        virtual public bool IsLocalType { get { throw new global::System.NotImplementedException(); } }
+        virtual public global::Windows.UI.Xaml.Markup.IXamlType ItemType { get { throw new global::System.NotImplementedException(); } }
+        virtual public global::Windows.UI.Xaml.Markup.IXamlType KeyType { get { throw new global::System.NotImplementedException(); } }
+        virtual public object ActivateInstance() { throw new global::System.NotImplementedException(); }
+        virtual public void AddToMap(object instance, object key, object item)  { throw new global::System.NotImplementedException(); }
+        virtual public void AddToVector(object instance, object item)  { throw new global::System.NotImplementedException(); }
+        virtual public void RunInitializer()   { throw new global::System.NotImplementedException(); }
+        virtual public object CreateFromString(string input)   { throw new global::System.NotImplementedException(); }
+    }
+    
+    internal delegate object Activator();
+    internal delegate void AddToCollection(object instance, object item);
+    internal delegate void AddToDictionary(object instance, object key, object item);
+
+    
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Windows.UI.Xaml.Build.Tasks", "4.0.0.0")]    
+    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    internal class XamlUserType : global::ModernKeePass.ModernKeePass_XamlTypeInfo.XamlSystemBaseType
+    {
+        global::ModernKeePass.ModernKeePass_XamlTypeInfo.XamlTypeInfoProvider _provider;
+        global::Windows.UI.Xaml.Markup.IXamlType _baseType;
+        bool _isArray;
+        bool _isMarkupExtension;
+        bool _isBindable;
+        bool _isReturnTypeStub;
+        bool _isLocalType;
+
+        string _contentPropertyName;
+        string _itemTypeName;
+        string _keyTypeName;
+        global::System.Collections.Generic.Dictionary<string, string> _memberNames;
+        global::System.Collections.Generic.Dictionary<string, object> _enumValues;
+
+        public XamlUserType(global::ModernKeePass.ModernKeePass_XamlTypeInfo.XamlTypeInfoProvider provider, string fullName, global::System.Type fullType, global::Windows.UI.Xaml.Markup.IXamlType baseType)
+            :base(fullName, fullType)
+        {
+            _provider = provider;
+            _baseType = baseType;
+        }
+
+        // --- Interface methods ----
+
+        override public global::Windows.UI.Xaml.Markup.IXamlType BaseType { get { return _baseType; } }
+        override public bool IsArray { get { return _isArray; } }
+        override public bool IsCollection { get { return (CollectionAdd != null); } }
+        override public bool IsConstructible { get { return (Activator != null); } }
+        override public bool IsDictionary { get { return (DictionaryAdd != null); } }
+        override public bool IsMarkupExtension { get { return _isMarkupExtension; } }
+        override public bool IsBindable { get { return _isBindable; } }
+        override public bool IsReturnTypeStub { get { return _isReturnTypeStub; } }
+        override public bool IsLocalType { get { return _isLocalType; } }
+
+        override public global::Windows.UI.Xaml.Markup.IXamlMember ContentProperty
+        {
+            get { return _provider.GetMemberByLongName(_contentPropertyName); }
+        }
+
+        override public global::Windows.UI.Xaml.Markup.IXamlType ItemType
+        {
+            get { return _provider.GetXamlTypeByName(_itemTypeName); }
+        }
+
+        override public global::Windows.UI.Xaml.Markup.IXamlType KeyType
+        {
+            get { return _provider.GetXamlTypeByName(_keyTypeName); }
+        }
+
+        override public global::Windows.UI.Xaml.Markup.IXamlMember GetMember(string name)
+        {
+            if (_memberNames == null)
+            {
+                return null;
+            }
+            string longName;
+            if (_memberNames.TryGetValue(name, out longName))
+            {
+                return _provider.GetMemberByLongName(longName);
+            }
+            return null;
+        }
+
+        override public object ActivateInstance()
+        {
+            return Activator(); 
+        }
+
+        override public void AddToMap(object instance, object key, object item) 
+        {
+            DictionaryAdd(instance, key, item);
+        }
+
+        override public void AddToVector(object instance, object item)
+        {
+            CollectionAdd(instance, item);
+        }
+
+        override public void RunInitializer() 
+        {
+            System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(UnderlyingType.TypeHandle);
+        }
+
+        override public object CreateFromString(string input)
+        {
+            if (_enumValues != null)
+            {
+                int value = 0;
+
+                string[] valueParts = input.Split(',');
+
+                foreach (string valuePart in valueParts) 
+                {
+                    object partValue;
+                    int enumFieldValue = 0;
+                    try
+                    {
+                        if (_enumValues.TryGetValue(valuePart.Trim(), out partValue))
+                        {
+                            enumFieldValue = global::System.Convert.ToInt32(partValue);
+                        }
+                        else
+                        {
+                            try
+                            {
+                                enumFieldValue = global::System.Convert.ToInt32(valuePart.Trim());
+                            }
+                            catch( global::System.FormatException )
+                            {
+                                foreach( string key in _enumValues.Keys )
+                                {
+                                    if( string.Compare(valuePart.Trim(), key, global::System.StringComparison.OrdinalIgnoreCase) == 0 )
+                                    {
+                                        if( _enumValues.TryGetValue(key.Trim(), out partValue) )
+                                        {
+                                            enumFieldValue = global::System.Convert.ToInt32(partValue);
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        value |= enumFieldValue; 
+                    }
+                    catch( global::System.FormatException )
+                    {
+                        throw new global::System.ArgumentException(input, FullName);
+                    }
+                }
+
+                return value; 
+            }
+            throw new global::System.ArgumentException(input, FullName);
+        }
+
+        // --- End of Interface methods
+
+        public Activator Activator { get; set; }
+        public AddToCollection CollectionAdd { get; set; }
+        public AddToDictionary DictionaryAdd { get; set; }
+
+        public void SetContentPropertyName(string contentPropertyName)
+        {
+            _contentPropertyName = contentPropertyName;
+        }
+
+        public void SetIsArray()
+        {
+            _isArray = true; 
+        }
+
+        public void SetIsMarkupExtension()
+        {
+            _isMarkupExtension = true;
+        }
+
+        public void SetIsBindable()
+        {
+            _isBindable = true;
+        }
+
+        public void SetIsReturnTypeStub()
+        {
+            _isReturnTypeStub = true;
+        }
+
+        public void SetIsLocalType()
+        {
+            _isLocalType = true;
+        }
+
+        public void SetItemTypeName(string itemTypeName)
+        {
+            _itemTypeName = itemTypeName;
+        }
+
+        public void SetKeyTypeName(string keyTypeName)
+        {
+            _keyTypeName = keyTypeName;
+        }
+
+        public void AddMemberName(string shortName)
+        {
+            if(_memberNames == null)
+            {
+                _memberNames =  new global::System.Collections.Generic.Dictionary<string,string>();
+            }
+            _memberNames.Add(shortName, FullName + "." + shortName);
+        }
+
+        public void AddEnumValue(string name, object value)
+        {
+            if (_enumValues == null)
+            {
+                _enumValues = new global::System.Collections.Generic.Dictionary<string, object>();
+            }
+            _enumValues.Add(name, value);
+        }
+    }
+
+    internal delegate object Getter(object instance);
+    internal delegate void Setter(object instance, object value);
+
+    
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Windows.UI.Xaml.Build.Tasks", "4.0.0.0")]    
+    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    internal class XamlMember : global::Windows.UI.Xaml.Markup.IXamlMember
+    {
+        global::ModernKeePass.ModernKeePass_XamlTypeInfo.XamlTypeInfoProvider _provider;
+        string _name;
+        bool _isAttachable;
+        bool _isDependencyProperty;
+        bool _isReadOnly;
+
+        string _typeName;
+        string _targetTypeName;
+
+        public XamlMember(global::ModernKeePass.ModernKeePass_XamlTypeInfo.XamlTypeInfoProvider provider, string name, string typeName)
+        {
+            _name = name;
+            _typeName = typeName;
+            _provider = provider;
+        }
+
+        public string Name { get { return _name; } }
+
+        public global::Windows.UI.Xaml.Markup.IXamlType Type
+        {
+            get { return _provider.GetXamlTypeByName(_typeName); }
+        }
+
+        public void SetTargetTypeName(string targetTypeName)
+        {
+            _targetTypeName = targetTypeName;
+        }
+        public global::Windows.UI.Xaml.Markup.IXamlType TargetType
+        {
+            get { return _provider.GetXamlTypeByName(_targetTypeName); }
+        }
+
+        public void SetIsAttachable() { _isAttachable = true; }
+        public bool IsAttachable { get { return _isAttachable; } }
+
+        public void SetIsDependencyProperty() { _isDependencyProperty = true; }
+        public bool IsDependencyProperty { get { return _isDependencyProperty; } }
+
+        public void SetIsReadOnly() { _isReadOnly = true; }
+        public bool IsReadOnly { get { return _isReadOnly; } }
+
+        public Getter Getter { get; set; }
+        public object GetValue(object instance)
+        {
+            if (Getter != null)
+                return Getter(instance);
+            else
+                throw new global::System.InvalidOperationException("GetValue");
+        }
+
+        public Setter Setter { get; set; }
+        public void SetValue(object instance, object value)
+        {
+            if (Setter != null)
+                Setter(instance, value);
+            else
+                throw new global::System.InvalidOperationException("SetValue");
+        }
+    }
+}
+
+

ModernKeePass/packages.config

@@ -1,9 +1,11 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="Microsoft.NETCore.Platforms" version="2.0.0" targetFramework="win81" />
-  <package id="Microsoft.NETCore.Portable.Compatibility" version="1.0.1" targetFramework="win81" />
-  <package id="ModernKeePassLib" version="2.19.0.26202" targetFramework="win81" />
+  <package id="Microsoft.NETCore.Portable.Compatibility" version="1.0.2" targetFramework="win81" />
+  <package id="ModernKeePassLib" version="2.19.0.27564" targetFramework="win81" />
   <package id="NETStandard.Library" version="2.0.0" targetFramework="win81" />
+  <package id="System.Net.Requests" version="4.3.0" targetFramework="win81" />
   <package id="System.Runtime.InteropServices.RuntimeInformation" version="4.3.0" targetFramework="win81" />
   <package id="System.Runtime.WindowsRuntime" version="4.3.0" targetFramework="win81" />
+  <package id="System.Xml.XmlSerializer" version="4.3.0" targetFramework="win81" />
 </packages>