Create VBESettings class to access the VBE's settings stored in the registry.

Create tests for VBESettings class (incomplete; need SystemWrappers or something)
Update the GeneralSettingsViewModel so that it checks the Compile On Demand settings and offer to update
Add resource strings for messages.

Author: bclothier

RetailCoder.VBE/Rubberduck.csproj

@@ -501,6 +501,8 @@
     <Compile Include="UnitTesting\Stubs\Beep.cs" />
     <Compile Include="UnitTesting\IStub.cs" />
     <Compile Include="UnitTesting\StubBase.cs" />
+    <Compile Include="VBERuntime\IVBESettings.cs" />
+    <Compile Include="VBERuntime\VBESettings.cs" />
     <Compile Include="VersionCheck\IVersionCheck.cs" />
     <Compile Include="UI\Command\MenuItems\CommandBars\AppCommandBarBase.cs" />
     <Compile Include="UI\Command\MenuItems\CommandBars\ContextSelectionLabelMenuItem.cs" />

RetailCoder.VBE/UI/RubberduckUI.Designer.cs

@@ -1795,4 +1795,16 @@ Would you like to import them to Rubberduck?</value>
   <data name="ParserState_UnexpectedError" xml:space="preserve">
     <value>Unexpected Error</value>
   </data>
+  <data name="Command_Reparse_CompileOnDemandEnabled" xml:space="preserve">
+    <value>The VBEsetting "Compile On Demand" is currently enabled. This is not recommended as this may hide compilation errors and cause problems with parsing. Do you want to parse anyway?</value>
+  </data>
+  <data name="Command_Reparse_CompileOnDemandEnabled_Caption" xml:space="preserve">
+    <value>Compile On Demand Setting</value>
+  </data>
+  <data name="GeneralSettings_CompileBeforeParse_WarnCompileOnDemandEnabled" xml:space="preserve">
+    <value>The VBE setting "Compile On Demand" is currently enabled. It is strongly recommended that you disable the setting via the VBE Properties dialog under General tab in order to use the Compile Before Parse feature. Do you want to disable it now?\r\n\r\nNOTE: Restart may be required for setting to take effect.</value>
+  </data>
+  <data name="GeneralSettings_CompileBeforeParse_WarnCompileOnDemandEnabled_Caption" xml:space="preserve">
+    <value>Compile On Demand currently enabled</value>
+  </data>
 </root>

RetailCoder.VBE/UI/RubberduckUI.resx

@@ -2,13 +2,15 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
+using System.Windows.Forms;
 using Rubberduck.Settings;
 using Rubberduck.Common;
 using NLog;
 using Rubberduck.Parsing.Common;
 using Rubberduck.Root;
 using Rubberduck.SettingsProvider;
 using Rubberduck.UI.Command;
+using Rubberduck.VBERuntime;
 
 namespace Rubberduck.UI.Settings
 {
@@ -21,11 +23,17 @@ public enum DelimiterOptions
     public class GeneralSettingsViewModel : SettingsViewModelBase, ISettingsViewModel
     {
         private readonly IOperatingSystem _operatingSystem;
+        private readonly IMessageBox _messageBox;
+        private readonly IVBESettings _vbeSettings;
+
         private bool _indenterPrompted;
 
-        public GeneralSettingsViewModel(Configuration config, IOperatingSystem operatingSystem)
+        public GeneralSettingsViewModel(Configuration config, IOperatingSystem operatingSystem, IMessageBox messageBox, IVBESettings vbeSettings)
         {
             _operatingSystem = operatingSystem;
+            _messageBox = messageBox;
+            _vbeSettings = vbeSettings;
+
             Languages = new ObservableCollection<DisplayLanguageSetting>(
                 new[] 
             {
@@ -131,11 +139,26 @@ public bool CompileBeforeParse
             get => _compileBeforeParse;
             set
             {
-                if (_compileBeforeParse != value)
+                if (_compileBeforeParse == value)
                 {
-                    _compileBeforeParse = value;
-                    OnPropertyChanged();
+                    return;
+                }
+
+                if (value && _vbeSettings.CompileOnDemand)
+                {
+                    var result = _messageBox.Show(RubberduckUI.GeneralSettings_CompileBeforeParse_WarnCompileOnDemandEnabled,
+                        RubberduckUI.GeneralSettings_CompileBeforeParse_WarnCompileOnDemandEnabled_Caption, MessageBoxButtons.YesNo,
+                        MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1);
+                    if(result == DialogResult.No)
+                    {
+                        return;
+                    }
+
+                    _vbeSettings.CompileOnDemand = false;
                 }
+
+                _compileBeforeParse = value;
+                OnPropertyChanged();
             }
         }
 

RetailCoder.VBE/UI/Settings/GeneralSettingsViewModel.cs

@@ -0,0 +1,9 @@
+namespace Rubberduck.VBERuntime
+{
+    public interface IVBESettings
+    {
+        VBESettings.DllVersion Version { get; }
+        bool CompileOnDemand { get; set; }
+        bool BackGroundCompile { get; set; }
+    }
+}

RetailCoder.VBE/VBERuntime/IVBESettings.cs

@@ -0,0 +1,75 @@
+using System;
+using Microsoft.Win32;
+using Rubberduck.VBEditor.SafeComWrappers.Abstract;
+
+namespace Rubberduck.VBERuntime
+{
+    public class VBESettings : IVBESettings
+    {
+        private const string Vbe7SettingPath = @"HKEY_CURRENT_USER\Software\Microsoft\VBA\7.0\Common";
+        private const string Vbe6SettingPath = @"HKEY_CURRENT_USER\Software\Microsoft\VBA\6.0\Common";
+
+        public enum DllVersion
+        {
+            Unknown,
+            Vbe6,
+            Vbe7
+        }
+
+        private readonly string _registryRootPath;
+
+        public VBESettings(IVBE vbe)
+        {
+            try
+            {
+                switch (Convert.ToInt32(decimal.Parse(vbe.Version)))
+                {
+                    case 6:
+                        Version = DllVersion.Vbe6;
+                        _registryRootPath = Vbe6SettingPath;
+                        break;
+                    case 7:
+                        Version = DllVersion.Vbe7;
+                        _registryRootPath = Vbe7SettingPath;
+                        break;
+                    default:
+                        Version = DllVersion.Unknown;
+                        break;
+                }
+            }
+            catch
+            {
+                Version = DllVersion.Unknown;
+                _registryRootPath = null;
+            }
+        }
+
+        public DllVersion Version { get; }
+
+        public bool CompileOnDemand
+        {
+            get => DWordToBooleanConverter(nameof(CompileOnDemand));
+            set => BooleanToDWordConverter(nameof(CompileOnDemand), value);
+        }
+
+        public bool BackGroundCompile
+        {
+            get => DWordToBooleanConverter(nameof(BackGroundCompile));
+            set => BooleanToDWordConverter(nameof(BackGroundCompile), value);
+        }
+
+        private const int DWordTrueValue = 1;
+        private const int DWordFalseValue = 0;
+
+        private bool DWordToBooleanConverter(string keyName)
+        {
+            var result = Registry.GetValue(_registryRootPath, keyName, DWordFalseValue) as int?;
+            return Convert.ToBoolean(result ?? DWordFalseValue);
+        }
+
+        private void BooleanToDWordConverter(string keyName, bool value)
+        {
+            Registry.SetValue(_registryRootPath, keyName, value ? DWordTrueValue : DWordFalseValue, RegistryValueKind.DWord);
+        }
+    }
+}

RetailCoder.VBE/VBERuntime/VBESettings.cs

@@ -305,6 +305,7 @@
     <Compile Include="UnitTesting\EngineTests.cs" />
     <Compile Include="UnitTesting\DiscoveryTests.cs" />
     <Compile Include="UnitTesting\ViewModelTests.cs" />
+    <Compile Include="VBE\VBESettingsTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="app.config" />

RubberduckTests/RubberduckTests.csproj

@@ -0,0 +1,84 @@
+using NUnit.Framework;
+using Rubberduck.VBERuntime;
+using RubberduckTests.Mocks;
+
+namespace RubberduckTests.VBE
+{
+    [TestFixture]
+    public class VBESettingsTests
+    {
+        [Category("VBE")]
+        [Test]
+        public void DllVersion_MustBe6()
+        {
+            var vbe = new MockVbeBuilder().Build();
+            vbe.SetupGet(s => s.Version).Returns("6.00");
+            var settings = new VBESettings(vbe.Object);
+
+            Assert.IsTrue(settings.Version == VBESettings.DllVersion.Vbe6);
+        }
+
+        [Category("VBE")]
+        [Test]
+        public void DllVersion_MustBe7()
+        {
+            var vbe = new MockVbeBuilder().Build();
+            vbe.SetupGet(s => s.Version).Returns("7.00");
+            var settings = new VBESettings(vbe.Object);
+
+            Assert.IsTrue(settings.Version == VBESettings.DllVersion.Vbe7);
+        }
+        
+        [Category("VBE")]
+        [Test]
+        public void DllVersion_IsBogus()
+        {
+            var vbe = new MockVbeBuilder().Build();
+            vbe.SetupGet(s => s.Version).Returns("foo");
+            var settings = new VBESettings(vbe.Object);
+
+            Assert.IsTrue(settings.Version == VBESettings.DllVersion.Unknown);
+        }
+
+        [Category("VBE")]
+        [Test]
+        public void DllVersion_IsNull()
+        {
+            var vbe = new MockVbeBuilder().Build();
+            vbe.SetupGet(s => s.Version).Returns((string)null);
+            var settings = new VBESettings(vbe.Object);
+
+            Assert.IsTrue(settings.Version == VBESettings.DllVersion.Unknown);
+        }
+
+        [Category("VBE")]
+        [Test]
+        public void CompileOnDemand_WriteRead()
+        {
+            var vbe = new MockVbeBuilder().Build();
+            vbe.SetupGet(s => s.Version).Returns("7.00");
+            var settings = new VBESettings(vbe.Object);
+
+            settings.CompileOnDemand = true;
+            Assert.IsTrue(settings.CompileOnDemand);
+
+            settings.CompileOnDemand = false;
+            Assert.IsTrue(settings.CompileOnDemand == false);
+        }
+
+        [Category("VBE")]
+        [Test]
+        public void BackGroundCompile_WriteRead()
+        {
+            var vbe = new MockVbeBuilder().Build();
+            vbe.SetupGet(s => s.Version).Returns("7.00");
+            var settings = new VBESettings(vbe.Object);
+
+            settings.BackGroundCompile = true;
+            Assert.IsTrue(settings.BackGroundCompile);
+
+            settings.BackGroundCompile = false;
+            Assert.IsTrue(settings.BackGroundCompile == false);
+        }
+    }
+}