protected ScrollBar(AutomationElement automationElement, ActionListener actionListener, ScrollBarButtonAutomationIds automationIds)
     : base(automationElement, actionListener)
 {
     this.automationIds = automationIds;
     var finder = new AutomationElementFinder(automationElement);
     primaryUIItemFactory = new PrimaryUIItemFactory(finder);
 }

 private ToolTip GetToolTip(UIItem uiItem, ActionListener actionListener)
 {
     mouse.Click(uiItem.Bounds.Center());
     actionListener.ActionPerformed(Action.WindowMessage);
     Thread.Sleep(CoreAppXmlConfiguration.Instance.TooltipWaitTime);
     return ToolTip.GetFrom(uiItem.Bounds.Center());
 }

 public void addActionListener(ActionListener actionListener)
 {
     lock (actionListeners)
     {
         actionListeners.Add(actionListener);
     }
 }

 private IUIItem Create(ContainerItemFactory containerItemFactory, SearchCriteria searchCriteria, ActionListener actionListener)
 {
     IUIItem item = containerItemFactory.Get(searchCriteria, actionListener);
     if (item == null) return null;
     windowItemsMap.Add(item.Location, searchCriteria);
     return item;
 }

 public UIItem(AutomationElement automationElement, ActionListener actionListener)
 {
     if (null == automationElement) throw new NullReferenceException();
     this.automationElement = automationElement;
     this.actionListener = actionListener;
     factory = new PrimaryUIItemFactory(new AutomationElementFinder(automationElement));
 }

 public ScrollBars(AutomationElement automationElement, ActionListener actionListener,
     ScrollBarButtonAutomationIds hScrollBarButtonAutomationIds, ScrollBarButtonAutomationIds vScrollBarButtonAutomationIds) {
     this.actionListener = actionListener;
     this.hScrollBarButtonAutomationIds = hScrollBarButtonAutomationIds;
     this.vScrollBarButtonAutomationIds = vScrollBarButtonAutomationIds;
     finder = new AutomationElementFinder(automationElement);
 }

        private static SuggestionList WaitTill(ActionListener actionListener, string failureMessage, Clock.Matched matched)
        {
            Clock.Do getSuggestionList = () => Find(actionListener);
            Clock.Expired onExpiration = delegate { throw new UIActionException(failureMessage + Constants.BusyMessage); };

            return
                (SuggestionList) new Clock(CoreAppXmlConfiguration.Instance.SuggestionListTimeout).Perform(getSuggestionList, matched, onExpiration);
        }

 internal static IScrollBars CreateBars(AutomationElement parentElement, ActionListener listener)
 {
     var frameworkId = parentElement.Current.FrameworkId;
     if (frameworkId == Constants.WPFFrameworkId)
         return new WPFScrollBars(parentElement, listener);
     if (frameworkId == Constants.SilverlightFrameworkId)
         return new ScrollBars(parentElement, listener, new SilverlightHScrollBarButtonAutomationIds(), new SilverlightVScrollBarButtonAutomationIds());
     return new ScrollBars(parentElement, listener, new DefaultScrollBarButtonAutomationIds(), new DefaultScrollBarButtonAutomationIds());
 }

 public virtual IUIItem Get(SearchCriteria searchCriteria, ActionListener uiItemActionListener)
 {
     IUIItem item = Find(searchCriteria);
     if (item == null || item is UIItemContainer)
     {
         //Cannot create dynamic proxy for class which has methods using generics. Also its not required to intercept methods on UIItem containers
         return item;
     }
     return UIItemProxyFactory.Create(item, uiItemActionListener);
 }

 public virtual IUIItem Create(SearchCriteria searchCriteria, ActionListener actionListener)
 {
     if (searchCriteria.IsIndexed)
     {
         UIItemCollection collection = CreateAll(searchCriteria, actionListener);
         return searchCriteria.IndexedItem(collection);
     }
     return dictionaryMappedItemFactory.Create(Finder.Descendant(searchCriteria.AutomationCondition), actionListener,
                                               searchCriteria.CustomItemType);
 }

 public TableScrollBars(AutomationElementFinder finder, ActionListener actionListener, TableVerticalScrollOffset tableVerticalScrollOffset)
 {
     AutomationElement verticalScrollElement = finder.Child(AutomationSearchCondition.ByControlType(ControlType.Pane).OfName(UIItemIdAppXmlConfiguration.Instance.TableVerticalScrollBar));
     verticalScrollBar = (verticalScrollElement == null)
                             ? (IVScrollBar) new NullVScrollBar()
                             : new TableVerticalScrollBar(verticalScrollElement, actionListener, tableVerticalScrollOffset);
     AutomationElement horizontalScrollElement = finder.Child(AutomationSearchCondition.ByControlType(ControlType.Pane).OfName(UIItemIdAppXmlConfiguration.Instance.TableHorizontalScrollBar));
     horizontalScrollBar = (horizontalScrollElement == null)
                               ? (IHScrollBar) new NullHScrollBar()
                               : new TableHorizontalScrollBar(horizontalScrollElement, actionListener);
 }

 private bool TryGetPopupMenu(AutomationSearchCondition[] searchConditions, ActionListener actionListener, out PopUpMenu popUpMenu)
 {
     var element = Retry.For(() => Finder.Child(searchConditions), CoreAppXmlConfiguration.Instance.PopupTimeout(), TimeSpan.FromMilliseconds(100));
     if (element == null)
     {
         popUpMenu = null;
         return false;
     }
     popUpMenu = new PopUpMenu(element, actionListener);
     return true;
 }

 public virtual PopUpMenu WPFPopupMenu(ActionListener actionListener)
 {
     var searchConditions = new[]
                                {
                                    AutomationSearchCondition.ByControlType(ControlType.Window),
                                    AutomationSearchCondition.ByControlType(ControlType.Menu)
                                };
     PopUpMenu popUpMenu;
     TryGetPopupMenu(searchConditions, actionListener, out popUpMenu);
     return popUpMenu;
 }

 private static SuggestionList WaitTill(ActionListener actionListener, string failureMessage, Predicate<SuggestionList> shouldRetry)
 {
     try
     {
         return Retry.For(() => Find(actionListener), shouldRetry, CoreAppXmlConfiguration.Instance.SuggestionListTimeout);
     }
     catch (Exception ex)
     {
         throw new UIActionException(failureMessage + Constants.BusyMessage, ex);
     }
 }

        private static SuggestionList Find(ActionListener actionListener)
        {
            AutomationElement dropDown =
                new AutomationElementFinder(AutomationElement.RootElement).Child(AutomationSearchCondition.ByClassName("Auto-Suggest Dropdown"));
            if (dropDown == null) return null;

            AutomationElement listViewElement =
                new AutomationElementFinder(dropDown).Child(AutomationSearchCondition.ByControlType(ControlType.DataGrid));
            if (listViewElement == null) return null;
            return new ListView(listViewElement, actionListener);
        }

 public virtual void DoubleClickOutsideToolTip(UIItem uiItem, ActionListener actionListener)
 {
     actionListener.ActionPerforming(uiItem);
     ToolTip toolTip = GetToolTip(uiItem, actionListener);
     if (toolTip == null)
         mouse.DoubleClick(uiItem.Bounds.Center(), actionListener);
     else
     {
         WhiteLogger.Instance.Debug("Found tooltip DoubleClicking outside tooltip bounds");
         mouse.DoubleClick(toolTip.LeftOutside(uiItem.Bounds), actionListener);
     }
 }

        public virtual UIItemCollection ItemsWithin(Rect bounds, ActionListener actionListener)
        {
            var collection = new UIItemCollection();
            List<AutomationElement> descendants = Finder.Descendants(AutomationSearchCondition.All);
            foreach (AutomationElement automationElement in descendants)
            {
                if (!bounds.Contains(automationElement.Current.BoundingRectangle)) continue;

                var factory = new DictionaryMappedItemFactory();
                collection.Add(factory.Create(automationElement, actionListener));
            }
            return collection;
        }

 public virtual void RightClickOutsideToolTip(UIItem uiItem, ActionListener actionListener)
 {
     actionListener.ActionPerforming(uiItem);
     ToolTip toolTip = GetToolTip(uiItem, actionListener);
     if (toolTip == null)
     {
         //Because mouse has already been moved
         mouse.RightClickHere(actionListener);
     }
     else
     {
         WhiteLogger.Instance.Debug("Found tooltip RightClicking outside tooltip bounds");
         mouse.RightClick(toolTip.LeftOutside(uiItem.Bounds), actionListener);
     }
 }

    /*public Player owner {
        get {
            if(mFlockUnit != null) {
                int index = Player.GroupToIndex(mFlockUnit.type);
                if(index >= 0 && index < Player.playerCount) {
                    return Player.GetPlayer(index);
                }
            }

            return null;
        }
    }*/
    protected override void Awake()
    {
        base.Awake();

        mFlockUnit = GetComponentInChildren<FlockUnit>();
        mListener = GetComponentInChildren<ActionListener>();

        if(mFlockUnit != null) {
            mFlockUnit.groupMoveEnabled = false;
        }

        if(mListener != null) {
            mListener.enterCallback += OnActionEnter;
            mListener.hitEnterCallback += OnActionHitEnter;
            mListener.hitExitCallback += OnActionHitExit;
            mListener.finishCallback += OnActionFinish;
        }
    }

        public virtual IUIItem Get(ContainerItemFactory containerItemFactory, SearchCriteria searchCriteria, ActionListener actionListener)
        {
            logger.DebugFormat("Finding item based on criteria: ({0}) on ({1})", searchCriteria, initializeOption.Identifier);
            Point location = windowItemsMap.GetItemLocation(searchCriteria);
            if (location.Equals(RectX.UnlikelyWindowPosition))
            {
                logger.Debug("[PositionBasedSearch] Could not find based on position, finding using search.");
                return Create(containerItemFactory, searchCriteria, actionListener);
            }

            AutomationElement automationElement = AutomationElementX.GetAutomationElementFromPoint(location);
            if (automationElement != null && searchCriteria.AppliesTo(automationElement))
            {
                IUIItem item = new DictionaryMappedItemFactory().Create(automationElement, actionListener, searchCriteria.CustomItemType);
                return UIItemProxyFactory.Create(item, actionListener);
            }

            logger.DebugFormat("[PositionBasedSearch] UIItem {0} changed its position, finding using search.", searchCriteria);
            return Create(containerItemFactory, searchCriteria, actionListener);
        }