internal void ActivateAddinExtensions(string id)
        {
            // Looks for loaded extension points which are extended by the provided
            // add-in, and adds the new nodes

            try {
                fireEvents = true;

                Addin addin = AddinManager.Registry.GetAddin(id);
                if (addin == null)
                {
                    AddinManager.ReportError("Required add-in not found", id, null, false);
                    return;
                }
                // Take note that his add-in has been enabled at run-time
                // Needed because loaded add-in descriptions may not include this add-in.
                RegisterRuntimeEnabledAddin(id);

                // Look for loaded extension points
                Hashtable eps = new Hashtable();
                foreach (ModuleDescription mod in addin.Description.AllModules)
                {
                    foreach (Extension ext in mod.Extensions)
                    {
                        ExtensionPoint ep = tree.FindLoadedExtensionPoint(ext.Path);
                        if (ep != null && !eps.Contains(ep))
                        {
                            eps.Add(ep, ep);
                        }
                    }
                }

                // Add the new nodes
                ArrayList loadedNodes = new ArrayList();
                foreach (ExtensionPoint ep in eps.Keys)
                {
                    ExtensionLoadData data = GetAddinExtensions(id, ep);
                    if (data != null)
                    {
                        foreach (Extension ext in data.Extensions)
                        {
                            TreeNode node = GetNode(ext.Path);
                            if (node != null && node.ExtensionNodeSet != null)
                            {
                                if (node.ChildrenLoaded)
                                {
                                    LoadModuleExtensionNodes(ext, data.AddinId, node.ExtensionNodeSet, loadedNodes);
                                }
                            }
                            else
                            {
                                AddinManager.ReportError("Extension node not found or not extensible: " + ext.Path, id, null, false);
                            }
                        }

                        // Global extension change event. Other events are fired by LoadModuleExtensionNodes.
                        NotifyExtensionsChanged(new ExtensionEventArgs(ep.Path));
                    }
                }

                // Call the OnAddinLoaded method on nodes, if the add-in is already loaded
                foreach (TreeNode nod in loadedNodes)
                {
                    nod.ExtensionNode.OnAddinLoaded();
                }
            }
            finally {
                fireEvents = false;
            }
            // Do the same in child contexts

            lock (conditionTypes) {
                if (childContexts != null)
                {
                    foreach (WeakReference wref in childContexts)
                    {
                        ExtensionContext ctx = wref.Target as ExtensionContext;
                        if (ctx != null)
                        {
                            ctx.ActivateAddinExtensions(id);
                        }
                    }
                }
            }
        }