// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void DoDispatchEvent(exUIControl _sender, List <exUIEventListener> _listeners, exUIEvent _event)
{
for (int i = 0; i < _listeners.Count; ++i)
{
exUIEventListener listener = _listeners[i];
//
if (_event.eventPhase == exUIEventPhase.Capture)
{
if (listener.capturePhase == false)
{
continue;
}
}
else if (_event.eventPhase == exUIEventPhase.Bubble)
{
if (listener.capturePhase)
{
continue;
}
}
//
listener.func(_event);
//
// if ( _event.isPropagationStopped )
// break;
}
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public void AddChild(exUIControl _ctrl)
{
if (_ctrl == null)
{
return;
}
if (_ctrl.parent == this)
{
return;
}
// you can not add your parent or yourself as your child
if (_ctrl.IsSelfOrAncestorOf(this))
{
return;
}
exUIControl lastParent = _ctrl.parent;
if (lastParent != null)
{
lastParent.RemoveChild(_ctrl);
}
children.Add(_ctrl);
_ctrl.parent = this;
}
///////////////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////////////////////////////////////
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public void AddControl(exUIControl _ctrl)
{
if (controls.IndexOf(_ctrl) == -1)
{
controls.Add(_ctrl);
exUIMng.FindAndAddChild(_ctrl);
}
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public new void OnSceneGUI()
{
exUIControl ctrl = target as exUIControl;
Vector3[] vertices = ctrl.GetLocalVertices();
if (vertices.Length > 0)
{
Rect aabb = exGeometryUtility.GetAABoundingRect(vertices);
Matrix4x4 l2w = ctrl.transform.localToWorldMatrix;
// draw control rect
vertices = new Vector3[4] {
l2w.MultiplyPoint3x4(new Vector3(aabb.xMin, aabb.yMin, 0)),
l2w.MultiplyPoint3x4(new Vector3(aabb.xMin, aabb.yMax, 0)),
l2w.MultiplyPoint3x4(new Vector3(aabb.xMax, aabb.yMax, 0)),
l2w.MultiplyPoint3x4(new Vector3(aabb.xMax, aabb.yMin, 0)),
};
exEditorUtility.GL_DrawRectLine(vertices, new Color(1.0f, 0.0f, 0.5f, 1.0f), true);
// draw scroll-view content
exUIScrollView scrollView = ctrl as exUIScrollView;
if (scrollView != null)
{
aabb.width = scrollView.contentSize.x;
aabb.yMin = aabb.yMax - scrollView.contentSize.y;
float contentX = (scrollView.horizontalContentDir == exUIScrollView.ContentDirection.LeftToRight) ? 0.0f : (scrollView.contentSize.x - scrollView.width);
float contentY = (scrollView.verticalContentDir == exUIScrollView.ContentDirection.TopToBottom) ? 0.0f : (scrollView.contentSize.y - scrollView.height);
aabb.center += scrollView.scrollOffset;
aabb.center += new Vector2(contentX, contentY);
vertices = new Vector3[4] {
l2w.MultiplyPoint3x4(new Vector3(aabb.xMin, aabb.yMin, 0)),
l2w.MultiplyPoint3x4(new Vector3(aabb.xMin, aabb.yMax, 0)),
l2w.MultiplyPoint3x4(new Vector3(aabb.xMax, aabb.yMax, 0)),
l2w.MultiplyPoint3x4(new Vector3(aabb.xMax, aabb.yMin, 0)),
};
exEditorUtility.GL_DrawRectLine(vertices, new Color(0.0f, 0.5f, 1.0f, 1.0f), true);
}
}
exPlane plane = target as exPlane;
if (plane.hasSprite == false)
{
Vector3 size;
Vector3 center;
bool changed = ProcessSceneEditorHandles(out size, out center);
if (changed)
{
ApplyPlaneScale(plane, size, center);
}
}
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public static exUIControl FindRoot(exUIControl _ctrl)
{
exUIControl root = null;
exUIControl parentCtrl = _ctrl;
while (parentCtrl != null)
{
root = parentCtrl;
parentCtrl = parentCtrl.parent;
}
return(root);
}
public void Reset()
{
active = false;
pressDown = false;
pressUp = false;
pos = Vector2.zero;
delta = Vector2.zero;
worldPos = Vector3.zero;
worldDelta = Vector3.zero;
hover = null;
pressed = null;
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void Awake()
{
exUIControl control = GetComponent <exUIControl>();
if (control != null)
{
Type controlType = control.GetType();
foreach (Emitter emitter in emitterList)
{
EventInfo eventInfo = controlType.GetEvent(emitter.eventName);
if (eventInfo != null)
{
foreach (SlotInfo slot in emitter.slots)
{
bool foundMethod = false;
MonoBehaviour[] allMonoBehaviours = slot.receiver.GetComponents <MonoBehaviour>();
foreach (MonoBehaviour monoBehaviour in allMonoBehaviours)
{
MethodInfo mi = monoBehaviour.GetType().GetMethod(slot.method,
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
null,
new Type [] {
typeof(GameObject),
},
null);
if (mi != null)
{
Delegate delegateForMethod = Delegate.CreateDelegate(typeof(System.Action <GameObject>), monoBehaviour, mi);
eventInfo.AddEventHandler(control, delegateForMethod);
foundMethod = true;
}
}
if (foundMethod == false)
{
Debug.LogWarning("Can not find method " + slot.method + " in " + slot.receiver.name);
}
}
}
else
{
Debug.LogWarning("Can not find event " + emitter.eventName + " in " + gameObject.name);
}
}
}
else
{
Debug.LogWarning("Can not find exUIControl in this GameObject");
}
}
exUIControl focus = null; // the Input focus ( usually, the keyboard focus )
///////////////////////////////////////////////////////////////////////////////
// static functions
///////////////////////////////////////////////////////////////////////////////
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public static List <exUIControl> GetRoutine(exUIControl _ctrl)
{
List <exUIControl> routine = new List <exUIControl>();
exUIControl parentCtrl = _ctrl.parent;
while (parentCtrl != null)
{
routine.Add(parentCtrl);
parentCtrl = parentCtrl.parent;
}
return(routine);
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public void RemoveChild(exUIControl _ctrl)
{
if (_ctrl == null)
{
return;
}
int idx = children.IndexOf(_ctrl);
if (idx != -1)
{
children.RemoveAt(idx);
_ctrl.parent = null;
}
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
static void FindAndAddChildRecursively(exUIControl _ctrl, Transform _trans)
{
foreach (Transform child in _trans)
{
exUIControl childCtrl = child.GetComponent <exUIControl>();
if (childCtrl)
{
_ctrl.AddChild(childCtrl);
FindAndAddChild(childCtrl);
}
else
{
FindAndAddChildRecursively(_ctrl, child);
}
}
}
///////////////////////////////////////////////////////////////////////////////
// functions
///////////////////////////////////////////////////////////////////////////////
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void Awake()
{
exUIControl ctrl = GetComponent <exUIControl>();
if (ctrl)
{
if (scaleInfos != null)
{
for (int j = 0; j < scaleInfos.Count; ++j)
{
EffectInfo_Scale info = scaleInfos[j];
EffectState_Scale state = new EffectState_Scale();
state.info = info;
state.func = info.GetCurveFunction();
AddState_Scale(ctrl, state);
}
}
if (offsetInfos != null)
{
for (int j = 0; j < offsetInfos.Count; ++j)
{
EffectInfo_Offset info = offsetInfos[j];
EffectState_Offset state = new EffectState_Offset();
state.info = info;
state.func = info.GetCurveFunction();
AddState_Offset(ctrl, state);
}
}
if (colorInfos != null)
{
for (int j = 0; j < colorInfos.Count; ++j)
{
EffectInfo_Color info = colorInfos[j];
EffectState_Color state = new EffectState_Color();
state.info = info;
state.func = info.GetCurveFunction();
AddState_Color(ctrl, state);
}
}
}
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
exUIControl RecursivelyGetUIControl(exUIControl _ctrl, Vector2 _worldPos)
{
if (_ctrl.gameObject.activeSelf == false || _ctrl.activeSelf == false)
{
return(null);
}
//
bool checkChildren = false;
if (_ctrl.useCollider)
{
checkChildren = true;
}
else
{
Vector2 localPos = new Vector2(_worldPos.x - _ctrl.transform.position.x,
_worldPos.y - _ctrl.transform.position.y);
Rect boundingRect = _ctrl.GetLocalAABoundingRect();
checkChildren = boundingRect.Contains(localPos);
}
//
if (checkChildren)
{
for (int i = 0; i < _ctrl.children.Count; ++i)
{
exUIControl childCtrl = _ctrl.children[i];
exUIControl resultCtrl = RecursivelyGetUIControl(childCtrl, _worldPos);
if (resultCtrl != null)
{
return(resultCtrl);
}
}
if (_ctrl.useCollider == false)
{
return(_ctrl);
}
}
return(null);
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
exUIControl PickControl(Vector2 _screenPos)
{
// pick 2D controls
Vector3 worldPointerPos = camera.ScreenToWorldPoint(_screenPos);
controls.Sort(controlSorterByPrioirty);
for (int i = 0; i < controls.Count; ++i)
{
exUIControl ctrl = controls[i];
exUIControl resultCtrl = RecursivelyGetUIControl(ctrl, worldPointerPos);
if (resultCtrl != null)
{
return(resultCtrl);
}
}
// pick ray-cast controls
Ray ray = camera.ScreenPointToRay(_screenPos);
ray.origin = new Vector3(ray.origin.x, ray.origin.y, camera.transform.position.z);
RaycastHit[] hits = Physics.RaycastAll(ray);
List <exUIControl> hitControls = new List <exUIControl>();
for (int i = 0; i < hits.Length; ++i)
{
RaycastHit hit = hits[i];
GameObject go = hit.collider.gameObject;
exUIControl ctrl = go.GetComponent <exUIControl>();
if (ctrl && ctrl.gameObject.activeInHierarchy && ctrl.activeInHierarchy)
{
hitControls.Add(ctrl);
}
}
if (hitControls.Count > 0)
{
hitControls.Sort(controlSorterByLevel);
return(hitControls[hitControls.Count - 1]);
}
return(null);
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
static void AddEventListeners(exUIControl _ctrl, string _eventName, List <SlotInfo> _slots)
{
foreach (SlotInfo slot in _slots)
{
bool foundMethod = false;
if (slot.receiver == null)
{
continue;
}
MonoBehaviour[] allMonoBehaviours = slot.receiver.GetComponents <MonoBehaviour>();
for (int i = 0; i < allMonoBehaviours.Length; ++i)
{
MonoBehaviour monoBehaviour = allMonoBehaviours[i];
// don't get method from control
if (monoBehaviour is exUIControl)
{
continue;
}
MethodInfo mi = monoBehaviour.GetType().GetMethod(slot.method,
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
null,
new Type[] { typeof(exUIEvent) },
null);
if (mi != null)
{
Action <exUIEvent> func
= (Action <exUIEvent>)Delegate.CreateDelegate(typeof(Action <exUIEvent>), monoBehaviour, mi);
_ctrl.AddEventListener(_eventName, func, slot.capturePhase);
foundMethod = true;
}
}
if (foundMethod == false)
{
Debug.LogWarning("Can not find method " + slot.method + " in " + slot.receiver.name);
}
}
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public void SetFocus(exUIControl _ctrl)
{
if (focus != _ctrl)
{
exUIControl unfocus = focus;
if (focus != null)
{
exUIFocusEvent focusEvent = new exUIFocusEvent();
focusEvent.relatedTarget = focus;
focus.OnUnfocus(focusEvent);
}
focus = _ctrl;
if (focus != null)
{
exUIFocusEvent focusEvent = new exUIFocusEvent();
focusEvent.relatedTarget = unfocus;
focus.OnFocus(focusEvent);
}
}
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public void AddEffect_Offset(exSpriteBase _target, EffectEventType _type, exEase.Type _curveType, Vector2 _to, float _duration)
{
exUIControl ctrl = GetComponent <exUIControl>();
if (ctrl)
{
EffectInfo_Offset info = new EffectInfo_Offset();
info.duration = _duration;
info.target = _target;
info.normal = _target.offset;
info.curveType = _curveType;
EffectInfo_Offset.PropInfo propInfo = new EffectInfo_Offset.PropInfo();
propInfo.type = _type;
propInfo.val = _to;
info.propInfos.Add(propInfo);
EffectState_Offset state = new EffectState_Offset();
state.info = info;
state.func = info.GetCurveFunction();
AddState_Offset(ctrl, state);
}
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public void AddEffect_Scale(Transform _target, EffectEventType _type, exEase.Type _curveType, Vector3 _to, float _duration)
{
exUIControl ctrl = GetComponent <exUIControl>();
if (ctrl)
{
EffectInfo_Scale info = new EffectInfo_Scale();
info.duration = _duration;
info.target = _target;
info.normal = _target.localScale;
info.curveType = _curveType;
EffectInfo_Scale.PropInfo propInfo = new EffectInfo_Scale.PropInfo();
propInfo.type = _type;
propInfo.val = _to;
info.propInfos.Add(propInfo);
EffectState_Scale state = new EffectState_Scale();
state.info = info;
state.func = info.GetCurveFunction();
AddState_Scale(ctrl, state);
}
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public bool IsSelfOrAncestorOf(exUIControl _ctrl)
{
if (_ctrl == null)
{
return(false);
}
if (_ctrl == this)
{
return(true);
}
exUIControl next = _ctrl.parent;
while (next != null)
{
if (next == this)
{
return(true);
}
next = next.parent;
}
return(false);
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void HandleHotPoints(exHotPoint[] _hotPoints, bool _isMouse)
{
// ========================================================
// handle hover event
// ========================================================
int hotPointCountForMouse = _isMouse ? 1 : _hotPoints.Length;
for (int i = 0; i < hotPointCountForMouse; ++i)
{
exHotPoint hotPoint = _hotPoints[i];
if (hotPoint.active == false)
{
continue;
}
if (hotPoint.pressed != null && hotPoint.pressed.grabMouseOrTouch)
{
continue;
}
// get hot control
exUIControl lastCtrl = hotPoint.hover;
exUIControl curCtrl = PickControl(hotPoint.pos);
hotPoint.hover = curCtrl;
if (lastCtrl != curCtrl)
{
exUIPointInfo pointInfo = new exUIPointInfo();
pointInfo.id = hotPoint.id;
pointInfo.pos = hotPoint.pos;
pointInfo.delta = hotPoint.delta;
pointInfo.worldPos = hotPoint.worldPos;
pointInfo.worldDelta = hotPoint.worldDelta;
exUIPointEvent pointEvent = new exUIPointEvent();
pointEvent.isMouse = hotPoint.isMouse;
pointEvent.pointInfos = new exUIPointInfo [] {
pointInfo
};
// on hover out
if (lastCtrl != null)
{
lastCtrl.OnHoverOut(pointEvent);
}
// on hover in
if (curCtrl != null)
{
pointEvent.Reset();
curCtrl.OnHoverIn(pointEvent);
if (hotPoint.isTouch)
{
hotPoint.pressDown = true;
}
}
}
}
if (_isMouse)
{
for (int i = 1; i < _hotPoints.Length; ++i)
{
_hotPoints[i].hover = _hotPoints[0].hover;
}
// ========================================================
// send scroll wheel event
// ========================================================
float scroll = Input.GetAxis("Mouse ScrollWheel");
if (scroll != 0.0f && _hotPoints[0].hover != null)
{
exUIWheelEvent wheelEvent = new exUIWheelEvent();
wheelEvent.delta = scroll;
_hotPoints[0].hover.OnEXMouseWheel(wheelEvent);
}
}
// ========================================================
// handle press down event
// ========================================================
for (int i = 0; i < _hotPoints.Length; ++i)
{
exHotPoint hotPoint = _hotPoints[i];
if (hotPoint.active == false)
{
continue;
}
if (hotPoint.pressDown)
{
exUIControl curCtrl = hotPoint.hover;
if (hotPoint.pressed != null && hotPoint.pressed.grabMouseOrTouch)
{
curCtrl = hotPoint.pressed;
}
// send press down event
if (curCtrl != null)
{
exUIPointInfo pointInfo = new exUIPointInfo();
pointInfo.id = hotPoint.id;
pointInfo.pos = hotPoint.pos;
pointInfo.delta = hotPoint.delta;
pointInfo.worldPos = hotPoint.worldPos;
pointInfo.worldDelta = hotPoint.worldDelta;
exUIPointEvent pointEvent = new exUIPointEvent();
pointEvent.isMouse = hotPoint.isMouse;
pointEvent.pointInfos = new exUIPointInfo [] {
pointInfo
};
curCtrl.OnPressDown(pointEvent);
}
hotPoint.pressed = curCtrl;
}
}
// ========================================================
// handle moving before press-up
// ========================================================
Dictionary <exUIControl, List <exHotPoint> > moveEvents = new Dictionary <exUIControl, List <exHotPoint> >();
// collect press move event
for (int i = 0; i < _hotPoints.Length; ++i)
{
exHotPoint hotPoint = _hotPoints[i];
if (hotPoint.active == false)
{
continue;
}
if (hotPoint.delta != Vector2.zero)
{
exUIControl curCtrl = hotPoint.hover;
if (hotPoint.pressed != null && hotPoint.pressed.grabMouseOrTouch)
{
curCtrl = hotPoint.pressed;
}
if (curCtrl != null)
{
List <exHotPoint> hotPointList = null;
if (moveEvents.ContainsKey(curCtrl))
{
hotPointList = moveEvents[curCtrl];
}
else
{
hotPointList = new List <exHotPoint>();
moveEvents.Add(curCtrl, hotPointList);
}
hotPointList.Add(hotPoint);
}
}
}
// send hot-point move event
foreach (KeyValuePair <exUIControl, List <exHotPoint> > iter in moveEvents)
{
exUIPointEvent pointEvent = new exUIPointEvent();
pointEvent.pointInfos = new exUIPointInfo [iter.Value.Count];
for (int i = 0; i < iter.Value.Count; ++i)
{
exHotPoint hotPoint = iter.Value[i];
exUIPointInfo pointInfo = new exUIPointInfo();
pointInfo.id = hotPoint.id;
pointInfo.pos = hotPoint.pos;
pointInfo.delta = hotPoint.delta;
pointInfo.worldPos = hotPoint.worldPos;
pointInfo.worldDelta = hotPoint.worldDelta;
pointEvent.pointInfos[i] = pointInfo;
pointEvent.isMouse = hotPoint.isMouse;
}
iter.Key.OnHoverMove(pointEvent);
}
// ========================================================
// handle press up event
// ========================================================
for (int i = 0; i < _hotPoints.Length; ++i)
{
exHotPoint hotPoint = _hotPoints[i];
if (hotPoint.active == false)
{
continue;
}
//
if (hotPoint.pressUp)
{
exUIPointInfo pointInfo = new exUIPointInfo();
pointInfo.id = hotPoint.id;
pointInfo.pos = hotPoint.pos;
pointInfo.delta = hotPoint.delta;
pointInfo.worldPos = hotPoint.worldPos;
pointInfo.worldDelta = hotPoint.worldDelta;
exUIPointEvent pointEvent = new exUIPointEvent();
pointEvent.isMouse = hotPoint.isMouse;
pointEvent.pointInfos = new exUIPointInfo [] {
pointInfo
};
exUIControl curCtrl = hotPoint.hover;
if (hotPoint.pressed != null && hotPoint.pressed.grabMouseOrTouch)
{
curCtrl = hotPoint.pressed;
}
// send press down event
if (curCtrl != null)
{
curCtrl.OnPressUp(pointEvent);
if (hotPoint.isTouch)
{
curCtrl.OnHoverOut(pointEvent);
}
}
hotPoint.pressed = null;
}
}
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public static exUIControl FindParent(exUIControl _ctrl)
{
return(_ctrl.FindParentComponent());
}
public void Reset()
{
isPropagationStopped_ = false;
target = null;
currentTarget = null;
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
protected override void DoInspectorGUI()
{
base.DoInspectorGUI();
// if settingsStyles is null
if (styles == null)
{
styles = new Styles();
}
//
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (GUILayout.Button("Sync Size", GUILayout.Width(70), GUILayout.Height(20)))
{
exPlane targetPlane = target as exPlane;
if (targetPlane.hasSprite)
{
exSpriteBase spriteBase = targetPlane.GetComponent <exSpriteBase>();
if (targetPlane.width != spriteBase.width)
{
targetPlane.width = spriteBase.width;
EditorUtility.SetDirty(targetPlane);
}
if (targetPlane.height != spriteBase.height)
{
targetPlane.height = spriteBase.height;
EditorUtility.SetDirty(targetPlane);
}
if (targetPlane.anchor != spriteBase.anchor)
{
targetPlane.anchor = spriteBase.anchor;
EditorUtility.SetDirty(targetPlane);
}
if (targetPlane.offset != spriteBase.offset)
{
targetPlane.offset = spriteBase.offset;
EditorUtility.SetDirty(targetPlane);
}
}
}
GUILayout.EndHorizontal();
//
EditorGUILayout.Space();
EditorGUILayout.PropertyField(priorityProp);
// active
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(activeProp, new GUIContent("Active"));
if (EditorGUI.EndChangeCheck())
{
foreach (Object obj in serializedObject.targetObjects)
{
exUIControl ctrl = obj as exUIControl;
if (ctrl)
{
ctrl.activeSelf = activeProp.boolValue;
EditorUtility.SetDirty(ctrl);
}
}
}
// grabMouseOrTouch
EditorGUILayout.PropertyField(grabMouseOrTouchProp, new GUIContent("Grab Mouse Or Touch"));
// use collider
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(useColliderProp, new GUIContent("Use Collider"));
if (EditorGUI.EndChangeCheck())
{
if (useColliderProp.boolValue)
{
foreach (Object obj in serializedObject.targetObjects)
{
exUIControl ctrl = obj as exUIControl;
if (ctrl)
{
Collider collider = ctrl.GetComponent <Collider>();
if (collider == null)
{
collider = ctrl.gameObject.AddComponent <BoxCollider>();
}
BoxCollider boxCollider = collider as BoxCollider;
if (boxCollider != null)
{
Rect localRect = ctrl.GetLocalAABoundingRect();
boxCollider.center = new Vector3(localRect.center.x, localRect.center.y, boxCollider.center.z);
boxCollider.size = new Vector3(localRect.width, localRect.height, boxCollider.size.z);
}
}
}
}
else
{
foreach (Object obj in serializedObject.targetObjects)
{
exUIControl ctrl = obj as exUIControl;
if (ctrl)
{
Collider[] colliders = ctrl.GetComponents <Collider>();
for (int i = 0; i < colliders.Length; ++i)
{
Object.DestroyImmediate(colliders[i]);
}
}
}
}
}
if (useColliderProp.boolValue)
{
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (GUILayout.Button("Sync Collider", GUILayout.MinWidth(50), GUILayout.Height(20)))
{
foreach (Object obj in serializedObject.targetObjects)
{
exUIControl ctrl = obj as exUIControl;
if (ctrl)
{
BoxCollider boxCollider = ctrl.GetComponent <BoxCollider>();
Rect localRect = ctrl.GetLocalAABoundingRect();
boxCollider.center = new Vector3(localRect.center.x, localRect.center.y, boxCollider.center.z);
boxCollider.size = new Vector3(localRect.width, localRect.height, boxCollider.size.z);
}
}
}
EditorGUILayout.EndHorizontal();
}
if (serializedObject.isEditingMultipleObjects == false)
{
exUIControl uiControl = target as exUIControl;
// event adding selector
List <string> eventDefNameList = new List <string>();
eventDefNameList.Add("Event List");
eventDefNameList.AddRange(uiControl.GetEventNames());
foreach (exUIControl.EventTrigger eventTrigger in uiControl.events)
{
int idx = eventDefNameList.IndexOf(eventTrigger.name);
if (idx != -1)
{
eventDefNameList.RemoveAt(idx);
}
}
int choice = EditorGUILayout.Popup("Add Event", 0, eventDefNameList.ToArray());
if (choice != 0)
{
exUIControl.EventTrigger newTrigger = new exUIControl.EventTrigger(eventDefNameList[choice]);
uiControl.events.Add(newTrigger);
EditorUtility.SetDirty(target);
}
// event triggers
for (int i = 0; i < uiControl.events.Count; ++i)
{
EditorGUILayout.Space();
exUIControl.EventTrigger eventTrigger = uiControl.events[i];
if (EventField(eventTrigger))
{
uiControl.events.RemoveAt(i);
--i;
EditorUtility.SetDirty(target);
}
EditorGUILayout.Space();
}
}
EditorGUILayout.Space();
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void DrawControlNode( exUIControl _ctrl )
{
Vector3[] vertices = _ctrl.GetLocalVertices();
if (vertices.Length > 0) {
Rect aabb = exGeometryUtility.GetAABoundingRect(vertices);
Matrix4x4 l2w = _ctrl.transform.localToWorldMatrix;
// draw control rect
vertices = new Vector3[4] {
l2w.MultiplyPoint3x4(new Vector3(aabb.xMin, aabb.yMin, 0)),
l2w.MultiplyPoint3x4(new Vector3(aabb.xMin, aabb.yMax, 0)),
l2w.MultiplyPoint3x4(new Vector3(aabb.xMax, aabb.yMax, 0)),
l2w.MultiplyPoint3x4(new Vector3(aabb.xMax, aabb.yMin, 0)),
};
exEditorUtility.GL_DrawRectLine(vertices, new Color( 1.0f, 0.0f, 0.5f, 1.0f ), true);
// draw scroll-view content
exUIScrollView scrollView = _ctrl as exUIScrollView;
if ( scrollView != null ) {
aabb.width = scrollView.contentSize.x;
aabb.yMin = aabb.yMax - scrollView.contentSize.y;
float contentX = (scrollView.horizontalContentDir == exUIScrollView.ContentDirection.LeftToRight) ? 0.0f : (scrollView.contentSize.x-scrollView.width);
float contentY = (scrollView.verticalContentDir == exUIScrollView.ContentDirection.TopToBottom) ? 0.0f : (scrollView.contentSize.y-scrollView.height);
aabb.center += scrollView.scrollOffset;
aabb.center += new Vector2( contentX, contentY );
vertices = new Vector3[4] {
l2w.MultiplyPoint3x4(new Vector3(aabb.xMin, aabb.yMin, 0)),
l2w.MultiplyPoint3x4(new Vector3(aabb.xMin, aabb.yMax, 0)),
l2w.MultiplyPoint3x4(new Vector3(aabb.xMax, aabb.yMax, 0)),
l2w.MultiplyPoint3x4(new Vector3(aabb.xMax, aabb.yMin, 0)),
};
exEditorUtility.GL_DrawRectLine(vertices, new Color( 0.0f, 0.5f, 1.0f, 1.0f ), true);
}
}
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public void DispatchEvent(exUIControl _sender, string _name, List <exUIEventListener> _listeners, exUIEvent _event)
{
_event.target = _sender;
if (_event.bubbles)
{
List <exUIControl> routine = GetRoutine(_sender);
// capture phase
if (_listeners != null)
{
for (int i = 0; i < _listeners.Count; ++i)
{
exUIEventListener listener = _listeners[i];
if (listener.capturePhase)
{
_event.eventPhase = exUIEventPhase.Capture;
for (int j = routine.Count - 1; j >= 0; --j)
{
exUIControl sender2 = routine[j];
List <exUIEventListener> listeners2 = sender2.GetEventListeners(_name);
_event.currentTarget = sender2;
DoDispatchEvent(sender2, listeners2, _event);
if (_event.isPropagationStopped)
{
return;
}
}
}
}
}
// target phase
if (_listeners != null)
{
_event.eventPhase = exUIEventPhase.Target;
_event.currentTarget = _sender;
DoDispatchEvent(_sender, _listeners, _event);
if (_event.isPropagationStopped)
{
return;
}
}
// bubble phase
_event.eventPhase = exUIEventPhase.Bubble;
for (int j = 0; j < routine.Count; ++j)
{
exUIControl sender2 = routine[j];
List <exUIEventListener> listeners2 = sender2.GetEventListeners(_name);
_event.currentTarget = sender2;
DoDispatchEvent(sender2, listeners2, _event);
if (_event.isPropagationStopped)
{
return;
}
}
}
else
{
_event.eventPhase = exUIEventPhase.Target;
_event.currentTarget = _sender;
DoDispatchEvent(_sender, _listeners, _event);
}
}
public void DispatchEvent(exUIControl _sender, string _name, exUIEvent _event)
{
List <exUIEventListener> listeners = _sender.GetEventListeners(_name);
DispatchEvent(_sender, _name, listeners, _event);
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void AddState_Color(exUIControl _ctrl, EffectState_Color _state)
{
for (int i = 0; i < _state.info.propInfos.Count; ++i)
{
EffectInfo_Color.PropInfo propInfo = _state.info.propInfos[i];
switch (propInfo.type)
{
case EffectEventType.Deactive:
_ctrl.AddEventListener("onDeactive",
delegate(exUIEvent _event) {
enabled = true;
_state.Begin(propInfo.val);
});
_ctrl.AddEventListener("onActive",
delegate(exUIEvent _event) {
enabled = true;
_state.Begin(_state.info.normal);
});
break;
case EffectEventType.Press:
_ctrl.AddEventListener("onPressDown",
delegate(exUIEvent _event) {
enabled = true;
_state.Begin(propInfo.val);
});
_ctrl.AddEventListener("onPressUp",
delegate(exUIEvent _event) {
enabled = true;
_state.Begin(_state.info.GetValue(EffectEventType.Hover));
});
break;
case EffectEventType.Hover:
_ctrl.AddEventListener("onHoverIn",
delegate(exUIEvent _event) {
enabled = true;
_state.Begin(propInfo.val);
});
_ctrl.AddEventListener("onHoverOut",
delegate(exUIEvent _event) {
enabled = true;
_state.Begin(_state.info.normal);
});
break;
case EffectEventType.Unchecked:
exUIToggle toggle = _ctrl as exUIToggle;
if (toggle != null)
{
_ctrl.AddEventListener("onUnchecked",
delegate(exUIEvent _event) {
enabled = true;
_state.Begin(propInfo.val);
});
_ctrl.AddEventListener("onChecked",
delegate(exUIEvent _event) {
enabled = true;
_state.Begin(_state.info.GetValue(EffectEventType.Hover));
});
}
break;
}
}
states.Add(_state);
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public void HoverOut(exUIControl _ctrl, int _id)
{
exHotPoint[] hotPoints = null;
if (hasTouch || simulateMouseAsTouch)
{
hotPoints = touchPoints;
}
else
{
hotPoints = mousePoints;
}
//
for (int i = 0; i < hotPoints.Length; ++i)
{
exHotPoint hotPoint = hotPoints[i];
if (hotPoint.active == false)
{
continue;
}
if (hotPoint.id != _id)
{
continue;
}
exUIPointInfo pointInfo = new exUIPointInfo();
pointInfo.id = hotPoint.id;
pointInfo.pos = hotPoint.pos;
pointInfo.delta = hotPoint.delta;
pointInfo.worldPos = hotPoint.worldPos;
pointInfo.worldDelta = hotPoint.worldDelta;
exUIPointEvent pointEvent = new exUIPointEvent();
pointEvent.isMouse = hotPoint.isMouse;
pointEvent.pointInfos = new exUIPointInfo [] {
pointInfo
};
// on hover out
if (_ctrl != null)
{
_ctrl.OnHoverOut(pointEvent);
}
hotPoint.hover = null;
// on hover in
if (_ctrl.parent != null)
{
pointEvent.Reset();
hotPoint.hover = _ctrl.parent;
_ctrl.parent.OnHoverIn(pointEvent);
if (hotPoint.isTouch)
{
pointEvent.Reset();
hotPoint.pressed = _ctrl.parent;
_ctrl.parent.OnPressDown(pointEvent);
}
}
}
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void AddState_Scale( exUIControl _ctrl, EffectState_Scale _state )
{
for ( int i = 0; i < _state.info.propInfos.Count; ++i ) {
EffectInfo_Scale.PropInfo propInfo = _state.info.propInfos[i];
switch ( propInfo.type ) {
case EffectEventType.Deactive:
_ctrl.AddEventListener( "onDeactive",
delegate ( exUIEvent _event ) {
enabled = true;
_state.Begin( propInfo.val );
} );
_ctrl.AddEventListener( "onActive",
delegate ( exUIEvent _event ) {
enabled = true;
_state.Begin( _state.info.normal );
} );
break;
case EffectEventType.Press:
_ctrl.AddEventListener ( "onPressDown",
delegate ( exUIEvent _event ) {
enabled = true;
_state.Begin( propInfo.val );
} );
_ctrl.AddEventListener ( "onPressUp",
delegate ( exUIEvent _event ) {
enabled = true;
_state.Begin( _state.info.GetValue( EffectEventType.Hover ) );
} );
_ctrl.AddEventListener ( "onHoverOut",
delegate ( exUIEvent _event ) {
if ( _ctrl.grabMouseOrTouch == false ) {
enabled = true;
_state.Begin( _state.info.normal );
}
} );
break;
case EffectEventType.Hover:
_ctrl.AddEventListener ( "onHoverIn",
delegate ( exUIEvent _event ) {
enabled = true;
_state.Begin( propInfo.val );
} );
_ctrl.AddEventListener ( "onHoverOut",
delegate ( exUIEvent _event ) {
enabled = true;
_state.Begin( _state.info.normal );
} );
break;
case EffectEventType.Unchecked:
exUIToggle toggle = _ctrl as exUIToggle;
if ( toggle != null ) {
_ctrl.AddEventListener ( "onUnchecked",
delegate ( exUIEvent _event ) {
enabled = true;
_state.Begin( propInfo.val );
} );
_ctrl.AddEventListener ( "onChecked",
delegate ( exUIEvent _event ) {
enabled = true;
_state.Begin( _state.info.GetValue( EffectEventType.Hover ) );
} );
}
break;
}
}
states.Add(_state);
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public static void FindAndAddChild(exUIControl _ctrl)
{
_ctrl.children.Clear();
FindAndAddChildRecursively(_ctrl, _ctrl.transform);
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
protected exUIControl.SlotInfo SlotField( exUIControl.SlotInfo _slot )
{
exUIControl.SlotInfo slot = _slot;
System.Type[] parameterTypes = new System.Type[] { typeof(exUIEvent) };
EditorGUILayout.BeginHorizontal();
// receiver
EditorGUI.BeginChangeCheck();
slot.receiver = EditorGUILayout.ObjectField( slot.receiver, typeof(GameObject), true ) as GameObject;
if ( EditorGUI.EndChangeCheck() ) {
EditorUtility.SetDirty(target);
}
if ( slot.receiver != null ) {
// get valid methods
List<string> methodNames = new List<string>();
methodNames.Add( "None" );
MonoBehaviour[] allMonoBehaviours = slot.receiver.GetComponents<MonoBehaviour>();
for ( int i = 0; i < allMonoBehaviours.Length; ++i ) {
MonoBehaviour monoBehaviour = allMonoBehaviours[i];
// don't get method from control
if ( monoBehaviour is exUIControl )
continue;
MethodInfo[] methods = monoBehaviour.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
for ( int m = 0; m < methods.Length; ++m ) {
MethodInfo mi = methods[m];
ParameterInfo[] miParameterTypes = mi.GetParameters();
if ( mi.ReturnType == typeof(void) &&
miParameterTypes.Length == parameterTypes.Length )
{
bool notMatch = false;
for ( int p = 0; p < miParameterTypes.Length; ++p ) {
if ( miParameterTypes[p].ParameterType != parameterTypes[p] ) {
notMatch = true;
break;
}
}
if ( notMatch == false && methodNames.IndexOf(mi.Name) == -1 ) {
methodNames.Add(mi.Name);
}
}
}
}
EditorGUI.BeginChangeCheck();
int choice = methodNames.IndexOf(_slot.method);
choice = EditorGUILayout.Popup ( choice == -1 ? 0 : choice, methodNames.ToArray(), GUILayout.Width(100) );
if ( EditorGUI.EndChangeCheck() ) {
_slot.method = methodNames[choice];
EditorUtility.SetDirty(target);
}
}
else {
slot = null;
}
// Delete
if ( GUILayout.Button( styles.iconToolbarMinus, "InvisibleButton", GUILayout.Width(20f) ) ) {
slot = null;
}
GUILayout.Space(3f);
EditorGUILayout.EndHorizontal();
return slot;
}
public void Reset()
{
isPropagationStopped_ = false;
target = null;
currentTarget = null;
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
// public void DispatchEvent ( exUIControl _sender, List<exUIEventListener> _eventListeners, exUIEvent _event ) {
// if ( _eventListeners.Count <= 0 )
// return;
// if ( _event.bubbles ) {
// List<exUIControl> routine = GetRoutine( _sender );
// _event.target = _sender;
// for ( int i = 0; i < _eventListeners.Count; ++i ) {
// exUIEventListener listener = _eventListeners[i];
// // capture phase
// if ( listener.capturePhase ) {
// _event.eventPhase = exUIEventPhase.Capture;
// for ( int j = routine.Count-1; j >= 0; --j ) {
// _event.currentTarget = routine[j];
// listener.func ( _event );
// if ( _event.isPropagationStopped )
// break;
// }
// if ( _event.isPropagationStopped )
// continue;
// }
// // target phase
// _event.eventPhase = exUIEventPhase.Target;
// _event.currentTarget = _sender;
// listener.func ( _event );
// if ( _event.isPropagationStopped )
// continue;
// // bubble phase
// _event.eventPhase = exUIEventPhase.Bubble;
// for ( int j = 0; j < routine.Count; ++j ) {
// _event.currentTarget = routine[j];
// listener.func ( _event );
// if ( _event.isPropagationStopped )
// break;
// }
// }
// }
// else {
// _event.target = _sender;
// for ( int i = 0; i < _eventListeners.Count; ++i ) {
// exUIEventListener listener = _eventListeners[i];
// // target phase
// _event.eventPhase = exUIEventPhase.Target;
// _event.currentTarget = _sender;
// listener.func ( _event );
// if ( _event.isPropagationStopped )
// break;
// }
// }
// }
// ------------------------------------------------------------------
// Desc:
// NOTE: FindObjectsOfType() will not find deactived GameObjects,
// so you need to manually add them to exUIMng
// ------------------------------------------------------------------
void Init()
{
if (initialized)
{
return;
}
//
if (camera == null)
{
Debug.LogError("The exUIMng should attach to a camera");
return;
}
//
if (Application.platform == RuntimePlatform.Android ||
Application.platform == RuntimePlatform.IPhonePlayer
#if UNITY_4_2
|| Application.platform == RuntimePlatform.WP8Player ||
Application.platform == RuntimePlatform.BB10Player
#endif
)
{
hasMouse = false;
hasTouch = true;
// hasKeyboard = false;
// hasController = true;
}
else if (Application.platform == RuntimePlatform.PS3 ||
Application.platform == RuntimePlatform.XBOX360
)
{
hasMouse = false;
hasTouch = false;
// hasKeyboard = false;
// hasController = true;
}
else if (Application.platform == RuntimePlatform.WindowsEditor ||
Application.platform == RuntimePlatform.OSXEditor
)
{
hasMouse = true;
hasTouch = false;
// hasKeyboard = true;
// hasController = true;
}
//
for (int i = 0; i < 10; ++i)
{
touchPoints[i] = new exHotPoint();
touchPoints[i].Reset();
touchPoints[i].id = i;
}
for (int i = 0; i < 3; ++i)
{
mousePoints[i] = new exHotPoint();
mousePoints[i].Reset();
mousePoints[i].id = i;
mousePoints[i].isMouse = true;
}
// find all controls in the scene, and add root controls to UIMng
exUIControl[] allControls = FindObjectsOfType(typeof(exUIControl)) as exUIControl[];
for (int i = 0; i < allControls.Length; ++i)
{
exUIControl ctrl = allControls[i];
exUIControl parent_ctrl = exUIMng.FindParent(ctrl);
if (parent_ctrl == null)
{
AddControl(ctrl);
}
}
//
initialized = true;
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
protected bool EventField( exUIControl.EventTrigger _eventTrigger )
{
bool deleted = false;
GUILayout.BeginHorizontal();
GUILayout.Space(4f);
GUILayout.BeginVertical();
EditorGUILayout.BeginHorizontal();
// name
GUILayout.Toggle( true, _eventTrigger.name, "dragtab");
// delete
if ( GUILayout.Button( styles.iconToolbarMinus,
"InvisibleButton",
GUILayout.Width(styles.iconToolbarMinus.width),
GUILayout.Height(styles.iconToolbarMinus.height) ) )
{
deleted = true;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal("AS TextArea", GUILayout.MinHeight(10f));
GUILayout.BeginVertical();
// slots
for ( int i = 0; i < _eventTrigger.slots.Count; ++i ) {
exUIControl.SlotInfo slotInfo = SlotField ( _eventTrigger.slots[i] );
if ( slotInfo == null ) {
_eventTrigger.slots.RemoveAt(i);
--i;
EditorUtility.SetDirty(target);
}
}
// new slot
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GameObject receiver = EditorGUILayout.ObjectField( null, typeof(GameObject), true, GUILayout.Width(150) ) as GameObject;
if ( receiver != null ) {
exUIControl.SlotInfo slotInfo = new exUIControl.SlotInfo();
slotInfo.receiver = receiver;
_eventTrigger.slots.Add(slotInfo);
EditorUtility.SetDirty(target);
}
GUILayout.Label( styles.iconToolbarPlus, GUILayout.Width(20) );
EditorGUILayout.EndHorizontal();
GUILayout.EndVertical();
EditorGUILayout.EndHorizontal();
GUILayout.EndVertical();
GUILayout.Space(4f);
GUILayout.EndHorizontal();
return deleted;
}