void Ui::_updateHovered( const Point& mousePos )
{
  WidgetPtr lastHovered = _d->hovered.current;
  WidgetPtr lastHoveredNoSubelement = _d->hovered.noSubelement;
  _d->hovered.lastMousePos = mousePos;

  // Get the real Hovered
  _d->hovered.current = rootWidget()->getElementFromPoint( mousePos );

  if( _d->tooltip.element.isValid() && _d->hovered.current == _d->tooltip.element )
  {
    // When the mouse is over the ToolTip we remove that so it will be re-created at a new position.
    // Note that ToolTip.EnterTime does not get changed here, so it will be re-created at once.
    _d->tooltip.element->deleteLater();
    _d->tooltip.element->hide();
    _d->tooltip.element = WidgetPtr();
    _d->hovered.current = rootWidget()->getElementFromPoint( mousePos );
  }

  // for tooltips we want the element itself and not some of it's subelements
  if( _d->hovered.current != rootWidget() )
  {
    _d->hovered.noSubelement = _d->hovered.current;
    while ( _d->hovered.noSubelement.isValid() && _d->hovered.noSubelement->isSubElement() )
    {
      _d->hovered.noSubelement = _d->hovered.noSubelement->parent();
    }
  }
  else
  {
    _d->hovered.noSubelement = 0;
  }

  if( _d->hovered.current != lastHovered )
  {
    if( lastHovered.isValid() )
    {
      lastHovered->onEvent( NEvent::Gui( lastHovered.object(), 0, guiElementLeft ) );
    }

    if( _d->hovered.current.isValid() )
    {
      _d->hovered.current->onEvent( NEvent::Gui( _d->hovered.current.object(), _d->hovered.current.object(), guiElementHovered ) );
    }
  }

  if ( lastHoveredNoSubelement != _d->hovered.noSubelement )
  {
    if( _d->tooltip.element.isValid() )
    {
      _d->tooltip.element->deleteLater();
      _d->tooltip.element = WidgetPtr();
    }

    if( _d->hovered.noSubelement.isValid() )
    {
      _d->tooltip.enterTime = DateTime::elapsedTime();
    }
  }
}

	void BasicContainer::ShowWidgetPart( WidgetPtr widget, Rectangle area )
	{
        Rectangle widgetArea = getChildrenArea();

        area.x += widget->GetX();
        area.y += widget->GetY();
        
        if (area.x + area.width > widgetArea.width)
        {
            widget->SetX(widget->GetX() - area.x - area.width + widgetArea.width);
        }

        if (area.y + area.height > widgetArea.height)
        {
            widget->SetY(widget->GetY() - area.y - area.height + widgetArea.height);
        }

        if (area.x < 0)
        {
            widget->SetX(widget->GetX() - area.x);
        }

        if (area.y < 0)
        {
            widget->SetY(widget->GetY() - area.y);
        }
    }

	void ItemBox::_redrawAllVisible()
	{

		int count = mCountLineVisible * mCountItemInLine + mTopIndex;
		size_t iwid = 0; // индекс виджета
		for (int pos = mTopIndex; pos<count; ++pos, ++iwid) {
			// дальше нет айтемов
			if (pos >= mCountItems) break;

			WidgetPtr widget = getItemWidget(iwid);

			widget->show();
			redrawItem(widget, (size_t)pos);

		}

		// все виджеты еще есть, то их надо бы скрыть
		while (iwid < mVectorItems.size()) {
			mVectorItems[iwid]->hide();
			iwid ++;
		}

		//MYGUI_OUT(mVectorItems.size());

	}

	bool ControllerFadeAlpha::addTime(WidgetPtr _widget, float _time)
	{
		float alpha = _widget->getAlpha();

		// проверяем нужно ли к чему еще стремиться
		if (mAlpha > alpha) {
			alpha += _time * mCoef;
			if (mAlpha > alpha) {
				_widget->setAlpha(alpha);
				eventUpdateAction(_widget);
				return true;
			}
			else {
				_widget->setAlpha(mAlpha);
			}
		}
		else if (mAlpha < alpha) {
			alpha -= _time * mCoef;
			if (mAlpha < alpha) {
				_widget->setAlpha(alpha);
				eventUpdateAction(_widget);
				return true;
			}
			else {
				_widget->setAlpha(mAlpha);
			}
		}

		// вызываем пользовательский делегат пост обработки
		eventPostAction(_widget);

		return false;
	}

	void Stack::AddChild( WidgetPtr child )
	{
		int x = 0;
		int y = 0;
		if (mWidgets.size() > 0)
		{
			WidgetPtr last = mWidgets.back();
			if (mOrientation == OrientationVertical)
			{
				y = last->GetY() + last->GetHeight() + mSpacing;
			}
			else
			{
				x = last->GetX() + last->GetWidth() + mSpacing;
			}
		}
		child->SetPosition(x, y);

		BasicContainer::Add(child);

		if (mOrientation == OrientationVertical)
		{
			SetSize(std::max(GetWidth(), child->GetWidth()), y + child->GetHeight());
		}
		else
		{
			SetSize(x + child->GetWidth(), std::max(GetHeight(), child->GetHeight()));
		}
	}

	// поправить на виджет и проверять на рутовость
	void LayerManager::attachToLayerKeeper(const std::string& _name, WidgetPtr _item)
	{
		MYGUI_ASSERT(_item->isRootWidget(), "attached widget must be root");

		// сначала отсоединяем
		detachFromLayerKeeper(_item);

		// а теперь аттачим
		for (VectorLayerKeeper::iterator iter=mLayerKeepers.begin(); iter!=mLayerKeepers.end(); ++iter) {
			if (_name == (*iter)->getName()) {

				// запоминаем в рутовом виджете хранитель лееров
				_item->mLayerKeeper = (*iter);

				// достаем из хранителя леер для себя
				_item->mLayerItemKeeper = (*iter)->getItem();

				// подписываемся на пиккинг
				_item->mLayerItemKeeper->_addPeekItem(_item);

				// физически подсоединяем иерархию
				_item->_attachToLayerItemKeeper(_item->mLayerItemKeeper);

				return;
			}
		}
		MYGUI_EXCEPT("Layer '" << _name << "' is not found");
	}

    void WidgetRender::Render(ContainerWidget* w)
    {
        m_render->PushSate();
        if (w->GetBackColor().a > 0.0f)
        {
            m_render->SetColor(w->GetBackColor());
            m_render->SetAlpha(w->GetBackColor().a);
            if (w->GetStyle()->IsEnabledTextures())
            {
                m_render->SetTexture(w->GetBackTexture());
                m_render->DrawTexturedQuad(w->GetLocalX(), w->GetLocalY(), w->GetWidth(), w->GetHeight());
            }
            else
            {
                m_render->DrawQuad(w->GetLocalX(), w->GetLocalY(), w->GetWidth(), w->GetHeight());
            }
        }

        m_render->Translate(w->GetLocalX(), w->GetLocalY());
        for (ContainerWidget::ChildrenCollection::iterator it = w->GetChildren().begin(); it != w->GetChildren().end(); ++it)
        {
            WidgetPtr child = (*it).second;
            child->Repaint(this);
        }
        m_render->PopState();
    }

bool Widget::dispatchTouchEvent(TouchEvent &event)
{
    auto curr = event.getCurrPoint();

    bool handled = false;

    // 靠前的控件先接受事件
    int size = getNode()->getChildren().size();
    for (int i = size - 1; i >= 0; --i) {
        auto child = getNode()->getChildren()[i];

        WidgetPtr childWidget = child->getComponent<Widget>();

        if (!childWidget) {
            continue;
        }

        Vec2 p = childWidget->getComponent<Transform2D>()->convertParentToLocalSpace(curr);
        event.setCurrPoint(p);

        // 有控件处理了事件就阻止传递
        if (childWidget->onTouchEvent(event)) {
            handled = true;

            break;
        }
    }

    return handled;
}

void ContainerWidget::addChild(const WidgetPtr& child)
{
	auto oldParent = child->getParent();
	if(oldParent)
		oldParent->removeChild(child);
		
	children.push_back(child);
	child->setParent(sharedFromThis());
}

	// преобразует точку на виджете в глобальную позицию
	IntPoint WidgetManager::convertToGlobal(const IntPoint& _point, WidgetPtr _widget)
	{
		IntPoint ret = _point;
		WidgetPtr wid = _widget;
		while (wid != null) {
			ret += wid->getPosition();
			wid = wid->getParent();
		}
		return ret;
	}

	void LayerManager::upLayerItem(WidgetPtr _item)
	{
		if (null == _item) return;

		// добираемся до рута
		while (_item->getParent() != null) _item = _item->getParent();

		// если приаттачены, то поднимаем
		if (null != _item->mLayerKeeper) _item->mLayerKeeper->upItem(_item->mLayerItemKeeper);

	}

    WidgetPtr Gui::GetKeyEventSource()
    {
        WidgetPtr widget = mFocusHandler->GetFocused();

        while (widget->_getInternalFocusHandler()
               && widget->_getInternalFocusHandler()->GetFocused())
        {
            widget = widget->_getInternalFocusHandler()->GetFocused();
        }

        return widget;
    }

    WidgetPtr Gui::GetMouseEventSource(int x, int y)
    {
        WidgetPtr widget = GetWidgetAt(x, y);

        if (mFocusHandler->GetModalMouseInputFocused()
            && !widget->isModalMouseInputFocused())
        {
            return mFocusHandler->GetModalMouseInputFocused();
        }

        return widget;
    }

    void FocusHandler::distributeFocusGainedEvent(const Event& focusEvent)
    {
        WidgetPtr sourceWidget = focusEvent.GetSource();

        std::list<FocusListener*> focusListeners = sourceWidget->_getFocusListeners();

        // Send the event to all focus listeners of the widget.
        for (std::list<FocusListener*>::iterator it = focusListeners.begin();
             it != focusListeners.end();
             ++it)
        {
            (*it)->focusGained(focusEvent);
        }
    }

		void WidgetFactory::Widget_Caption(WidgetPtr _widget, const Ogre::String &_key, const Ogre::String &_value)
		{
			// change '\n' on char 10
			size_t pos = _value.find("\\n");
			if (pos == std::string::npos) _widget->setCaption(_value);
			else {
				std::string value(_value);
				while (pos != std::string::npos) {
					value[pos++] = '\n';
					value.erase(pos, 1);
					pos = value.find("\\n");
				}
				_widget->setCaption(value);
			}
		}

	void ControllerFadeAlpha::prepareItem(WidgetPtr _widget)
	{
		// подготовка виджета, блокируем если только нужно
		if (!mEnabled) _widget->setEnabledSilent(mEnabled);

		if ((ALPHA_MIN != mAlpha) && (false == _widget->isVisible())) {
			_widget->setAlpha(ALPHA_MIN);
			_widget->setVisible(true);
		}

		// отписываем его от ввода
		if (false == mEnabled) InputManager::getInstance()._unlinkWidget(_widget);

		// вызываем пользовательский делегат для подготовки
		eventPreAction(_widget);
	}

    void BasicContainer::Add(WidgetPtr widget)
    {
        mWidgets.push_back(widget);

        if (mInternalFocusHandler == NULL)
        {
            widget->_setFocusHandler(_getFocusHandler());
        }
        else
        {
            widget->_setFocusHandler(mInternalFocusHandler);
        }

        widget->_setParent(shared_from_this());
        widget->addDeathListener(this);
    }

    void Gui::handleModalFocusReleased()
    {
         // Check all widgets below the mouse to see if they are
        // present in the "widget with mouse" queue. If a widget
        // is not then it should be added and an entered event should
        // be sent to it.
        WidgetPtr widget = GetMouseEventSource(mLastMouseX, mLastMouseY);
        WidgetPtr parent = widget;

        while (parent != NULL)
        {
            parent = widget->GetParent();

            // Check if the widget is present in the "widget with mouse" queue.
            bool widgetIsPresentInQueue = false;
            std::deque<WidgetPtr>::iterator iter;
            for (iter = mWidgetWithMouseQueue.begin();
                 iter != mWidgetWithMouseQueue.end();
                 iter++)
            {
                if (*iter == widget)
                {
                    widgetIsPresentInQueue = true;
                    break;
                }
            }

            // Widget is not present, send an entered event and add
            // it to the "widget with mouse" queue.
            if (!widgetIsPresentInQueue
                && Widget::widgetExists(widget))
            {
                distributeMouseEvent(widget,
                                     MouseEvent::ENTERED,
                                     mLastMousePressButton,
                                     mLastMouseX,
                                     mLastMouseY,
                                     false,
                                     true);
                mWidgetWithMouseQueue.push_front(widget);
            }

            WidgetPtr swap = widget;
            widget = parent;
            parent = swap->GetParent();
        }
    }

    WidgetPtr Gui::GetWidgetAt(int x, int y)
    {
        // If the widget's parent has no child then we have found the widget..
        WidgetPtr parent = mTop;
        WidgetPtr child = mTop;

        while (child != NULL)
        {
            WidgetPtr swap = child;
            int parentX, parentY;
            parent->getAbsolutePosition(parentX, parentY);
            child = parent->GetWidgetAt(x - parentX, y - parentY);
            parent = swap;
        }

        return parent;
    }

    void BasicContainer::Remove(WidgetPtr widget)
    {
        WidgetListIterator iter;
        for (iter = mWidgets.begin(); iter != mWidgets.end(); iter++)
        {
            if (*iter == widget)
            {
                mWidgets.erase(iter);
                widget->_setFocusHandler(FocusHandlerPtr());
                widget->_setParent(WidgetPtr());
                widget->removeDeathListener(this);
                return;
            }
        }

        throw GCN_EXCEPTION("There is no such widget in this container.");
    }