public GenerationMenuWidget(Window parent, IElement referer, Bus bus, string busName)
        {
            if (referer.Data != null) {
                MenuItem path = new MenuItem("Call " + referer.Name + "...");
                ObjectPath p = new ObjectPath(referer.Parent.Parent.Path);

                if (!referer.Data.IsProperty) {
                    path.Activated += delegate {
                        MethodInvokeDialog diag = new MethodInvokeDialog (parent, bus, busName, p, referer);

                        while (diag.Run () == (int)ResponseType.None);
                        diag.Destroy();
                    };
                } else {
                    path.Activated += delegate {
                        PropertyInvokeDialog diag = new PropertyInvokeDialog (parent, bus, busName, p, referer);

                        while (diag.Run () == (int)ResponseType.None);
                        diag.Destroy();
                    };
                }

                this.Append(path);
                path.ShowAll();
            }
        }

 public ElementInstancesAddedEventArgs(IElement[] elements)
 {
     if(elements==null)
         _Elements = new IElement[0];
     else
         _Elements = elements;
 }

        public IElement FindFirst(IElement context, LocatorStrategy strategy, string locator)
        {
            AutomationProperty property = this.ToAutomationProperty(strategy);
            AutomationElement element = null;
            switch (strategy)
            {
                case LocatorStrategy.Id:
                case LocatorStrategy.Name:
                case LocatorStrategy.ClassName:
                    element = context.AutomationElement.FindFirst(
                        TreeScope.Descendants,
                        new PropertyCondition(property, locator));
                    break;

                case LocatorStrategy.TagName:
                    ControlType type = this.uiAutomation.FromTagName(locator);
                    element = context.AutomationElement.FindFirst(
                        TreeScope.Descendants,
                        new PropertyCondition(property, type));
                    break;

                case LocatorStrategy.XPath:
                    element = this.uiAutomation.FindFirstByXPath(context.AutomationElement, locator);
                    break;

                default:
                    throw new FailedCommandException(
                        string.Format("Usupported locator startegy: {0}", strategy.ToString()),
                        32); // InvalidSelector (32)
            }

            return element == null ? null : this.elementFactory.GetElement(element);
        }

		public ITextPatternRange RangeFromChild (IElement childElement)
		{
			Element child = childElement as Element;
			if (child == null || child.Parent != this)
				throw new InvalidOperationException ();
			return new TextRangePattern (accessible);
		}

        public static string GetSharedCodeFullFileName(IElement container, string baseProjectDirectory)
        {

            string fileName = GetEventFileNameForElement(container);
            return baseProjectDirectory + fileName;
        
        }

        protected override bool CheckElement(IElement element)
        {
            if (!NHProjectFileLanguageService.IsNHFile(element.GetProjectFile()))
                return false;

            return base.CheckElement(element);
        }

 String IMarkupFormatter.CloseTag(IElement element, Boolean selfClosing)
 {
     var prefix = element.Prefix;
     var name = element.LocalName;
     var tag = !String.IsNullOrEmpty(prefix) ? prefix + ":" + name : name;
     return (selfClosing || !element.HasChildNodes) ? String.Empty : String.Concat("</", tag, ">");
 }

        public override ICodeBlock GenerateAdditionalMethods(ICodeBlock codeBlock, IElement element)
        {
            EntitySave entitySave = element as EntitySave;

            if (entitySave == null || (!entitySave.ImplementsIClickable && !entitySave.ImplementsIWindow))
            {
                return codeBlock;
            }


            if (entitySave.ImplementsIWindow)
            {
                bool inheritsFromIWindow = entitySave.GetInheritsFromIWindow();

                // Add all the code that never changes if this is the base IWindow (doesn't have a parent IWindow)
                if (!inheritsFromIWindow)
                {
                    GenerateEnabledVariable(codeBlock, element);      
                }
            }

            IWindowCodeGenerator.WriteCodeForHasCursorOver(
                entitySave, codeBlock, entitySave.GetInheritsFromIWindowOrIClickable());

            var isVirtual = string.IsNullOrEmpty(entitySave.BaseEntity) || entitySave.GetInheritsFromIWindowOrIClickable() == false;

            codeBlock
                .Function("WasClickedThisFrame", "FlatRedBall.Gui.Cursor cursor", Public: true, Virtual: isVirtual, Override: !isVirtual, Type: "bool")
                .Line("return cursor.PrimaryClick && HasCursorOver(cursor);")
                .End();

            return codeBlock;
        }

 /// <summary>
 /// Initializes a new instance of the DummyInputNetworkPort class, This class maintains the dataObj
 /// as a member, does NOT use the backingStore of the pipe.
 /// </summary>
 /// <param name="parent"></param>
 /// <param name="inPipe"></param>
 /// <param name="dataObj"></param>
 /// <param name="isValid"></param>
 public DummyInputNetworkPort(IElement parent, INetworkPipe inPipe, INetwork dataObj, bool isValid)
 {
     _parent = parent;
     _inPipe = inPipe;
     _netObj = dataObj;
     _IsValid = isValid;
 }

        private void GenerateInitializeLevel(ICodeBlock codeBlock, IElement element)
        {
            #region /////////////////////////////////Early out////////////////////////////////
            bool shouldGenerate = GetIfShouldGenerate(element);

            if (!shouldGenerate)
            {
                return;
            }

            ///////////////////////////////End early out/////////////////////////////
            #endregion


            codeBlock.Line("FlatRedBall.TileGraphics.LayeredTileMap CurrentTileMap;");
            var function = codeBlock.Function("void", "InitializeLevel", "string levelName");

            GenerateInitializeLevelObjects(function);

            GenerateInitializeCamera(function);

            GenerateAddCollisionAndEntities(function);

            GenerateInitializeAnimations(function);
        }

 public OutputNeutralPort(Guid id, IElement parent)
 {
     Id = id;
     _pipes = new List<INeutralPipe>();
     ParentElement = parent;
     Index = -1;
 }

        private static void TryToRemoveInvalidState(this GlueProjectSave glueProjectSave, bool showPopupsOnFixedErrors, IElement containingElement, NamedObjectSave nos)
        {
            if (nos.SourceType == SourceType.Entity && !string.IsNullOrEmpty(nos.SourceClassType) && !string.IsNullOrEmpty(nos.CurrentState))
            {
                EntitySave foundEntitySave = glueProjectSave.GetEntitySave(nos.SourceClassType);

                if (foundEntitySave != null)
                {
                    bool hasFoundState = false;

                    hasFoundState = foundEntitySave.GetStateRecursively(nos.CurrentState) != null;

                    if (!hasFoundState)
                    {
                        if (showPopupsOnFixedErrors)
                        {
                            MessageBox.Show("The Object " + nos.InstanceName + " in " + containingElement.Name + " uses the invalid state " + nos.CurrentState +
                                "\nRemoving this current State");
                        }

                        nos.CurrentState = null;

                    }
                }
            }
        }

 public override bool Apply(IElement element)
 {
     if (element == null)
         return false;
     return element.ElementType == LanguageElementType.For 
         || element.ElementType == LanguageElementType.ForEach;
 }

        /// <summary>Executes the specified solution.</summary>
        /// <param name="element">The element.</param>
        protected override void Execute(IElement element)
        {
            var node = element.ToTreeNode();
              if (node == null)
              {
            return;
              }

              IInvocationExpression invocationExpression = null;

              while (node != null)
              {
            invocationExpression = node as IInvocationExpression;

            if (invocationExpression != null)
            {
              break;
            }

            node = node.Parent;
              }

              if (invocationExpression == null)
              {
            return;
              }

              Execute(invocationExpression);
        }

 public void addNewTab(String name, IElement element)
 {
     Label tablabel = new Label(name);
     this.AppendPage((Widget)element,tablabel);
     this.ShowAll();
     TabCount++;
 }

        /// <summary>
        /// Computes the declarations for the given element in the context of
        /// the specified styling rules.
        /// </summary>
        /// <param name="rules">The styles to use.</param>
        /// <param name="element">The element that is questioned.</param>
        /// <param name="pseudoSelector">The optional pseudo selector to use.</param>
        /// <returns>The style declaration containing all the declarations.</returns>
        public static CssStyleDeclaration ComputeDeclarations(this StyleCollection rules, IElement element, String pseudoSelector = null)
        {
            var computedStyle = new CssStyleDeclaration();
            var pseudoElement = PseudoElement.Create(element, pseudoSelector);

            if (pseudoElement != null)
            {
                element = pseudoElement;
            }

            computedStyle.SetDeclarations(rules.ComputeCascadedStyle(element).Declarations);
            var htmlElement = element as IHtmlElement;

            if (htmlElement != null)
            {
                var declarations = htmlElement.Style.OfType<CssProperty>();
                computedStyle.SetDeclarations(declarations);
            }

            var nodes = element.GetAncestors().OfType<IElement>();

            foreach (var node in nodes)
            {
                var style = rules.ComputeCascadedStyle(node);
                computedStyle.UpdateDeclarations(style.Declarations);
            }

            return computedStyle;
        }

 public void ReactToChange(string changedMember, object oldValue, EventResponseSave ers, IElement container)
 {
     if (changedMember == "EventName")
     {
         ReactToEventRename(oldValue, ers, container);
     }
 }

		// TODO: Rename to GetAutomationElements
		internal static AutomationElement [] GetOrCreateAutomationElements (IElement [] sourceElements)
		{
			AutomationElement [] ret = new AutomationElement [sourceElements.Length];
			for (int i = 0; i < sourceElements.Length; i++)
				ret [i] = GetOrCreateAutomationElement (sourceElements [i]);
			return ret;
		}

        protected override bool CheckResolve(IReference reference, IElement element)
        {
            if (reference is TableReference && !DatabaseManager.GetInstance(element.GetManager().Solution).Enabled)
                return false;

            return base.CheckResolve(reference, element);
        }

        public override Boolean Match(IElement element)
        {
            var parent = element.ParentElement;

            if (parent != null)
            {
                var n = Math.Sign(_step);
                var k = 0;

                for (var i = parent.ChildNodes.Length - 1; i >= 0; i--)
                {
                    var child = parent.ChildNodes[i] as IElement;

                    if (child != null && child.NodeName.Is(element.NodeName))
                    {
                        k += 1;

                        if (child == element)
                        {
                            var diff = k - _offset;
                            return diff == 0 || (Math.Sign(diff) == n && diff % _step == 0);
                        }
                    }
                }
            }

            return false;
        }