void Update()
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hitInfo;
if (Physics.Raycast(ray, out hitInfo, Mathf.Infinity))
{
if (hover_state == HoverState.NONE)
{
// -- not used, but may be useful :
// -- hitInfo.collider.SendMessage("OnMouseEnter", SendMessageOptions.DontRequireReceiver);
// -- hitInfo.transform.gameObject.GetComponent<TileScript>().myName = "yo";
hoverObject = hitInfo.transform.gameObject.GetComponent <TileScript>();
hoverObject.IsSelected = true;
}
hover_state = HoverState.HOVER;
selected();
}
else
{
if (hover_state == HoverState.HOVER)
{
//if (!hoverObject) {
hoverObject.IsSelected = false;
hoverObject.SetVisual();
//}
}
///hoverObject = null;
hover_state = HoverState.NONE;
}
}
void Update() {
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hitInfo;
if (Physics.Raycast(ray, out hitInfo, Mathf.Infinity)) {
if (hover_state == HoverState.NONE) {
// -- not used, but may be useful :
// -- hitInfo.collider.SendMessage("OnMouseEnter", SendMessageOptions.DontRequireReceiver);
// -- hitInfo.transform.gameObject.GetComponent<TileScript>().myName = "yo";
hoverObject = hitInfo.transform.gameObject.GetComponent<TileScript>();
hoverObject.IsSelected = true;
}
hover_state = HoverState.HOVER;
selected();
} else {
if (hover_state == HoverState.HOVER) {
//if (!hoverObject) {
hoverObject.IsSelected = false;
hoverObject.SetVisual();
//}
}
///hoverObject = null;
hover_state = HoverState.NONE;
}
}
private async Task SetOpacityAsync(TouchEff sender, TouchState touchState, HoverState hoverState, int duration)
{
var regularOpacity = sender.RegularOpacity;
var pressedOpacity = sender.PressedOpacity;
var hoveredOpacity = sender.HoveredOpacity;
if (Abs(regularOpacity - 1) <= double.Epsilon &&
Abs(pressedOpacity - 1) <= double.Epsilon &&
Abs(hoveredOpacity - 1) <= double.Epsilon)
{
return;
}
var opacity = regularOpacity;
var easing = sender.RegularAnimationEasing;
if (touchState == TouchState.Pressed)
{
opacity = pressedOpacity;
easing = sender.PressedAnimationEasing;
}
else if (hoverState == HoverState.Hovering)
{
opacity = hoveredOpacity;
easing = sender.HoveredAnimationEasing;
}
await sender.Control.FadeTo(opacity, (uint)Abs(duration), easing);
}
private void Hover()
{
if (Input.GetKey(KeyCode.Space) && hoverState == HoverState.Ready)
{
if (currentHoverFuel > 0)
{
rb.AddRelativeForce(Vector2.up * hoverAcceleration);
currentHoverFuel -= fuelDrainAmount * Time.fixedDeltaTime;
}
else
{
//Fuel fully drained, put hover on cooldown
hoverState = HoverState.CoolDown;
StartCoroutine(RechargeCD(hoverCDDuration));
}
}
if (DG.IsGrounded)
{
//Fuel has been recharged, hover is ready
if (currentHoverFuel >= maxHoverFuel)
{
hoverState = HoverState.Ready;
}
if (hoverState == HoverState.Recharging && currentHoverFuel < maxHoverFuel)
{
currentHoverFuel += fuelGainAmount * Time.deltaTime;
if (currentHoverFuel > maxHoverFuel)
{
currentHoverFuel = maxHoverFuel;
}
}
}
}
private async Task SetRotationXAsync(TouchEff sender, TouchState touchState, HoverState hoverState, int duration, Easing easing)
{
var regularRotationX = sender.RegularRotationX;
var pressedRotationX = sender.PressedRotationX;
var hoveredRotationX = sender.HoveredRotationX;
if (Abs(regularRotationX) <= double.Epsilon &&
Abs(pressedRotationX) <= double.Epsilon &&
Abs(hoveredRotationX) <= double.Epsilon)
{
return;
}
var rotationX = regularRotationX;
if (touchState == TouchState.Pressed)
{
rotationX = pressedRotationX;
}
else if (hoverState == HoverState.Hovering)
{
rotationX = hoveredRotationX;
}
await sender.Control.RotateXTo(rotationX, (uint)Abs(duration), easing);
}
private async Task SetRotationYAsync(TouchEff sender, TouchState touchState, HoverState hoverState, int duration)
{
var regularRotationY = sender.RegularRotationY;
var pressedRotationY = sender.PressedRotationY;
var hoveredRotationY = sender.HoveredRotationY;
if (Abs(regularRotationY) <= double.Epsilon &&
Abs(pressedRotationY) <= double.Epsilon &&
Abs(hoveredRotationY) <= double.Epsilon)
{
return;
}
var rotationY = regularRotationY;
var easing = sender.RegularAnimationEasing;
if (touchState == TouchState.Pressed)
{
rotationY = pressedRotationY;
easing = sender.PressedAnimationEasing;
}
else if (hoverState == HoverState.Hovering)
{
rotationY = hoveredRotationY;
easing = sender.HoveredAnimationEasing;
}
await sender.Control.RotateYTo(rotationY, (uint)Abs(duration), easing);
}
protected override void ApplyHoverState(HoverState newHoverState, bool isStateChange, List <ProximityController> changedControllers)
{
foreach (ProximityController interactor in changedControllers)
{
if (interactor == null)
{
continue;
}
LaserBeamController lbi = interactor.GetComponent <LaserBeamController> ();
switch (newHoverState)
{
case HoverState.Hovered:
case HoverState.Pressed:
if (lbi.hoveredObject != this)
{
// Debug.Log (name + ": Adding hover state for pointer event: " + lbi.name);
UILaserInputModule.instance.HandleInputExitAndEnter(lbi.uiLaser.pointerEvent, gameObject);
lbi.hoveredObject = this;
}
break;
case HoverState.DraggedAway:
case HoverState.None:
if (lbi.hoveredObject == this)
{
// Debug.Log (name + ": Removing hover state for pointer event: " + lbi.name);
UILaserInputModule.instance.HandleInputExitAndEnter(lbi.uiLaser.pointerEvent, null);
lbi.hoveredObject = null;
}
break;
}
}
}
Task SetRotationX(TouchEffect sender, TouchState touchState, HoverState hoverState, int duration, Easing?easing)
{
var normalRotationX = sender.NormalRotationX;
var pressedRotationX = sender.PressedRotationX;
var hoveredRotationX = sender.HoveredRotationX;
if (Abs(normalRotationX) <= double.Epsilon &&
Abs(pressedRotationX) <= double.Epsilon &&
Abs(hoveredRotationX) <= double.Epsilon)
{
return(Task.FromResult(false));
}
var rotationX = normalRotationX;
if (touchState == TouchState.Pressed)
{
rotationX = pressedRotationX;
}
else if (hoverState == HoverState.Hovered && (sender.Element?.IsSet(TouchEffect.HoveredRotationXProperty) ?? false))
{
rotationX = hoveredRotationX;
}
var element = sender.Element;
if (duration <= 0 && element != null)
{
element.AbortAnimations();
element.RotationX = rotationX;
return(Task.FromResult(true));
}
return(element?.RotateXTo(rotationX, (uint)Abs(duration), easing) ?? Task.FromResult(false));
}
public void MouseOverTile()
{
//Start Tile highlighting code
ray = Camera.main.ScreenPointToRay(Input.mousePosition);
hit = Physics2D.Raycast(ray.origin, ray.direction, 100f);
if (hit)
{
hover_state = HoverState.HOVER;
}
else
{
hover_state = HoverState.NONE;
}
if (hover_state == HoverState.HOVER)
{
//Mouse is hovering
//Debug.Log(mapController.GridToMap(mapController.grid.WorldToCell(hit.point)));
//Debug.Log(MapController.instance.grid.WorldToCell(hit.point));
//if (lastTileLoc != null)
// tileSelecting.SetTile(lastTileLoc, null);
lastTileLoc = MapController.instance.grid.WorldToCell(hit.point);
tilePointer = MapController.instance.grid.WorldToCell(hit.point);
}
//else
//{
// tileSelecting.SetTile(lastTileLoc, null);
//}
//End Tile highlighting code
}
Task SetOpacity(TouchEffect sender, TouchState touchState, HoverState hoverState, int duration, Easing easing)
{
var normalOpacity = sender.NormalOpacity;
var pressedOpacity = sender.PressedOpacity;
var hoveredOpacity = sender.HoveredOpacity;
if (Abs(normalOpacity - 1) <= double.Epsilon &&
Abs(pressedOpacity - 1) <= double.Epsilon &&
Abs(hoveredOpacity - 1) <= double.Epsilon)
{
return(Task.FromResult(false));
}
var opacity = normalOpacity;
if (touchState == TouchState.Pressed)
{
opacity = pressedOpacity;
}
else if (hoverState == HoverState.Hovered && sender.Element.IsSet(TouchEffect.HoveredOpacityProperty))
{
opacity = hoveredOpacity;
}
var element = sender.Element;
if (duration <= 0)
{
element.Opacity = opacity;
return(Task.FromResult(true));
}
return(element.FadeTo(opacity, (uint)Abs(duration), easing));
}
protected override void OnMouseMove(MouseEventArgs args)
{
if (args.Button == MouseButtons.None)
{
if (mouseMoveIgnore > 0)
{
mouseMoveIgnore--;
return;
}
lastLocation = args;
if (hoverState == HoverState.InHover)
{
DoHover();
}
else
{
try
{
hoverTimer.Enabled = false;
hoverTimer.Enabled = true;
hoverTimer.Start();
hoverState = HoverState.Ready;
}
catch (InvalidOperationException)
{
// eat this here...
}
}
}
base.OnMouseMove(args);
}
Task SetRotationY(TouchEffect sender, TouchState touchState, HoverState hoverState, int duration, Easing easing)
{
var normalRotationY = sender.NormalRotationY;
var pressedRotationY = sender.PressedRotationY;
var hoveredRotationY = sender.HoveredRotationY;
if (Abs(normalRotationY) <= double.Epsilon &&
Abs(pressedRotationY) <= double.Epsilon &&
Abs(hoveredRotationY) <= double.Epsilon)
{
return(Task.FromResult(false));
}
var rotationY = normalRotationY;
if (touchState == TouchState.Pressed)
{
rotationY = pressedRotationY;
}
else if (hoverState == HoverState.Hovered && sender.Element.IsSet(TouchEffect.HoveredRotationYProperty))
{
rotationY = hoveredRotationY;
}
var element = sender.Element;
if (duration <= 0)
{
element.RotationY = rotationY;
return(Task.FromResult(true));
}
return(element.RotateYTo(rotationY, (uint)Abs(duration), easing));
}
void Start()
{
anim = GetComponent <Animator>();
//stateInfo = anim.GetCurrentAnimatorStateInfo(0);
//jumpHash = Animator.StringToHash("Jump");
hover_state = HoverState.NONE;
}
public void OnButtonMouseover()
{
if (_selectedState != SelectedState.Selected)
{
_hoverState = HoverState.Hover;
UpdateState();
}
}
public void Clear()
{
m_hoveredGO = null;
m_hoverState = HoverState.NONE;
m_clickCount = 0;
m_isDetectingClick = false;
}
public void OnButtonMouseout()
{
if (_selectedState != SelectedState.Selected)
{
_hoverState = HoverState.Default;
UpdateState();
}
}
protected override void OnClick(EventArgs e)
{
hoverTimer.Enabled = false;
hoverState = HoverState.AfterClick;
hoverTooltip.Hide();
mouseMoveIgnore = 1;
base.OnClick(e);
}
private void checkLeaderChanged()
{
if (this.leaderLastPosition != toFollow.position ||
this.leaderLastRotation != this.toFollow.rotation) {
this.leaderLastPosition = toFollow.position;
this.leaderLastRotation = toFollow.rotation;
this.currentState = HoverState.FOLLOWING;
}
}
private Task GetAnimationTask(TouchEff sender, TouchState touchState, HoverState hoverState, double?durationMultiplier = null)
{
if (sender.Control == null)
{
return(Task.CompletedTask);
}
var token = _animationTokenSource.Token;
var duration = sender.RegularAnimationDuration;
var easing = sender.RegularAnimationEasing;
if (touchState == TouchState.Pressed)
{
duration = sender.RegularAnimationDuration;
easing = sender.PressedAnimationEasing;
}
else if (hoverState == HoverState.Hovering)
{
duration = sender.HoveredAnimationDuration;
easing = sender.HoveredAnimationEasing;
}
duration = duration.AdjustDurationMultiplier(durationMultiplier);
if (duration <= 0 &&
Device.RuntimePlatform != Device.iOS &&
Device.RuntimePlatform != Device.macOS)
{
duration = 1;
}
sender.RaiseAnimationStarted(touchState, hoverState, duration);
return(Task.WhenAll(
_customAnimationTaskGetter?.Invoke(sender, touchState, hoverState, duration, easing, token) ?? Task.FromResult(true),
SetBackgroundColorAsync(sender, touchState, hoverState, duration, easing),
SetOpacityAsync(sender, touchState, hoverState, duration, easing),
SetScaleAsync(sender, touchState, hoverState, duration, easing),
SetTranslationAsync(sender, touchState, hoverState, duration, easing),
SetRotationAsync(sender, touchState, hoverState, duration, easing),
SetRotationXAsync(sender, touchState, hoverState, duration, easing),
SetRotationYAsync(sender, touchState, hoverState, duration, easing),
Task.Run(async() =>
{
_animationProgress = 0;
_animationState = touchState;
for (var progress = AnimationProgressDelay; progress < duration; progress += AnimationProgressDelay)
{
await Task.Delay(AnimationProgressDelay).ConfigureAwait(false);
if (token.IsCancellationRequested)
{
return;
}
_animationProgress = (double)progress / duration;
}
_animationProgress = 1;
})));
}
void DoneHover()
{
if (hoverState == HoverState.InHover)
{
hoverTooltip.Hide();
this.SelectionLength = 0;
hoverState = HoverState.Ready;
hoverTimer.Enabled = false;
}
}
private void followLeader()
{
Transform t = this.transform;
t.position = Vector3.MoveTowards(t.position,toFollow.position + positionOffset,positionSpeed);
t.LookAt(targetLookAt);
t.Rotate (rotationOffset);
if (t.position == toFollow.position + positionOffset) {
this.currentState = HoverState.HOVERING;
}
}
void UpdateVisualState(VisualElement visualElement, TouchState touchState, HoverState hoverState)
{
var state = touchState == TouchState.Pressed
? nameof(TouchState.Pressed)
: hoverState == HoverState.Hovered
? nameof(HoverState.Hovered)
: nameof(TouchState.Normal);
VisualStateManager.GoToState(visualElement, state);
}
private void checkLeaderChanged()
{
if (this.leaderLastPosition != toFollow.position ||
this.leaderLastRotation != this.toFollow.rotation)
{
this.leaderLastPosition = toFollow.position;
this.leaderLastRotation = toFollow.rotation;
this.currentState = HoverState.FOLLOWING;
}
}
void UpdateVisualState(VisualElement visualElement, TouchState touchState, HoverState hoverState)
{
var state = touchState == TouchState.Pressed
? TouchEffect.PressedVisualState
: hoverState == HoverState.Hovered
? TouchEffect.HoveredVisualState
: TouchEffect.UnpressedVisualState;
VisualStateManager.GoToState(visualElement, state);
}
protected override void OnMouseLeave(EventArgs e)
{
if (_toggleHover)
{
if (_hoverState == HoverState.On)
{
_hoverState = HoverState.Off;
RecreateHandle();
}
}
}
private Predicate <Touch> MakeTriggerRule(GameObject obj, HoverState hover)
{
return(delegate(Touch touch)
{
if (obj == null || obj.IsDestroyed || obj.Layer == null)
{
return false;
}
return GetHoverState(touch, obj) == hover;
});
}
private void ButtonUp(XRButtonDatum datum)
{
if (datum.InputName == _visualizeButtonPressHitRay && _hoverState == HoverState.Press)
{
_hoverState = HoverState.Hover;
_hitTargetMaterial.color = _hoverEndColor;
_hitTargetInstance.transform.localScale = new Vector3(
_hitTargetScale,
_hitTargetScale,
_hitTargetScale);
}
}
private void followLeader()
{
Transform t = this.transform;
t.position = Vector3.MoveTowards(t.position, toFollow.position + positionOffset, positionSpeed);
t.LookAt(targetLookAt);
t.Rotate(rotationOffset);
if (t.position == toFollow.position + positionOffset)
{
this.currentState = HoverState.HOVERING;
}
}
Task SetTranslation(TouchEffect sender, TouchState touchState, HoverState hoverState, int duration, Easing easing)
{
var normalTranslationX = sender.NormalTranslationX;
var pressedTranslationX = sender.PressedTranslationX;
var hoveredTranslationX = sender.HoveredTranslationX;
var normalTranslationY = sender.NormalTranslationY;
var pressedTranslationY = sender.PressedTranslationY;
var hoveredTranslationY = sender.HoveredTranslationY;
if (Abs(normalTranslationX) <= double.Epsilon &&
Abs(pressedTranslationX) <= double.Epsilon &&
Abs(hoveredTranslationX) <= double.Epsilon &&
Abs(normalTranslationY) <= double.Epsilon &&
Abs(pressedTranslationY) <= double.Epsilon &&
Abs(hoveredTranslationY) <= double.Epsilon)
{
return(Task.FromResult(false));
}
var translationX = normalTranslationX;
var translationY = normalTranslationY;
if (touchState == TouchState.Pressed)
{
translationX = pressedTranslationX;
translationY = pressedTranslationY;
}
else if (hoverState == HoverState.Hovered)
{
if (sender.Element.IsSet(TouchEffect.HoveredTranslationXProperty))
{
translationX = hoveredTranslationX;
}
if (sender.Element.IsSet(TouchEffect.HoveredTranslationYProperty))
{
translationY = hoveredTranslationY;
}
}
var element = sender.Element;
if (duration <= 0)
{
element.AbortAnimations();
element.TranslationX = translationX;
element.TranslationY = translationY;
return(Task.FromResult(true));
}
return(element.TranslateTo(translationX, translationY, (uint)Abs(duration), easing));
}
private void ButtonDown(XRButtonDatum datum)
{
if (datum.InputName == _visualizeButtonPressHitRay && datum.PressCollider != null)
{
_hoverState = HoverState.Press;
_hitTargetMaterial.color = _pressEndColor;
_hitTargetInstance.transform.localScale = new Vector3(
_hitTargetScale * 1.5f,
_hitTargetScale * 1.5f,
_hitTargetScale * 1.5f);
}
}
// Use this for initialization
void Start()
{
arm = transform.GetChild(1).GetComponent <Arm>();
if (arm.transform.GetChild(0).childCount > 0)
{
weapon = arm.transform.GetChild(0).GetChild(0);
}
direction = Direction.RIGHT;
hoverState = HoverState.Ready;
currentHoverFuel = maxHoverFuel;
}
public bool SetHoverState(ProximityController controller, HoverState newHoverState)
{
if (newHoverState == HoverState.Hovered || newHoverState == HoverState.None)
{
Debug.LogError("Use AddHover or RemoveHover for setting hover state");
// DSL: Might just want to re-route
return(false);
}
// HoverState.Pressed or HoverState.DraggedAway
if (newHoverState == HoverState.Pressed)
{
if (hoverState != HoverState.Hovered && hoverState != HoverState.DraggedAway)
{
Debug.LogError("Cannot move to Pressed state from " + hoverState);
// DSL: Might just want to re-route
return(false);
}
if (!controller.SortedHoveredObjectsContains(this))
{
controller.AddHoveredItem(this);
}
if (!hoveredList.Contains(controller))
{
hoveredList.Add(controller);
}
}
else if (newHoverState == HoverState.DraggedAway)
{
if (hoverState != HoverState.Pressed)
{
Debug.LogError("Cannot move to DraggedAway state from " + hoverState);
// DSL: Might just want to re-route
return(false);
}
if (controller.SortedHoveredObjectsContains(this))
{
controller.RemoveHoveredItem(this);
}
hoveredList.Remove(controller);
}
List <ProximityController> controllerList = new List <ProximityController>()
{
controller
};
ApplyHoverState(newHoverState, true, controllerList);
hoverState = newHoverState;
return(true);
}
Task SetScale(TouchEffect sender, TouchState touchState, HoverState hoverState, int duration, Easing?easing)
{
var normalScale = sender.NormalScale;
var pressedScale = sender.PressedScale;
var hoveredScale = sender.HoveredScale;
if (Abs(normalScale - 1) <= double.Epsilon &&
Abs(pressedScale - 1) <= double.Epsilon &&
Abs(hoveredScale - 1) <= double.Epsilon)
{
return(Task.FromResult(false));
}
var scale = normalScale;
if (touchState == TouchState.Pressed)
{
scale = pressedScale;
}
else if (hoverState == HoverState.Hovered && (sender.Element?.IsSet(TouchEffect.HoveredScaleProperty) ?? false))
{
scale = hoveredScale;
}
var element = sender.Element;
if (element == null)
{
return(Task.FromResult(false));
}
if (duration <= 0)
{
element.AbortAnimations(nameof(SetScale));
element.Scale = scale;
return(Task.FromResult(true));
}
var animationCompletionSource = new TaskCompletionSource <bool>();
element.Animate(nameof(SetScale), v =>
{
if (double.IsNaN(v))
{
return;
}
element.Scale = v;
}, element.Scale, scale, 16, (uint)Abs(duration), easing, (v, b) => animationCompletionSource.SetResult(b));
return(animationCompletionSource.Task);
}
/// <summary>
/// Initializes a new instance of the HoverStateChangeEventArgs class.
/// </summary>
/// <param name="hoverState">The <see cref="HoverState"/> values.</param>
public HoverStateChangeEventArgs(HoverState hoverState)
{
this.m_hoverState = hoverState;
}
void Update()
{
if (inGame && objectHolder.tutorialPanel.activeSelf)
{
if (tutCountDown < 0)
objectHolder.tutorialPanel.SetActive(false);
else
tutCountDown -= Time.deltaTime;
}
if (Input.GetKeyDown(KeyCode.Escape) && inGame)
{
paused = !paused;
OnPauseMenu();
}
if(Input.GetKeyDown(KeyCode.O))
{
if (inGame)
UIHolder.Instance().WriteText("pressed O :/");
Screen.SetResolution(1920, 1080, true);
Screen.fullScreen = true;
}
if(Input.GetKeyDown(KeyCode.P))
{
Screen.fullScreen = false;
}
#region CenterMouse
RaycastHit hitInfo = new RaycastHit();
Ray ray = Camera.main.ScreenPointToRay(new Vector3(Screen.width / 2, Screen.height / 2, 0));
if (Physics.Raycast(ray, out hitInfo))
{
if (hover_state == HoverState.NONE)
{
hoveredGO = hitInfo.collider.gameObject;
}
hover_state = HoverState.HOVER;
}
if(hitInfo.collider != null && (hitInfo.collider.gameObject != hoveredGO || hitInfo.distance > 3))
{
if (hover_state == HoverState.HOVER)
{
hoveredGO.SendMessage("MouseExit", SendMessageOptions.DontRequireReceiver);
}
hover_state = HoverState.NONE;
}
if (hover_state == HoverState.HOVER)
{
hitInfo.collider.SendMessage("MouseOver", SendMessageOptions.DontRequireReceiver); //Mouse is hovering
}
#endregion
}
/// <summary>
/// Raises the MouseMove event
/// </summary>
/// <param name="e">A MouseEventArgs that contains the event data.</param>
protected override void OnMouseMove(MouseEventArgs e)
{
if (this.CaptionRectangle.Contains(e.X, e.Y) == true)
{
if (this.m_hoverStateCaptionBar == HoverState.None)
{
this.m_hoverStateCaptionBar = HoverState.Hover;
OnCaptionBarHoverStateChanged(this, new HoverStateChangeEventArgs(this.m_hoverStateCaptionBar));
}
}
else
{
if (this.m_hoverStateCaptionBar == HoverState.Hover)
{
this.m_hoverStateCaptionBar = HoverState.None;
OnCaptionBarHoverStateChanged(this, new HoverStateChangeEventArgs(this.m_hoverStateCaptionBar));
}
}
if ((this.ShowExpandIcon == true) || (this.ShowCloseIcon == true))
{
if (this.RectangleExpandIcon.Contains(e.X, e.Y) == true)
{
if (this.m_hoverStateExpandIcon == HoverState.None)
{
this.m_hoverStateExpandIcon = HoverState.Hover;
OnExpandIconHoverStateChanged(this, new HoverStateChangeEventArgs(this.m_hoverStateExpandIcon));
}
}
else
{
if (this.m_hoverStateExpandIcon == HoverState.Hover)
{
this.m_hoverStateExpandIcon = HoverState.None;
OnExpandIconHoverStateChanged(this, new HoverStateChangeEventArgs(this.m_hoverStateExpandIcon));
}
}
if (this.RectangleCloseIcon.Contains(e.X, e.Y) == true)
{
if (this.m_hoverStateCloseIcon == HoverState.None)
{
this.m_hoverStateCloseIcon = HoverState.Hover;
OnCloseIconHoverStateChanged(this, new HoverStateChangeEventArgs(this.m_hoverStateCloseIcon));
}
}
else
{
if (this.m_hoverStateCloseIcon == HoverState.Hover)
{
this.m_hoverStateCloseIcon = HoverState.None;
OnCloseIconHoverStateChanged(this, new HoverStateChangeEventArgs(this.m_hoverStateCloseIcon));
}
}
}
base.OnMouseMove(e);
}
/// <summary>
/// Raises the MouseLeave event.
/// </summary>
/// <param name="e">An EventArgs that contains the event data.</param>
protected override void OnMouseLeave(EventArgs e)
{
if (this.m_hoverStateCaptionBar == HoverState.Hover)
{
this.m_hoverStateCaptionBar = HoverState.None;
OnCaptionBarHoverStateChanged(this,new HoverStateChangeEventArgs(this.m_hoverStateCaptionBar));
}
if (this.m_hoverStateExpandIcon == HoverState.Hover)
{
this.m_hoverStateExpandIcon = HoverState.None;
OnExpandIconHoverStateChanged(this, new HoverStateChangeEventArgs(this.m_hoverStateExpandIcon));
}
if (this.m_hoverStateCloseIcon == HoverState.Hover)
{
this.m_hoverStateCloseIcon = HoverState.None;
OnCloseIconHoverStateChanged(this, new HoverStateChangeEventArgs(this.m_hoverStateCloseIcon));
}
base.OnMouseLeave(e);
}
