static void ForEachEventListenerBubbleUp(UIEventArgs e, HitChain hitPointChain, EventListenerAction listenerAction)
{
HitInfo hitInfo;
for (int i = hitPointChain.Count - 1; i >= 0; --i)
{
hitInfo = hitPointChain.GetHitInfo(i);
IUIEventListener listener = hitInfo.hitElement.GetController() as IUIEventListener;
if (listener != null)
{
if (e.SourceHitElement == null)
{
e.SourceHitElement = listener;
}
var hitPoint = hitInfo.point;
e.SetLocation(hitPoint.X, hitPoint.Y);
e.CurrentContextElement = listener;
if (listenerAction(listener))
{
return;
}
}
}
}
internal bool HitTestCore(HitChain hitChain)
{
int testX;
int testY;
hitChain.GetTestPoint(out testX, out testY);
if (this.RunCount == 0)
{
return(false);
}
else
{
LinkedListNode <EditableRun> cnode = this.First;
int curLineTop = this.lineTop;
hitChain.OffsetTestPoint(0, -curLineTop);
while (cnode != null)
{
if (cnode.Value.HitTestCore(hitChain))
{
hitChain.OffsetTestPoint(0, curLineTop);
return(true);
}
cnode = cnode.Next;
}
hitChain.OffsetTestPoint(0, curLineTop);
return(false);
}
}
public override bool HitTestCore(HitChain hitChain)
{
if ((layerFlags & IS_LAYER_HIDDEN) == 0)
{
if ((layerFlags & FLOWLAYER_HAS_MULTILINE) != 0)
{
List <EditableTextLine> lines = (List <EditableTextLine>)lineCollection;
int j = lines.Count;
int testYPos = hitChain.TestPoint.Y;
for (int i = 0; i < j; ++i)
{
EditableTextLine line = lines[i];
if (line.LineBottom < testYPos)
{
continue;
}
else if (line.HitTestCore(hitChain))
{
return(true);
}
else if (line.LineTop > testYPos)
{
return(false);
}
}
}
else
{
EditableTextLine onlyLine = (EditableTextLine)lineCollection;
return(onlyLine.HitTestCore(hitChain));
}
}
return(false);
}
static void ForEachEventListenerBubbleUp <T>(T e, HitChain hitPointChain, EventListenerAction <T> listenerAction)
where T : UIEventArgs
{
HitInfo hitInfo;
for (int i = hitPointChain.Count - 1; i >= 0; --i)
{
hitInfo = hitPointChain.GetHitInfo(i);
if (hitInfo.HitElemAsRenderElement.GetController() is IUIEventListener listener)
{
if (e.SourceHitElement == null)
{
e.SetSourceHitObject(listener);
}
Point p = hitInfo.point;
e.SetLocation(p.X, p.Y);
e.SetCurrentContextElement(listener);
if (listenerAction(e, listener))
{
return;
}
}
}
}
internal bool HitTestCore(HitChain hitChain)
{
throw new NotSupportedException();
return(true);
//int testX;
//int testY;
//hitChain.GetTestPoint(out testX, out testY);
//if (this.Count == 0)
//{
// return false;
//}
//else
//{
// LinkedListNode<EditableRun> cnode = this.First;
// int curLineTop = this.lineTop;
// hitChain.OffsetTestPoint(0, -curLineTop);
// while (cnode != null)
// {
// if (cnode.Value.HitTestCore(hitChain))
// {
// hitChain.OffsetTestPoint(0, curLineTop);
// return true;
// }
// cnode = cnode.Next;
// }
// hitChain.OffsetTestPoint(0, curLineTop);
// return false;
//}
}
//==============================================================
//hit test
public bool HitTestCore(HitChain hitChain)
{
if ((propFlags & RenderElementConst.HIDDEN) != 0)
{
return(false);
}
int testX;
int testY;
hitChain.GetTestPoint(out testX, out testY);
if ((testY >= b_top && testY <= (b_top + b_height) &&
(testX >= b_left && testX <= (b_left + b_width))))
{
if (this.MayHasViewport)
{
hitChain.OffsetTestPoint(
-b_left + this.ViewportX,
-b_top + this.ViewportY);
}
else
{
hitChain.OffsetTestPoint(-b_left, -b_top);
}
hitChain.AddHitObject(this);
if (this.MayHasChild)
{
this.ChildrenHitTestCore(hitChain);
}
if (this.MayHasViewport)
{
hitChain.OffsetTestPoint(
b_left - this.ViewportX,
b_top - this.ViewportY);
}
else
{
hitChain.OffsetTestPoint(b_left, b_top);
}
if ((propFlags & RenderElementConst.TRANSPARENT_FOR_ALL_EVENTS) != 0 &&
hitChain.TopMostElement == this)
{
hitChain.RemoveCurrentHit();
return(false);
}
else
{
return(true);
}
}
else
{
return(false);
}
}
void IEventPortal.PortalMouseUp(UIMouseEventArgs e)
{
#if DEBUG
if (this.dbugRootGraphics.dbugEnableGraphicInvalidateTrace)
{
this.dbugRootGraphics.dbugGraphicInvalidateTracer.WriteInfo("================");
this.dbugRootGraphics.dbugGraphicInvalidateTracer.WriteInfo("MOUSEUP");
this.dbugRootGraphics.dbugGraphicInvalidateTracer.WriteInfo("================");
}
#endif
HitChain hitPointChain = GetFreeHitChain();
HitTestCoreWithPrevChainHint(hitPointChain, this._previousChain, e.X, e.Y);
int hitCount = hitPointChain.Count;
if (hitCount > 0)
{
SetEventOrigin(e, hitPointChain);
//---------------------------------------------------------------
ForEachOnlyEventPortalBubbleUp(e, hitPointChain, (portal) =>
{
portal.PortalMouseUp(e);
return(true);
});
//---------------------------------------------------------------
if (!e.CancelBubbling)
{
ForEachEventListenerBubbleUp(e, hitPointChain, (listener) =>
{
listener.ListenMouseUp(e);
return(true);
});
}
//---------------------------------------------------------------
if (!e.CancelBubbling)
{
if (e.IsAlsoDoubleClick)
{
ForEachEventListenerBubbleUp(e, hitPointChain, listener =>
{
listener.ListenMouseDoubleClick(e);
//-------------------------------------------------------
//retrun true to stop this loop (no further bubble up)
//return false to bubble this to upper control
return(e.CancelBubbling || !listener.BypassAllMouseEvents);
});
}
else
{
ForEachEventListenerBubbleUp(e, hitPointChain, listener =>
{
listener.ListenMouseClick(e);
return(e.CancelBubbling || !listener.BypassAllMouseEvents);
});
}
}
}
SwapHitChain(hitPointChain);
e.StopPropagation();
}
void HitTestCoreWithChain(HitChain hitPointChain, int x, int y)
{
hitPointChain.ClearAll();
hitPointChain.SetStartTestPoint(x, y);
RenderElement commonElement = this.topRenderElement;
commonElement.HitTestCore(hitPointChain);
}
void IEventPortal.PortalMouseWheel(UIMouseEventArgs e)
{
#if DEBUG
if (this.dbugRootGraphics.dbugEnableGraphicInvalidateTrace)
{
this.dbugRootGraphics.dbugGraphicInvalidateTracer.WriteInfo("================");
this.dbugRootGraphics.dbugGraphicInvalidateTracer.WriteInfo("MOUSEWHEEL");
this.dbugRootGraphics.dbugGraphicInvalidateTracer.WriteInfo("================");
}
#endif
HitChain hitPointChain = GetFreeHitChain();
#if DEBUG
_dbugHitChainPhase = dbugHitChainPhase.MouseWheel;
#endif
//find hit element
HitTestCoreWithPrevChainHint(hitPointChain, _previousChain, e.X, e.Y);
if (hitPointChain.Count > 0)
{
//------------------------------
//1. origin object
SetEventOrigin(e, hitPointChain);
//------------------------------
IUIEventListener currentMouseWheel = null;
//portal
ForEachOnlyEventPortalBubbleUp(e, hitPointChain, portal =>
{
portal.PortalMouseWheel(e);
//*****
currentMouseWheel = e.CurrentContextElement;
return(true);
});
//------------------------------
//use events
if (!e.CancelBubbling)
{
e.CurrentContextElement = currentMouseWheel = null; //clear
ForEachEventListenerBubbleUp(e, hitPointChain, listener =>
{
if (listener.BypassAllMouseEvents)
{
return(false);
}
currentMouseWheel = listener;
listener.ListenMouseWheel(e);
//-------------------------------------------------------
bool cancelMouseBubbling = e.CancelBubbling;
//-------------------------------------------------------
//retrun true to stop this loop (no further bubble up)
//return false to bubble this to upper control
return(e.CancelBubbling || !listener.BypassAllMouseEvents);
});
}
}
SwapHitChain(hitPointChain);
e.StopPropagation();
}
public static bool HitTestCore(HitChain hitTestHint, HitTestHint layoutHint, IEnumerable <RenderElement> hitTestIter)
{
switch (layoutHint)
{
default:
{
foreach (RenderElement renderE in hitTestIter)
{
if (renderE.HitTestCore(hitTestHint))
{
return(true);
}
}
}
return(false);
case HitTestHint.HorizontalRowNonOverlap:
{
foreach (RenderElement renderE in hitTestIter)
{
if (renderE.HitTestCore(hitTestHint))
{
return(true);
}
else if (renderE.Right < hitTestHint.TestPointX)
{
//hitTestIter iterates from right to left
//so in this case (eg. we have whitespace between each elem)
//this should be stop
return(false);
}
}
}
return(false);
case HitTestHint.VerticalColumnNonOverlap:
{
foreach (RenderElement renderE in hitTestIter)
{
if (renderE.HitTestCore(hitTestHint))
{
return(true);
}
else if (renderE.Bottom < hitTestHint.TestPointY)
{
//hitTestIter iterates from bottom to top
//so in this case (eg. we have whitespace between each elem)
//this should be stop
return(false);
}
}
}
return(false);
}
}
static void SetEventOrigin(UIEventArgs e, HitChain hitChain)
{
int count = hitChain.Count;
if (count > 0)
{
var hitInfo = hitChain.GetHitInfo(count - 1);
e.ExactHitObject = hitInfo.hitElement;
}
}
public override void ChildrenHitTestCore(HitChain hitChain)
{
if (_elements != null)
{
RenderElemHelper.HitTestCore(hitChain, ContentHitTestHint, _elements.GetHitTestIter());
#if DEBUG
debug_RecordLayerInfo(_elements.dbugGetLayerInfo());
#endif
}
}
public override void ChildrenHitTestCore(HitChain hitChain)
{
if (this.defaultLayer != null)
{
defaultLayer.HitTestCore(hitChain);
#if DEBUG
debug_RecordLayerInfo(defaultLayer);
#endif
}
}
static RenderElement HitTestOnPreviousChain(HitChain hitPointChain, HitChain previousChain, int x, int y)
{
#if DEBUG
if (hitPointChain == previousChain)
{
throw new NotSupportedException();
}
#endif
if (previousChain.Count > 0)
{
previousChain.SetStartTestPoint(x, y);
//test on prev chain top to bottom
int j = previousChain.Count;
for (int i = 0; i < j; ++i)
{
HitInfo hitInfo = previousChain.GetHitInfo(i);
RenderElement elem = hitInfo.hitElement;
if (elem != null && elem.VisibleAndHasParent)
{
if (elem.Contains(hitInfo.point))
{
RenderElement found = elem.FindUnderlyingSiblingAtPoint(hitInfo.point);
if (found == null)
{
Point leftTop = elem.Location;
hitPointChain.OffsetTestPoint(leftTop.X, leftTop.Y);
hitPointChain.AddHitObject(elem);
//add to chain
}
else
{
break;
}
}
}
else
{
break;
}
}
}
//---------------------------------
if (hitPointChain.Count > 0)
{
var commonElement = hitPointChain.GetHitInfo(hitPointChain.Count - 1).hitElement;
hitPointChain.RemoveCurrentHit();
return(commonElement);
}
else
{
return(null);
}
}
void SwapHitChain(HitChain hitChain)
{
if (_previousChain != null)
{
_hitChainStack.Push(_previousChain);
}
_previousChain = hitChain;
//temp fix here
_previousChain.Reset();
}
void IEventPortal.PortalMouseMove(UIMouseEventArgs e)
{
HitChain hitPointChain = GetFreeHitChain();
#if DEBUG
hitPointChain.dbugHitPhase = dbugHitChainPhase.MouseMove;
#endif
HitTestCoreWithPrevChainHint(hitPointChain, this._previousChain, e.X, e.Y);
this._previousChain.ClearAll();
SetEventOrigin(e, hitPointChain);
//-------------------------------------------------------
ForEachOnlyEventPortalBubbleUp(e, hitPointChain, (portal) =>
{
portal.PortalMouseMove(e);
return(true);
});
//-------------------------------------------------------
if (!e.CancelBubbling)
{
bool foundSomeHit = false;
ForEachEventListenerBubbleUp(e, hitPointChain, (listener) =>
{
foundSomeHit = true;
bool isFirstMouseEnter = false;
if (e.CurrentMouseActive != null &&
e.CurrentMouseActive != listener)
{
e.CurrentMouseActive.ListenMouseLeave(e);
isFirstMouseEnter = true;
}
if (!e.IsCanceled)
{
e.CurrentMouseActive = listener;
e.IsFirstMouseEnter = isFirstMouseEnter;
e.CurrentMouseActive.ListenMouseMove(e);
e.IsFirstMouseEnter = false;
}
return(true);//stop
});
if (!foundSomeHit && e.CurrentMouseActive != null)
{
e.CurrentMouseActive.ListenMouseLeave(e);
if (!e.IsCanceled)
{
e.CurrentMouseActive = null;
}
}
}
SwapHitChain(hitPointChain);
e.StopPropagation();
}
protected override bool CustomHitTest(HitChain hitChain)
{
hitChain.AddHitObject(this);
if (_gridLayer != null && _gridLayer.HitTestCore(hitChain))
{
return(true);
}
int before = hitChain.Count;
ChildrenHitTestCore(hitChain);
return(before < hitChain.Count);
}
void SwapHitChain(HitChain hitChain)
{
this._previousChain = hitChain;
//temp fix here
this._previousChain.ClearAll();
// hitChain.ClearAll();
//if (isDragging && hitChain.Count < 2)
//{
//}
//hitChain.ClearAll();
//this.hitChainStack.Push(hitChain);
}
static void SetEventOrigin(UIEventArgs e, HitChain hitChain)
{
int count = hitChain.Count;
if (count > 0)
{
e.SetExactHitObject(hitChain.GetHitInfo(count - 1).HitElemAsRenderElement);
}
else
{
e.SetExactHitObject(null);
}
}
public bool HitTestCore(HitChain hitChain)
{
hitChain.GetTestPoint(out int testX, out int testY);
GridCell cell = GetCellByPosition(testX, testY);
if (cell != null && cell.ContentElement is RenderElement renderE)
{
hitChain.OffsetTestPoint(-cell.X, -cell.Y);
renderE.HitTestCore(hitChain);
hitChain.OffsetTestPoint(cell.X, cell.Y);
return(true);
}
return(false);
}
void IEventPortal.PortalMouseMove(UIMouseEventArgs e)
{
HitChain hitPointChain = GetFreeHitChain();
HitTestCoreWithChain(hitPointChain, e.X, e.Y);
SetEventOrigin(e, hitPointChain);
//-------------------------------------------------------
ForEachOnlyEventPortalBubbleUp(e, hitPointChain, (portal) =>
{
portal.PortalMouseMove(e);
return(true);
});
//-------------------------------------------------------
if (!e.CancelBubbling)
{
bool foundSomeHit = false;
ForEachEventListenerBubbleUp(e, hitPointChain, (listener) =>
{
foundSomeHit = true;
bool isFirstMouseEnter = false;
if (e.CurrentMouseActive != null &&
e.CurrentMouseActive != listener)
{
e.CurrentMouseActive.ListenMouseLeave(e);
isFirstMouseEnter = true;
}
if (!e.IsCanceled)
{
e.CurrentMouseActive = listener;
e.IsFirstMouseEnter = isFirstMouseEnter;
e.CurrentMouseActive.ListenMouseMove(e);
e.IsFirstMouseEnter = false;
}
return(true);//stop
});
if (!foundSomeHit && e.CurrentMouseActive != null)
{
e.CurrentMouseActive.ListenMouseLeave(e);
if (!e.IsCanceled)
{
e.CurrentMouseActive = null;
}
}
}
ReleaseHitChain(hitPointChain);
e.StopPropagation();
}
public override void ChildrenHitTestCore(HitChain hitChain)
{
RectD bound = RenderVx.GetBounds();
if (bound.Contains(hitChain.TestPoint.x, hitChain.TestPoint.y))
{
//check exact hit or the vxs part
if (HitTestOnSubPart(RenderVx, hitChain.TextPointX, hitChain.TextPointY))
{
hitChain.AddHitObject(this);
}
}
base.ChildrenHitTestCore(hitChain);
}
// static RenderElement HitTestOnPreviousChain(HitChain hitPointChain, HitChain previousChain, int x, int y)
// {
//#if DEBUG
// if (hitPointChain == previousChain)
// {
// throw new NotSupportedException();
// }
//#endif
// if (previousChain.Count > 0)
// {
// previousChain.SetStartTestPoint(x, y);
// //test on prev chain top to bottom
// int j = previousChain.Count;
// for (int i = 0; i < j; ++i)
// {
// HitInfo hitInfo = previousChain.GetHitInfo(i);
// RenderElement elem = hitInfo.HitElemAsRenderElement;
// if (elem != null && elem.VisibleAndHasParent)
// {
// if (elem.Contains(hitInfo.point))
// {
// RenderElement found = elem.FindUnderlyingSiblingAtPoint(hitInfo.point);
// if (found == null)
// {
// Point leftTop = elem.Location;
// hitPointChain.OffsetTestPoint(leftTop.X, leftTop.Y);
// hitPointChain.AddHitObject(elem);
// //add to chain
// }
// else
// {
// break;
// }
// }
// }
// else
// {
// break;
// }
// }
// }
// //---------------------------------
// if (hitPointChain.Count > 0)
// {
// var commonElement = hitPointChain.GetHitInfo(hitPointChain.Count - 1).HitElemAsRenderElement;
// hitPointChain.RemoveCurrentHit();
// return commonElement;
// }
// else
// {
// return null;
// }
// }
void HitTestCoreWithPrevChainHint(HitChain hitPointChain, HitChain previousChain, int x, int y)
{
//---------------------------------
//test on previous chain first , find common element
hitPointChain.ClearAll();
hitPointChain.SetStartTestPoint(x, y);
#if DEBUG
hitPointChain.dbugHitPhase = _dbugHitChainPhase;
#endif
//if (this.dbugId > 0 && isDragging && previousChain.Count > 1)
//{
//}
//RenderElement commonElement = HitTestOnPreviousChain(hitPointChain, previousChain, x, y);
//temp fix
//TODO: fix bug on HitTestOnPreviousChain()
RenderElement commonElement = _topRenderElement;
////use root
//if (isDragging)
//{
// if (commonElement != this.topRenderElement)
// {
// }
//}
//if (lastCommonElement != null && commonElement != null &&
// lastCommonElement != commonElement && isDragging)
//{
// Console.WriteLine(commonElement.dbug_GetBoundInfo());
//}
//if (commonElement == null)
//{
// commonElement = this.topRenderElement;
//}
//if (commonElement != this.topRenderElement)
//{
//}
//lastCommonElement = commonElement;
commonElement.HitTestCore(hitPointChain);
//this.topRenderElement.HitTestCore(hitPointChain);
}
public override bool HasCustomHitTest => true; //set to true, CustomHitTest() will be called
protected override bool CustomHitTest(HitChain hitChain)
{
if (_approxRectBounds.Contains(hitChain.TestPoint))
{
//in rgn
//check hit test on each child
for (int i = _controlPoints.Count - 1; i >= 0; --i)
{
CustomRenderBox ctrlPoint = _controlPoints[i];
if (ctrlPoint.HitTestCore(hitChain))
{
hitChain.AddHitObject(ctrlPoint);
return(true);
}
}
}
return(false);
}
static void ForEachOnlyEventPortalBubbleUp(UIEventArgs e, HitChain hitPointChain, EventPortalAction eventPortalAction)
{
for (int i = hitPointChain.Count - 1; i >= 0; --i)
{
HitInfo hitPoint = hitPointChain.GetHitInfo(i);
object currentHitElement = hitPoint.hitElement.GetController();
IEventPortal eventPortal = currentHitElement as IEventPortal;
if (eventPortal != null)
{
var ppp = hitPoint.point;
e.CurrentContextElement = currentHitElement as IUIEventListener;
e.SetLocation(ppp.X, ppp.Y);
if (eventPortalAction(eventPortal))
{
return;
}
}
}
}
static void ForEachOnlyEventPortalBubbleUp <T>(T e, HitChain hitPointChain, EventPortalAction <T> eventPortalAction)
where T : UIEventArgs
{
for (int i = hitPointChain.Count - 1; i >= 0; --i)
{
HitInfo hitPoint = hitPointChain.GetHitInfo(i);
object currentHitObj = hitPoint.HitElemAsRenderElement.GetController();
if (currentHitObj is IEventPortal eventPortal)
{
Point p = hitPoint.point;
e.SetCurrentContextElement(currentHitObj as IUIEventListener);
e.SetLocation(p.X, p.Y);
if (eventPortalAction(e, eventPortal))
{
return;
}
}
}
}
public bool HitTestCore(HitChain hitChain)
{
if (LineTop <= hitChain.TestPointY &&
(LineTop + LineHeight) > hitChain.TestPointY)
{
LinkedListNode <RenderElement> node = _linkList.First;
hitChain.OffsetTestPoint(0, -LineTop);
bool found = false;
while (node != null)
{
if (node.Value.HitTestCore(hitChain))
{
found = true;
break;
}
node = node.Next;
}
hitChain.OffsetTestPoint(0, LineTop);
return(found);
}
return(false);
}
public override bool HitTestCore(HitChain hitChain)
{
int testX;
int testY;
hitChain.GetTestPoint(out testX, out testY);
GridCell cell = GetGridItemByPosition(testX, testY);
if (cell != null && cell.HasContent)
{
hitChain.OffsetTestPoint(-cell.X, -cell.Y);
var renderE = cell.ContentElement as RenderElement;
if (renderE != null)
{
renderE.HitTestCore(hitChain);
}
hitChain.OffsetTestPoint(cell.X, cell.Y);
return(true);
}
return(false);
}
// static RenderElement HitTestOnPreviousChain(HitChain hitPointChain, HitChain previousChain, int x, int y)
// {
//#if DEBUG
// if (hitPointChain == previousChain)
// {
// throw new NotSupportedException();
// }
//#endif
// if (previousChain.Count > 0)
// {
// previousChain.SetStartTestPoint(x, y);
// //test on prev chain top to bottom
// int j = previousChain.Count;
// for (int i = 0; i < j; ++i)
// {
// HitInfo hitInfo = previousChain.GetHitInfo(i);
// RenderElement elem = hitInfo.HitElemAsRenderElement;
// if (elem != null && elem.VisibleAndHasParent)
// {
// if (elem.Contains(hitInfo.point))
// {
// RenderElement found = elem.FindUnderlyingSiblingAtPoint(hitInfo.point);
// if (found == null)
// {
// Point leftTop = elem.Location;
// hitPointChain.OffsetTestPoint(leftTop.X, leftTop.Y);
// hitPointChain.AddHitObject(elem);
// //add to chain
// }
// else
// {
// break;
// }
// }
// }
// else
// {
// break;
// }
// }
// }
// //---------------------------------
// if (hitPointChain.Count > 0)
// {
// var commonElement = hitPointChain.GetHitInfo(hitPointChain.Count - 1).HitElemAsRenderElement;
// hitPointChain.RemoveCurrentHit();
// return commonElement;
// }
// else
// {
// return null;
// }
// }
void HitTestCoreWithPrevChainHint(HitChain hitChain, HitChain previousChain, int x, int y)
{
//---------------------------------
//test on previous chain first , find common element
hitChain.Reset();
hitChain.SetStartTestPoint(x, y);
#if DEBUG
hitChain.dbugHitPhase = _dbugHitChainPhase;
#endif
//if (this.dbugId > 0 && isDragging && previousChain.Count > 1)
//{
//}
//RenderElement commonElement = HitTestOnPreviousChain(hitPointChain, previousChain, x, y);
//temp fix
//TODO: fix bug on HitTestOnPreviousChain()
RenderElement commonElement = _topRenderElement;
commonElement.HitTestCore(hitChain);
//remove disable elements
//if (hitPointChain.dbugHitPhase == dbugHitChainPhase.MouseDown)
//{
int j = hitChain.Count;
for (int i = 0; i < j; ++i)
{
HitInfo info = hitChain.GetHitInfo(i);
RenderElement renderE = info.HitElemAsRenderElement;
if (renderE != null && renderE.GetController() is IUIEventListener ui && !ui.Enabled)
{
HitChain.UnsafeClear(hitChain);
break;//stop loop and exit
}
}
//}
}
public virtual void ChildrenHitTestCore(HitChain hitChain)
{
}
