#include "Painter.h"
#include "Window.h"
#include "Widget.h"


#include <assert.h>
#define DEBUG_WIDGET  0
#if DEBUG_WIDGET
#  include <stdio.h>
#  include <typeinfo>
#endif


bool c_useRetina = true;
float c_retinaScale = 2.0f;


BEGIN_NAMESPACE

	
Widget::Widget(Object* a_parent, const char* a_name)
  : Widget(ObjectPtrCast<Widget>(a_parent), a_name)
{
}


Widget::Widget(const char* a_name, bool a_root)
  : BaseT(nullptr, a_name)
{
  assert(a_root);
  m_layoutDirection = LP_Horizontal;
  m_windowX = m_windowY = 0;
  m_watchingMouse = false;
  m_delayDelete = false;
  m_hasUnmanagedDescendant = false;
  m_x = m_y = 0;
  m_goalWidth = m_goalHeight = 1;
  layoutMargin = 5;
  layoutSpacing = 5;
  backgroundBrush = 0xF0F0F0;
  flags = WF_None;
  scale = 1.0f;
  m_combinedScale = 1.0f;
}


Widget::Widget(Widget* a_parent, const char* a_name, LayoutPolicy a_layoutDirection, int a_x, int a_y, int a_width, int a_height)
	: BaseT(a_parent ? a_parent : new Window(a_name, true), a_name), m_layoutDirection(a_layoutDirection)
{
  // TODO: when automatically creating a parent window when parent is 0, we need
  // a way to automatically destroy things - currently destruction is not well tested.
  // Need to try create and destroy a bunch of widgets and see if the windows can be removed.
  // May require adding a flag to say if we automatically created the parent window or not.
  // Or perhaps using shared_ptr and then if the window has no children it destroys itself?
  layoutMargin = 5;
  layoutSpacing = 5;
  backgroundBrush = 0xF0F0F0;
  m_windowX = m_windowY = 0;
  m_watchingMouse = false;
  m_delayDelete = false;
  m_hasUnmanagedDescendant = false;
  scale = 1.0f;
  Widget* widgetParent = parent<Widget>();
  m_combinedScale = (widgetParent) ? widgetParent->m_combinedScale : 1.0f;
  connect(scale.valueChanged, this, &Widget::updateScale);
  setGeometry(a_x, a_y, a_width, a_height);
  flags = WF_None;
  if (m_layoutDirection == LP_Unmanaged)
    setParentHasUnmanagedChild();
}


Widget::~Widget()
{
}


void Widget::updateScale(float ignored)
{
  Widget* widgetParent = parent<Widget>();
  m_combinedScale = (widgetParent) ? scale.value() * widgetParent->m_combinedScale : scale.value();

  std::list<Widget*> widgetChildren = children<Widget>();
  for (Widget* child : widgetChildren)
  {
    child->updateScale(0.0f);
  }
}


void Widget::setParentHasUnmanagedChild()
{
  Widget* widgetParent = parent<Widget>();
  if (widgetParent)
    widgetParent->setParentHasUnmanagedChild();
  m_hasUnmanagedDescendant = true;
}


void Widget::childAdded(Object* a_object)
{
  Widget* widgetParent = parent<Widget>();
	if (widgetParent)
		widgetParent->updateLayout();
	else
		updateLayout();
	repaint();
}


void Widget::updateLayout()
{
  std::list<Widget*> widgetChildren = children<Widget>();
  
	// recalculate layout
	int childCount = (int)widgetChildren.size();
	if (childCount)
	{
		SizeOptions childTotalSize;
		Vector<SizeOptions> childSizes;
		childSizes.resize(childCount);
		memset(&childTotalSize, 0, sizeof(childTotalSize));

		int i = 0;
		for (std::list<Widget*>::const_iterator it = widgetChildren.begin(); it != widgetChildren.end(); ++it)
		{
      (*it)->scaledSizeOptions(childSizes[i]);

      childTotalSize.m_minimum.m_width    += childSizes[i].m_minimum.m_width;
      childTotalSize.m_minimum.m_height   += childSizes[i].m_minimum.m_height;

      childTotalSize.m_preferred.m_width  += childSizes[i].m_preferred.m_width;
      childTotalSize.m_preferred.m_height += childSizes[i].m_preferred.m_height;

      childTotalSize.m_maximum.m_width    += childSizes[i].m_maximum.m_width;
      childTotalSize.m_maximum.m_height   += childSizes[i].m_maximum.m_height;

      i++;
		}

		int x = 0, y = 0, wid = width(), heig = height();
		int extraSpaceForMarginsAndSpacing = (childCount - 1) * layoutSpacing() + layoutMargin() * 2;

    // TODO: refactor the horz/vert cases to one set of code as mostly the same
		if (m_layoutDirection == LP_Horizontal)
		{
			// horz
			if ( wid > childTotalSize.m_maximum.m_width )
			{
				// TODO: need to do padding horizontally
				wid = childTotalSize.m_maximum.m_width;
			}
			if ( wid < childTotalSize.m_minimum.m_width )
			{
				// TODO: can't meet the constraint
				wid = childTotalSize.m_minimum.m_width;
			}
			if ( wid < extraSpaceForMarginsAndSpacing )
			{
				// TODO: can't meet the constraint
				wid = extraSpaceForMarginsAndSpacing;
			}

			int w = wid - extraSpaceForMarginsAndSpacing;
			int h = heig - layoutMargin() * 2;
			int remainder = w - childTotalSize.m_preferred.m_width;
			Vector<int> proposedChildWidths;
			Vector<bool> childWidthDone;
			int childWidthDoneCount = 0;
			proposedChildWidths.resize(childCount);
			childWidthDone.resize(childCount);
			for (int i = 0; i < childCount; i++)
			{
				proposedChildWidths[i] = childSizes[i].m_preferred.m_width;
				childWidthDone[i] = false;
			}
			while (abs(remainder) > (childCount-childWidthDoneCount))
			{
				int distributedRemainder = remainder / (childCount-childWidthDoneCount);

				for (int i = 0; i < childCount; i++)
				{
					if (!childWidthDone[i]) {
						if (remainder < 0) {
							if (proposedChildWidths[i] + distributedRemainder < childSizes[i].m_minimum.m_width)
							{
								proposedChildWidths[i] = childSizes[i].m_minimum.m_width;
								childWidthDone[i] = true;
								childWidthDoneCount++;
							} else {
								proposedChildWidths[i] += distributedRemainder;
							}
						} else {
							if (proposedChildWidths[i] + distributedRemainder > childSizes[i].m_maximum.m_width)
							{
								proposedChildWidths[i] = childSizes[i].m_maximum.m_width;
								childWidthDone[i] = true;
								childWidthDoneCount++;
							} else {
								proposedChildWidths[i] += distributedRemainder;
							}
						}
					}
				}

				int newTotalProposedWidth = 0;
				for (int i = 0; i < childCount; i++)
					newTotalProposedWidth += proposedChildWidths[i];
				remainder = w - newTotalProposedWidth;

				if (childWidthDoneCount >= childCount)
					break;
			}

			int i = 0;
			y = x = layoutMargin();
			for (std::list<Widget*>::const_iterator it = widgetChildren.begin(); it != widgetChildren.end(); ++it, x += proposedChildWidths[i] + layoutSpacing(), i++)
				(*it)->setGeometry(x, y, proposedChildWidths[i], h);

		}
    else // if (m_layoutDirection == LP_Vertical)
    {
			// vert
			if ( heig > childTotalSize.m_maximum.m_height )
			{
				// TODO: need to do padding horizontally
				heig = childTotalSize.m_maximum.m_height;
			}
			if ( heig < childTotalSize.m_minimum.m_height )
			{
				// TODO: can't meet the constraint
				heig = childTotalSize.m_minimum.m_height;
			}
			if ( heig < extraSpaceForMarginsAndSpacing )
			{
				// TODO: can't meet the constraint
				heig = extraSpaceForMarginsAndSpacing;
			}

			int h = heig - extraSpaceForMarginsAndSpacing;
			int w = wid - layoutMargin() * 2;
			int remainder = h - childTotalSize.m_preferred.m_height;
			Vector<int> proposedChildHeight;
			Vector<bool> childHeightDone;
			int childHeightDoneCount = 0;
			proposedChildHeight.resize(childCount);
			childHeightDone.resize(childCount);
			for (int i = 0; i < childCount; i++)
			{
				proposedChildHeight[i] = childSizes[i].m_preferred.m_height;
				childHeightDone[i] = false;
			}
			while (abs(remainder) > (childCount-childHeightDoneCount))
			{
				int distributedRemainder = remainder / (childCount-childHeightDoneCount);

				for (int i = 0; i < childCount; i++)
				{
					if (!childHeightDone[i]) {
						if (remainder < 0) {
							if (proposedChildHeight[i] + distributedRemainder < childSizes[i].m_minimum.m_height)
							{
								proposedChildHeight[i] = childSizes[i].m_minimum.m_height;
								childHeightDone[i] = true;
								childHeightDoneCount++;
							} else {
								proposedChildHeight[i] += distributedRemainder;
							}
						} else {
							if (proposedChildHeight[i] + distributedRemainder > childSizes[i].m_maximum.m_height)
							{
								proposedChildHeight[i] = childSizes[i].m_maximum.m_height;
								childHeightDone[i] = true;
								childHeightDoneCount++;
							} else {
								proposedChildHeight[i] += distributedRemainder;
							}
						}
					}
				}

				int newTotalProposedHeight = 0;
				for (int i = 0; i < childCount; i++)
					newTotalProposedHeight += proposedChildHeight[i];
				remainder = h - newTotalProposedHeight;

				if (childHeightDoneCount >= childCount)
					break;
			}

			int i = 0;
			y = x = layoutMargin();
			for (std::list<Widget*>::const_iterator it = widgetChildren.begin(); it != widgetChildren.end(); ++it, y += proposedChildHeight[i] + layoutSpacing(), i++)
				(*it)->setGeometry(x, y, w, proposedChildHeight[i]);
		}
	}
}


void Widget::sizeOptions(SizeOptions& a_sizeOptions)
{
	a_sizeOptions.m_minimum.m_width    = 0;
	a_sizeOptions.m_minimum.m_height   = 0;
	a_sizeOptions.m_preferred.m_width  = 256;
	a_sizeOptions.m_preferred.m_height = 256;
	a_sizeOptions.m_maximum.m_width    = 65536;
	a_sizeOptions.m_maximum.m_height   = 65536;
	//return;

  std::list<Widget*> widgetChildren = children<Widget>();
	int childCount = (int)widgetChildren.size();
	if (!childCount)
	{
		// TODO
		// Bottom level widgets that have no children ought to implement sizeOptions
		return;
	}

	SizeOptions childSizes;
	if (m_layoutDirection == LP_Horizontal)
	{
		// horiz
		a_sizeOptions.m_minimum.m_height = 0;
		a_sizeOptions.m_preferred.m_height = 0;
		a_sizeOptions.m_maximum.m_height = 65536;

		a_sizeOptions.m_minimum.m_width = 0;
		a_sizeOptions.m_preferred.m_width = 0;
		a_sizeOptions.m_maximum.m_width = 0;

		for (std::list<Widget*>::const_iterator it = widgetChildren.begin(); it != widgetChildren.end(); ++it)
		{
			(*it)->scaledSizeOptions(childSizes);

			a_sizeOptions.m_minimum.m_width   += childSizes.m_minimum.m_width;
			a_sizeOptions.m_preferred.m_width += childSizes.m_preferred.m_width;
			a_sizeOptions.m_maximum.m_width   += childSizes.m_maximum.m_width;

			a_sizeOptions.m_minimum.m_height    = std::max(a_sizeOptions.m_minimum.m_height, childSizes.m_minimum.m_height);
			a_sizeOptions.m_preferred.m_height += childSizes.m_preferred.m_height;
			a_sizeOptions.m_maximum.m_height    = std::min(a_sizeOptions.m_maximum.m_height, childSizes.m_maximum.m_height);
		}

		a_sizeOptions.m_preferred.m_height /= childCount; // average of preferred heights

		int extraSpaceForMarginsAndSpacing = layoutMargin() * 2;
		a_sizeOptions.m_minimum.m_height   += extraSpaceForMarginsAndSpacing;
		a_sizeOptions.m_preferred.m_height += extraSpaceForMarginsAndSpacing;
		a_sizeOptions.m_maximum.m_height   += extraSpaceForMarginsAndSpacing;

		extraSpaceForMarginsAndSpacing += (childCount - 1) * layoutSpacing();
		a_sizeOptions.m_minimum.m_width   += extraSpaceForMarginsAndSpacing;
		a_sizeOptions.m_preferred.m_width += extraSpaceForMarginsAndSpacing;
		a_sizeOptions.m_maximum.m_width   += extraSpaceForMarginsAndSpacing;

	}
  else // if (m_layoutDirection == LP_Vertical)
  {
		// vert
		a_sizeOptions.m_minimum.m_width = 0;
		a_sizeOptions.m_preferred.m_width = 0;
		a_sizeOptions.m_maximum.m_width = 65536;

		a_sizeOptions.m_minimum.m_height = 0;
		a_sizeOptions.m_preferred.m_height = 0;
		a_sizeOptions.m_maximum.m_height = 0;

		for (std::list<Widget*>::const_iterator it = widgetChildren.begin(); it != widgetChildren.end(); ++it)
		{
			(*it)->scaledSizeOptions(childSizes);

			a_sizeOptions.m_minimum.m_height   += childSizes.m_minimum.m_height;
			a_sizeOptions.m_preferred.m_height += childSizes.m_preferred.m_height;
			a_sizeOptions.m_maximum.m_height   += childSizes.m_maximum.m_height;

			a_sizeOptions.m_minimum.m_width    = std::max(a_sizeOptions.m_minimum.m_width, childSizes.m_minimum.m_width);
			a_sizeOptions.m_preferred.m_width += childSizes.m_preferred.m_width;
			a_sizeOptions.m_maximum.m_width    = std::min(a_sizeOptions.m_maximum.m_width, childSizes.m_maximum.m_width);
		}

		a_sizeOptions.m_preferred.m_width /= childCount; // average of preferred heights

		int extraSpaceForMarginsAndSpacing = layoutMargin() * 2;
		a_sizeOptions.m_minimum.m_width   += extraSpaceForMarginsAndSpacing;
		a_sizeOptions.m_preferred.m_width += extraSpaceForMarginsAndSpacing;
		a_sizeOptions.m_maximum.m_width   += extraSpaceForMarginsAndSpacing;

		extraSpaceForMarginsAndSpacing += (childCount - 1) * layoutSpacing();
		a_sizeOptions.m_minimum.m_height   += extraSpaceForMarginsAndSpacing;
		a_sizeOptions.m_preferred.m_height += extraSpaceForMarginsAndSpacing;
		a_sizeOptions.m_maximum.m_height   += extraSpaceForMarginsAndSpacing;
	}

	// ensure min is less than max and clamp the preferred to the min and max
	if ( a_sizeOptions.m_maximum.m_height < a_sizeOptions.m_minimum.m_height )
		a_sizeOptions.m_maximum.m_height = a_sizeOptions.m_minimum.m_height = (a_sizeOptions.m_maximum.m_height + a_sizeOptions.m_minimum.m_height) / 2;
	if ( a_sizeOptions.m_maximum.m_width < a_sizeOptions.m_minimum.m_width )
		a_sizeOptions.m_maximum.m_width = a_sizeOptions.m_minimum.m_width = (a_sizeOptions.m_maximum.m_width + a_sizeOptions.m_minimum.m_width) / 2;
	if ( a_sizeOptions.m_preferred.m_height < a_sizeOptions.m_minimum.m_height )
		a_sizeOptions.m_preferred.m_height = a_sizeOptions.m_minimum.m_height;
	if ( a_sizeOptions.m_preferred.m_width < a_sizeOptions.m_minimum.m_width )
		a_sizeOptions.m_preferred.m_width = a_sizeOptions.m_minimum.m_width;
	if ( a_sizeOptions.m_preferred.m_height > a_sizeOptions.m_maximum.m_height )
		a_sizeOptions.m_preferred.m_height = a_sizeOptions.m_maximum.m_height;
	if ( a_sizeOptions.m_preferred.m_width > a_sizeOptions.m_maximum.m_width )
		a_sizeOptions.m_preferred.m_width = a_sizeOptions.m_maximum.m_width;
 
  // We are the topLevel widget before the window widget
  Widget* widgetParent = parent<Widget>();
  if (widgetParent && !widgetParent->parent<Widget>())
  {
    Rectangle rect = widgetParent->rectangle();
    a_sizeOptions.m_maximum = rect.m_size;
  }
}


void Widget::setGeometry(int a_x, int a_y, int a_width, int a_height)
{
	m_windowX = m_x = a_x;
	m_windowY = m_y = a_y;
	m_goalWidth = a_width;// / 2.0;// * m_combinedScale;// / 2.0;
	m_goalHeight = a_height;// / 2.0;// * m_combinedScale;// / 2.0;
  Widget* widgetParent = parent<Widget>();
	if (widgetParent)
	{
    if (c_useRetina)
    {
      m_goalWidth *= 2;
      m_goalHeight *= 2;
    }
    //m_goalWidth = (a_width / c_retinaScale) * 2.0;
    //m_goalHeight = (a_height / c_retinaScale) * 2.0;
		m_windowX = widgetParent->m_windowX + a_x;
		m_windowY = widgetParent->m_windowY + a_y;
		updateTarget(); // update target buffer
	}

  // TODO: if a child geometry changes, does that bubble up to the parent?
  // If so, layout updates need to ascend up to the root parent, and then do a full re-layout all the way down

  // TODO: also need to be careful. doing updateLayout will call setGeometry on widgets which will call updateLayout etc.
  // Also in the constructor, it calls setGeometry and it also does this before the widget it added to the parent's children
  // Adding a child widget causes a full re-layout from the root down

  // TODO: setGeometry on the root (ie: window) should re-size the underlying window. possibly need a virtual function for this
	updateLayout();
}


TimerId Widget::startTimer(int a_milliSeconds)
{
  Widget* widgetParent = parent<Widget>();
	if (widgetParent)
		return widgetParent->startTimer(a_milliSeconds);
	return 0;
}


void Widget::killTimer(TimerId a_timerId)
{
  Widget* widgetParent = parent<Widget>();
	if (widgetParent)
		widgetParent->killTimer(a_timerId);
}


void Widget::eraseBackground(int i)
{
	Painter p(this);
	p.reset();
/* 
	p.setBrush(backgroundBrush());
#if DEBUG_WIDGET
	printf("draw rect: %i %i %i %i\n", 0, 0, width(), height());
#endif
	p.drawRectangle(0, 0, width(), height());
*/
}


int Widget::width()
{
  if (c_useRetina)
	  return targetBuffer().m_width / 2;
	return targetBuffer().m_width;// * 2;
}


int Widget::height()
{
  if (c_useRetina)
	  return targetBuffer().m_height / 2;
	return targetBuffer().m_height;// * 2;
}


void Widget::sizeEvent(SizeEvent& a_event)
{
}


void Widget::paintEvent(PaintEvent& a_event)
{
	eraseBackground();
}


void Widget::glPaint()
{
}


void Widget::timerEvent(TimerEvent& a_event)
{
}


void Widget::keyEvent(KeyEvent& a_event)
{
}


void Widget::mouseEvent(MouseEvent& a_event)
{
}


void Widget::mouseEnterEvent(MouseEvent& a_event)
{
}


void Widget::mouseLeaveEvent(MouseEvent& a_event)
{
}


void Widget::wheelEvent(WheelEvent& a_event)
{
}


void Widget::updateTarget()
{
  Widget* widgetParent = parent<Widget>();
 
    /*
  if (widgetParent)
  {
    PixelBuffer& parentTarget = widgetParent->targetBuffer();
    m_goalWidth = clamp(m_goalWidth, 0, parentTarget.m_width);
    m_goalHeight = clamp(m_goalHeight, 0, parentTarget.m_height);
    if (parentTarget.m_isRetina)
    {
      m_target.m_width = clamp(parentTarget.m_width - m_x*2 - 1, 0, m_goalWidth);
      m_target.m_height = clamp(parentTarget.m_height - m_y*2 - 1, 0, m_goalHeight);
    }
    else
    {
      m_target.m_width = clamp(parentTarget.m_width - m_x - 1, 0, m_goalWidth);
      m_target.m_height = clamp(parentTarget.m_height - m_y - 1, 0, m_goalHeight);
    }
  }
  */

  if (m_layoutDirection == LP_Unmanaged)
  {
    m_target.m_width = m_goalWidth;   // FIXME: still needs to be clamped though
    m_target.m_height = m_goalHeight; // ditto
    
    //m_target.m_width = clamp(m_goalWidth, 0, m_target.m_width);
    //m_target.m_height = clamp(m_goalHeight, 0, m_target.m_height);
  }
  else if (widgetParent)
  {
    PixelBuffer& parentTarget = widgetParent->targetBuffer();
    m_target.m_width = clamp(parentTarget.m_width - m_x - 1, 0, m_goalWidth);
    m_target.m_height = clamp(parentTarget.m_height - m_y - 1, 0, m_goalHeight);

    
//    m_goalWidth = clamp(m_goalWidth, 0, parentTarget.m_width - m_x - 1);
//    m_goalHeight = clamp(m_goalHeight, 0, parentTarget.m_height - m_y - 1);
    //m_target.m_width = clamp(m_goalWidth, 0, parentTarget.m_width - m_x - 1);
    //m_target.m_height = clamp(m_goalHeight, 0, parentTarget.m_height - m_y - 1);
  }

  int maxWidth = m_target.m_width - m_x - 1;
  int maxHeight = m_target.m_height - m_y - 1;

  if (widgetParent)
  {
    PixelBuffer& parentTarget = widgetParent->targetBuffer();
    m_target.m_pixels = parentTarget.m_pixels + m_y * (parentTarget.m_strideBytes/4) + m_x;
    m_target.m_strideBytes = parentTarget.m_strideBytes;
    m_target.m_format = parentTarget.m_format;
    m_target.m_isRetina = parentTarget.m_isRetina;
    
    maxWidth = parentTarget.m_width - m_x - 1;
    maxHeight = parentTarget.m_height - m_y - 1;

#if USE_RETINA
    if (c_useRetina)
    {
      maxWidth = parentTarget.m_width - m_x*2 - 1;
      maxHeight = parentTarget.m_height - m_y*2 - 1;
      
      //m_target.m_pixels = parentTarget.m_pixels + int(m_y * c_retinaScale) * (parentTarget.m_strideBytes/4) + int(m_x * c_retinaScale);
      m_target.m_pixels = parentTarget.m_pixels + int(m_y * 2.0) * (parentTarget.m_strideBytes/4) + int(m_x * 2.0);
    }
#endif

  }
  else
  {
    m_target.m_isRetina = false;
    m_target.m_pixels = m_target.m_pixels + m_y * (m_target.m_strideBytes/4) + m_x;
  }

  if (m_layoutDirection != LP_Unmanaged)
  {
    m_target.m_width = clamp(m_target.m_width, 0, maxWidth);
    m_target.m_height = clamp(m_target.m_height, 0, maxHeight);
  }

}


void Widget::repaint()
{
	Rectangle rectangle = { { { 0, 0 } }, { { width(), height() } } };
	update(rectangle);
}


void Widget::update(Rectangle& a_rectangle)
{
  Widget* widgetParent = parent<Widget>();
	if (widgetParent)
	{
		a_rectangle.m_x += m_x;
		a_rectangle.m_y += m_y;
		widgetParent->update(a_rectangle); // This recursively calculates m_windowX and m_windowY
		// When this gets up to the top level widget it will be a window object with overloaded update function
	}
}


void Widget::event(Event& a_event)
{
	a_event.m_commonEvent.reject();

	switch (a_event.m_type)
	{
		case Event::ET_TimerEvent:
			timerEvent(a_event.m_timerEvent);
			break;
		case Event::ET_PaintEvent:
      if (flags() == WF_EraseBackground)
        eraseBackground();
      paintEvent(a_event.m_paintEvent);
			break;
		case Event::ET_SizeEvent:
			if (parent<Widget>())
				updateTarget();
			sizeEvent(a_event.m_sizeEvent);
			break;
		default:
			break;
	}

  std::list<Widget*> widgetChildren = children<Widget>();

/*
  // Code if not dealing with unmanaged layouts
  for (std::list<Widget*>::const_iterator it = widgetChildren.begin(); it != widgetChildren.end(); ++it)
  {
#if DEBUG_WIDGET
    printf("event, child class: %s\n", typeid(*(*it)).name());
#endif
    (*it)->event(a_event);
    if (a_event.m_commonEvent.m_accepted)
      return;
  }
*/

  // Code to deal with event propogation with unmanaged layouts
  // The order depends on event type. paint events go dirst to managed, then the unmanaged
  // layout widgets are drawn last. For input events, the managed widgets are processed first.
	if (a_event.m_type == Event::ET_PaintEvent)
  {
    std::vector<Widget*> unmanagedWidgets;
    for (std::list<Widget*>::const_iterator it = widgetChildren.begin(); it != widgetChildren.end(); ++it)
    {
      if ((*it)->m_hasUnmanagedDescendant)
      {
        unmanagedWidgets.push_back(*it);
      }
      else
      {
        (*it)->event(a_event);
        if (a_event.m_commonEvent.m_accepted)
          return;
      }
    }
    for (Widget* w : unmanagedWidgets)
    {
      w->event(a_event);
      if (a_event.m_commonEvent.m_accepted)
        return;
    }
  }
  else
  {
    std::vector<Widget*> managedWidgets;
    for (std::list<Widget*>::const_iterator it = widgetChildren.begin(); it != widgetChildren.end(); ++it)
    {
      if ((*it)->m_hasUnmanagedDescendant)
      {
        (*it)->event(a_event);
        if (a_event.m_commonEvent.m_accepted)
          return;
      }
      else
      {
        managedWidgets.push_back(*it);
      }
    }
    for (Widget* w : managedWidgets)
    {
      w->event(a_event);
      if (a_event.m_commonEvent.m_accepted)
        return;
    }
  }


	bool mouseInside = false;
	switch (a_event.m_type)
	{
		case Event::ET_MouseEvent:
			mouseInside = ((a_event.m_mouseEvent.m_position.m_x > m_windowX)
				&& (a_event.m_mouseEvent.m_position.m_y > m_windowY)
				&& (a_event.m_mouseEvent.m_position.m_x < (m_windowX + width()))
				&& (a_event.m_mouseEvent.m_position.m_y < (m_windowY + height())));
			if (m_mouseEntered && !mouseInside)
			{
				mouseLeaveEvent(a_event.m_mouseEvent);
			}
			if (!m_mouseEntered && mouseInside)
			{
				mouseEnterEvent(a_event.m_mouseEvent);
			}
			m_mouseEntered = mouseInside;
			if (mouseInside	|| m_watchingMouse )
			{
        MouseEvent pushEvent = a_event.m_mouseEvent;
				a_event.m_mouseEvent.m_x = (pushEvent.m_x - m_windowX);
				a_event.m_mouseEvent.m_y = (pushEvent.m_y - m_windowY);
				a_event.m_mouseEvent.m_oldX = (pushEvent.m_oldX - m_windowX);
				a_event.m_mouseEvent.m_oldY = (pushEvent.m_oldY - m_windowY);
				//a_event.m_mouseEvent.m_x = (pushEvent.m_x - m_windowX) * c_retinaScale;
				//a_event.m_mouseEvent.m_y = (pushEvent.m_y - m_windowY) * c_retinaScale;
				//a_event.m_mouseEvent.m_oldX = (pushEvent.m_oldX - m_windowX) * c_retinaScale;
				//a_event.m_mouseEvent.m_oldY = (pushEvent.m_oldY - m_windowY) * c_retinaScale;
				//a_event.m_mouseEvent.m_x = (pushEvent.m_x * 2.0f / c_retinaScale) - m_windowX;
				//a_event.m_mouseEvent.m_y = (pushEvent.m_y * 2.0f / c_retinaScale) - m_windowY;
				//a_event.m_mouseEvent.m_oldX = (pushEvent.m_oldX * 2.0f / c_retinaScale) - m_windowX;
				//a_event.m_mouseEvent.m_oldY = (pushEvent.m_oldY * 2.0f / c_retinaScale) - m_windowY;
				if (!a_event.m_mouseEvent.m_oldButtons && a_event.m_mouseEvent.m_buttons)
					m_watchingMouse = true;
				if (!a_event.m_mouseEvent.m_buttons)
					m_watchingMouse = false;
				mouseEvent(a_event.m_mouseEvent);
        a_event.m_mouseEvent = pushEvent; // pop
			}
			break;
		case Event::ET_WheelEvent:
			wheelEvent(a_event.m_wheelEvent);
			break;
		case Event::ET_KeyEvent:
			keyEvent(a_event.m_keyEvent);
			break;
		default:
			break;
	}

  if (!parent())
  {
    deleteDelayDeleteWidgets();
  }
}


void Widget::delayDelete()
{
  m_delayDelete = true;
}


void Widget::collectDelayDeleteWidgets(std::vector<Widget*>& a_widgetsToBeDeleted) const
{
  std::list<Widget*> widgetChildren = children<Widget>();
  for (std::list<Widget*>::const_iterator it = widgetChildren.begin(); it != widgetChildren.end(); ++it)
  {
    (*it)->collectDelayDeleteWidgets(a_widgetsToBeDeleted);
    if ((*it)->m_delayDelete)
    {
      a_widgetsToBeDeleted.emplace_back(*it);
    }
  }
}


void Widget::deleteDelayDeleteWidgets()
{
  std::vector<Widget*> widgetsToBeDeleted;
  collectDelayDeleteWidgets(widgetsToBeDeleted);
  for (auto w : widgetsToBeDeleted)
  {
    delete w;
  }
}


void Widget::scaledSizeOptions(SizeOptions& a_sizeOptions)
{
  sizeOptions(a_sizeOptions);
  a_sizeOptions.m_minimum.m_width *= m_combinedScale;
  a_sizeOptions.m_minimum.m_height *= m_combinedScale;
  a_sizeOptions.m_preferred.m_width *= m_combinedScale;
  a_sizeOptions.m_preferred.m_height *= m_combinedScale;
  a_sizeOptions.m_maximum.m_width *= m_combinedScale;
  a_sizeOptions.m_maximum.m_height *= m_combinedScale;
}


END_NAMESPACE