private void OnAttachToPanel(AttachToPanelEvent e)
{
var h = textHandle;
h.useLegacy = e.destinationPanel.contextType == ContextType.Editor;
textHandle = h;
}
static void OnOptionAttachToPanel(AttachToPanelEvent evt)
{
var element = evt.currentTarget as VisualElement;
var option = evt.currentTarget as IGroupBoxOption;
IGroupManager groupManager = null;
var hierarchyParent = element.hierarchy.parent;
while (hierarchyParent != null)
{
if (hierarchyParent is IGroupBox groupBox)
{
groupManager = FindOrCreateGroupManager(groupBox);
break;
}
hierarchyParent = hierarchyParent.hierarchy.parent;
}
if (groupManager == null)
{
groupManager = FindOrCreateGroupManager(element.elementPanel);
}
groupManager.RegisterOption(option);
s_GroupOptionManagerCache[option] = groupManager;
}
private void OnAttachToPanel(AttachToPanelEvent evt)
{
int num = 0;
for (int i = 0; i <= Foldout.ussFoldoutMaxDepth; i++)
{
base.RemoveFromClassList(Foldout.ussFoldoutDepthClassName + i.ToString());
}
base.RemoveFromClassList(Foldout.ussFoldoutDepthClassName + "max");
bool flag = base.parent != null;
if (flag)
{
for (VisualElement parent = base.parent; parent != null; parent = parent.parent)
{
bool flag2 = parent.GetType() == typeof(Foldout);
if (flag2)
{
num++;
}
}
}
bool flag3 = num > Foldout.ussFoldoutMaxDepth;
if (flag3)
{
base.AddToClassList(Foldout.ussFoldoutDepthClassName + "max");
}
else
{
base.AddToClassList(Foldout.ussFoldoutDepthClassName + num.ToString());
}
}
private void OnAttachToPanel(AttachToPanelEvent e)
{
TextHandle textHandle = this.textHandle;
textHandle.useLegacy = (e.destinationPanel.contextType == ContextType.Editor);
this.textHandle = textHandle;
}
void OnEnter(AttachToPanelEvent evt)
{
if (isActive)
{
SendActivation();
}
}
private void OnEnter(AttachToPanelEvent evt)
{
bool isActive = this.isActive;
if (isActive)
{
this.SendActivation();
}
}
private void OnAttachToPanel(AttachToPanelEvent evt)
{
if (evt.destinationPanel == null)
{
return;
}
if (evt.destinationPanel.contextType == ContextType.Player)
{
contentViewport.RegisterCallback <PointerDownEvent>(OnPointerDown);
contentViewport.RegisterCallback <PointerMoveEvent>(OnPointerMove);
contentViewport.RegisterCallback <PointerUpEvent>(OnPointerUp);
}
}
protected override void ExecuteDefaultAction(EventBase evt)
{
if (evt == null)
{
return;
}
// no call to base.ExecuteDefaultAction(evt):
// - we dont want mouse click to directly give focus to IMGUIContainer:
// they should be handled by IMGUI and if an IMGUI control grabs the
// keyboard, the IMGUIContainer will gain focus via FocusController.SyncIMGUIFocus.
// - same thing for tabs: IMGUI should handle them.
// - we dont want to set the PseudoState.Focus flag on IMGUIContainer.
// They are focusable, but only for the purpose of focusing their children.
// Here, we set flags that will be acted upon in DoOnGUI(), since we need to change IMGUI state.
if (evt.eventTypeId == BlurEvent.TypeId())
{
// A lost focus event is ... a lost focus event.
// The specific handling of the IMGUI will be done in the DoOnGUI() above...
lostFocus = true;
// On lost focus, we need to repaint to remove any focused element blue borders.
IncrementVersion(VersionChangeType.Repaint);
}
else if (evt.eventTypeId == FocusEvent.TypeId())
{
FocusEvent fe = evt as FocusEvent;
receivedFocus = true;
focusChangeDirection = fe.direction;
m_IsFocusDelegated = fe.IsFocusDelegated;
}
else if (evt.eventTypeId == DetachFromPanelEvent.TypeId())
{
if (elementPanel != null)
{
elementPanel.IMGUIContainersCount--;
}
}
else if (evt.eventTypeId == AttachToPanelEvent.TypeId())
{
if (elementPanel != null)
{
elementPanel.IMGUIContainersCount++;
// Set class names for foldout depth.
SetFoldoutDepthClass();
}
}
}
void OnAttachToPanel(AttachToPanelEvent evt)
{
if (evt.destinationPanel == null)
{
return;
}
contentContainer.AddManipulator(m_NavigationManipulator = new KeyboardNavigationManipulator(Apply));
m_MenuContainer.RegisterCallback <PointerMoveEvent>(OnPointerMove);
m_MenuContainer.RegisterCallback <PointerUpEvent>(OnPointerUp);
evt.destinationPanel.visualTree.RegisterCallback <GeometryChangedEvent>(OnParentResized);
m_ScrollView.RegisterCallback <GeometryChangedEvent>(EnsureVisibilityInParent);
m_ScrollView.RegisterCallback <FocusOutEvent>(OnFocusOut);
}
private void OnAttachToPanel(AttachToPanelEvent evt)
{
bool flag = evt.destinationPanel == null;
if (!flag)
{
bool flag2 = evt.destinationPanel.contextType == ContextType.Player;
if (flag2)
{
this.contentViewport.RegisterCallback <PointerDownEvent>(new EventCallback <PointerDownEvent>(this.OnPointerDown), TrickleDown.NoTrickleDown);
this.contentViewport.RegisterCallback <PointerMoveEvent>(new EventCallback <PointerMoveEvent>(this.OnPointerMove), TrickleDown.NoTrickleDown);
this.contentViewport.RegisterCallback <PointerUpEvent>(new EventCallback <PointerUpEvent>(this.OnPointerUp), TrickleDown.NoTrickleDown);
}
}
}
public override void HandleEvent(EventBase evt)
{
if (evt.eventTypeId == AttachToPanelEvent.TypeId() && evt is AttachToPanelEvent attachEvent)
{
textHandle = attachEvent.destinationPanel.contextType == ContextType.Editor
? TextHandleFactory.GetEditorHandle()
: TextHandleFactory.GetRuntimeHandle();
#if UNITY_EDITOR
(attachEvent.destinationPanel as BaseVisualElementPanel)?.OnTextElementAdded(this);
#endif
}
else if (evt.eventTypeId == DetachFromPanelEvent.TypeId() && evt is DetachFromPanelEvent detachEvent)
{
#if UNITY_EDITOR
(detachEvent.originPanel as BaseVisualElementPanel)?.OnTextElementRemoved(this);
#endif
}
base.HandleEvent(evt);
}
private void OnAttachToPanel(AttachToPanelEvent evt)
{
if (evt.destinationPanel == null)
{
return;
}
if (evt.destinationPanel.contextType == ContextType.Player)
{
// In the editor, we need PickingMode.Ignore so users can pick IMGUI dockarea
// splitters behind the scroll view. In the runtime, since we support touch,
// we need to support picking there.
contentViewport.pickingMode = PickingMode.Position;
contentViewport.RegisterCallback <PointerDownEvent>(OnPointerDown);
contentViewport.RegisterCallback <PointerMoveEvent>(OnPointerMove);
contentViewport.RegisterCallback <PointerUpEvent>(OnPointerUp);
}
}
private void OnAttachToPanel(AttachToPanelEvent evt)
{
if (evt.destinationPanel == null)
{
return;
}
if (evt.destinationPanel.contextType == ContextType.Editor)
{
m_ScrollView.contentContainer.RegisterCallback <MouseDownEvent>(OnMouseDown);
m_ScrollView.contentContainer.RegisterCallback <MouseUpEvent>(OnMouseUp);
}
else if (evt.destinationPanel.contextType == ContextType.Player)
{
m_ScrollView.contentContainer.RegisterCallback <PointerDownEvent>(OnPointerDown);
m_ScrollView.contentContainer.RegisterCallback <PointerUpEvent>(OnPointerUp);
}
m_ScrollView.contentContainer.RegisterCallback <KeyDownEvent>(OnKeyDown);
}
private void OnAttachToPanel(AttachToPanelEvent e)
{
m_TextHandle.useLegacy = e.destinationPanel.contextType == ContextType.Editor;
}
private void OnAttachToPanel(AttachToPanelEvent e)
{
m_TextHandle = e.destinationPanel.contextType == ContextType.Editor
? TextHandleFactory.GetEditorHandle()
: TextHandleFactory.GetRuntimeHandle();
}
private void OnAttachToPanel(AttachToPanelEvent attachEvent)
{
(attachEvent.destinationPanel as BaseVisualElementPanel)?.liveReloadSystem.RegisterTextElement(this);
}
private void RegisterCallbacksFromTarget(AttachToPanelEvent evt)
{
RegisterCallbacksFromTarget();
}
