예제 #1
0
 internal void CheckEmacsVskSelected()
 {
     try
     {
         if (!IsEmacsVskInstalled)
         {
             return;
         }
         ILocalRegistry2 service   = ServiceProvider.GetService <SLocalRegistry, ILocalRegistry2>();
         var             pbstrRoot = (string)null;
         service.GetLocalRegistryRoot(out pbstrRoot);
         using (RegistryKey registryKey1 = Registry.CurrentUser.OpenSubKey(pbstrRoot))
         {
             if (registryKey1 == null)
             {
                 return;
             }
             using (RegistryKey registryKey2 = registryKey1.OpenSubKey("Keyboard"))
             {
                 if (registryKey2 == null)
                 {
                     return;
                 }
                 var path = registryKey2.GetValue("SchemeName") as string;
                 IsEnabled = !string.IsNullOrEmpty(path) &&
                             string.Equals("VsEmacs.vsk", Path.GetFileName(path),
                                           StringComparison.InvariantCultureIgnoreCase);
             }
         }
     }
     catch
     {
         IsEnabled = false;
     }
 }
예제 #2
0
        /// <summary>
        /// Returns a RegistryKey object for the root of a given storage type.
        /// It is up to the caller to dispose the returned object.
        /// </summary>
        /// <param name="provider">The service provider to use to access the Visual Studio's services.</param>
        /// <param name="registryType">The type of registry storage to open.</param>
        /// <param name="writable">Flag to indicate is the key should be writable.</param>
        public static RegistryKey RegistryRoot(IServiceProvider provider, __VsLocalRegistryType registryType, bool writable)
        {
            if (null == provider)
            {
                throw new ArgumentNullException("provider");
            }

            // The current implementation of the shell supports only RegType_UserSettings and
            // RegType_Configuration, so for any other values we have to return not implemented.
            if ((__VsLocalRegistryType.RegType_UserSettings != registryType) &&
                (__VsLocalRegistryType.RegType_Configuration != registryType))
            {
                throw new NotSupportedException();
            }

            // Try to get the new ILocalRegistry4 interface that is able to handle the new
            // registry paths.
            ILocalRegistry4 localRegistry = provider.GetService(typeof(SLocalRegistry)) as ILocalRegistry4;

            if (null != localRegistry)
            {
                uint   rootHandle;
                string rootPath;
                if (ErrorHandler.Succeeded(localRegistry.GetLocalRegistryRootEx((uint)registryType, out rootHandle, out rootPath)))
                {
                    // Check if we have valid data.
                    __VsLocalRegistryRootHandle handle = (__VsLocalRegistryRootHandle)rootHandle;
                    if (!string.IsNullOrEmpty(rootPath) && (__VsLocalRegistryRootHandle.RegHandle_Invalid != handle))
                    {
                        // Check if the root is inside HKLM or HKCU. Note that this does not depends only from
                        // the registry type, but also from instance-specific data like the RANU flag.
                        RegistryKey root = (__VsLocalRegistryRootHandle.RegHandle_LocalMachine == handle) ? Registry.LocalMachine : Registry.CurrentUser;
                        return(root.OpenSubKey(rootPath, writable));
                    }
                }
            }

            // We are here if the usage of the new interface failed for same reason, so we have to fall back to
            // the ond way to access the registry.
            ILocalRegistry2 oldRegistry = provider.GetService(typeof(SLocalRegistry)) as ILocalRegistry2;

            if (null == oldRegistry)
            {
                // There is something wrong with this installation or this service provider.
                return(null);
            }
            string registryPath;

            NativeMethods.ThrowOnFailure(oldRegistry.GetLocalRegistryRoot(out registryPath));
            if (string.IsNullOrEmpty(registryPath))
            {
                return(null);
            }

            RegistryKey regRoot = (__VsLocalRegistryType.RegType_Configuration == registryType) ? Registry.LocalMachine : Registry.CurrentUser;

            return(regRoot.OpenSubKey(registryPath, writable));
        }
예제 #3
0
        private void EnsureContexts()
        {
            ThreadHelper.ThrowIfNotOnUIThread();

            if (_otherSccProviderContexts == null)
            {
                List <SccData> sccs = new List <SccData>();

                ILocalRegistry2 lr = GetService <ILocalRegistry2>(typeof(SLocalRegistry));

                string        root;
                List <string> names = new List <string>();
                if (VSErr.Succeeded(lr.GetLocalRegistryRoot(out root)))
                {
                    RegistryKey baseKey = Registry.LocalMachine;

                    // TODO: Find some way to use the VS2008 RANU api
                    if (root.EndsWith("\\UserSettings"))
                    {
                        root    = root.Substring(0, root.Length - 13) + "\\Configuration";
                        baseKey = Registry.CurrentUser;
                    }

                    using (RegistryKey rk = baseKey.OpenSubKey(root + "\\SourceControlProviders", RegistryKeyPermissionCheck.ReadSubTree))
                    {
                        if (rk != null)
                        {
                            string myId = AnkhId.SccProviderGuid.ToString("B");
                            foreach (string name in rk.GetSubKeyNames())
                            {
                                if (name.Length == 38 && !myId.Equals(name, StringComparison.OrdinalIgnoreCase))
                                {
                                    try
                                    {
                                        using (RegistryKey rks = rk.OpenSubKey(name, RegistryKeyPermissionCheck.ReadSubTree))
                                        {
                                            string service = rks.GetValue("Service") as string;

                                            if (!string.IsNullOrEmpty(service))
                                            {
                                                Guid sccGuid            = new Guid(name);
                                                CmdStateCacheItem cache = GetCache(new Guid(name));

                                                sccs.Add(new SccData(cache, service));
                                            }
                                        }
                                    }
                                    catch { }
                                }
                            }
                        }
                    }
                }

                _otherSccProviderContexts = sccs.ToArray();
            }
        }
예제 #4
0
        private string GetVsInstallPath()
        {
            ILocalRegistry2 service   = ServiceProvider.GetService <SLocalRegistry, ILocalRegistry2>();
            var             pbstrRoot = (string)null;

            service.GetLocalRegistryRoot(out pbstrRoot);
            using (RegistryKey registryKey = Registry.LocalMachine.OpenSubKey(pbstrRoot))
                return(Path.GetDirectoryName(registryKey.GetValue("InstallDir") as string));
        }
예제 #5
0
        protected override void SetOutputLogger(IVsOutputWindowPane output)
        {
            if (BuildLogger == null)
            {
                // Need to get the outer IVsHierarchy because may be aggregated.

                System.IntPtr unknown   = System.IntPtr.Zero;
                IVsHierarchy  hierarchy = null;
                try
                {
                    unknown   = Marshal.GetIUnknownForObject(this);
                    hierarchy = Marshal.GetTypedObjectForIUnknown(unknown, typeof(IVsHierarchy)) as IVsHierarchy;
                }
                finally
                {
                    if (unknown != System.IntPtr.Zero)
                    {
                        Marshal.Release(unknown);
                    }
                }

                // Create the logger.

                BuildLogger = new VsLogger(output, TaskProvider, hierarchy);

                // To retrive the verbosity level the logger depends on the registry root.

                ILocalRegistry2 registry = GetService(typeof(SLocalRegistry)) as ILocalRegistry2;
                if (registry != null)
                {
                    string registryRoot;
                    registry.GetLocalRegistryRoot(out registryRoot);
                    VsLogger logger = BuildLogger as VsLogger;
                    if (!string.IsNullOrEmpty(registryRoot) && logger != null)
                    {
                        logger.VerbosityRegistryRoot = registryRoot;
                        logger.ErrorString           = ErrorString;
                        logger.WarningString         = WarningString;
                    }
                }
            }
            else
            {
                ((VsLogger)BuildLogger).OutputWindowPane = output;
            }

            if (BuildEngine != null)
            {
                BuildEngine.UnregisterAllLoggers();
                BuildEngine.RegisterLogger(BuildLogger);
            }
        }
예제 #6
0
        static public String GetLocalRegistryRoot()
        {
            // Get the visual studio root key
            if (VsRoot == null)
            {
                ILocalRegistry2 localReg = GetService(typeof(ILocalRegistry)) as ILocalRegistry2;
                if (localReg != null)
                {
                    localReg.GetLocalRegistryRoot(out VsRoot);
                }

                if (VsRoot == null)
                {
                    VsRoot = @"Software\Microsoft\VisualStudio\10.0";                     // Guess on failure
                }
            }
            return(VsRoot);
        }
예제 #7
0
        static public String GetLocalRegistryRoot()
        {
            // Get the visual studio root key
            string          vsRoot   = null;
            ILocalRegistry2 localReg = GetService(typeof(ILocalRegistry)) as ILocalRegistry2;

            if (localReg != null)
            {
                localReg.GetLocalRegistryRoot(out vsRoot);
                if (vsRoot != null)
                {
                    return(vsRoot);
                }
            }
#if DEV10
            return(@"Software\Microsoft\VisualStudio\10.0"); // Guess on failure
#else
            return(@"Software\Microsoft\VisualStudio\9.0");  // Guess on failure
#endif
        }