/// <summary>
/// Constructor
/// </summary>
public BuzzInputReport()
{
// Create the button states
Buttons = new ButtonStates[NumHandsets];
for (var i = 0; i < NumHandsets; i++)
Buttons[i] = new ButtonStates();
}
/// <summary>
/// Creates a new instance of SquareButton
/// </summary>
public SquareButton()
{
_colorUpDark = SystemColors.ControlDark;
_colorUpLit = SystemColors.Control;
_colorDownDark = SystemColors.ControlDark;
_colorDownLit = SystemColors.ControlDark;
_state = ButtonStates.None;
}
void Start()
{
buttons = new List<GameObject>();
panelImageScript = panel.GetComponent<Image>();
biographyImageScript = GameObject.Find("Biography").GetComponent<Image>();
triggerSquareBoundary = 5;
changeInventoryIcons = false;
inventoryDisplayStates = InventoryDisplayStates.NoInventory;
buttonStates = ButtonStates.Create;
torsoItems = new string[] { "Blouse", "Jacket", "Shirt", "Tank" };
legsItems = new string[] { "Miniskirt", "Shorts", "Pants", "Dress" };
}
/// <summary>
/// At the end of every frame, we change our button's state if needed
/// </summary>
protected virtual void LateUpdate()
{
if (CurrentState == ButtonStates.ButtonUp)
{
_lastStateChangeAt = Time.time;
_fromColor = PressedColor;
_toColor = _initialColor;
CurrentState = ButtonStates.Off;
}
if (CurrentState == ButtonStates.ButtonDown)
{
_lastStateChangeAt = Time.time;
_fromColor = _initialColor;
_toColor = PressedColor;
CurrentState = ButtonStates.ButtonPressed;
}
}
protected override void OnMouseDown(MouseEventArgs e)
{
MouseArgs = e;
if (e.Button == MouseButtons.Left)
{
_ButtonState = ButtonStates.Pressed;
RedrawButton();
if (!ClickOnMouseUp && Enabled)
{
base.OnClick(e);
base.OnMouseClick(e);
}
}
}
ButtonStates ReadStates()
{
ButtonStates bs = ButtonStates.None;
byte[] buttonData = buttonMem.Read();
int bitMask = 1;
foreach (byte butState in buttonData)
{
if (butState != 0)
{
bs |= (ButtonStates)bitMask;
}
bitMask = bitMask << 1;
}
return(bs);
}
/// <summary>
/// Triggers the bound pointer down action
/// </summary>
public virtual void OnPointerDown(PointerEventData data)
{
if (CurrentState != ButtonStates.Off)
{
return;
}
CurrentState = ButtonStates.ButtonDown;
if (_canvasGroup != null)
{
_canvasGroup.alpha = PressedOpacity;
}
if (AxisPressedFirstTime != null)
{
AxisPressedFirstTime.Invoke();
}
}
/// <summary>
/// Triggers the bound pointer up action
/// </summary>
public virtual void OnPointerUp(PointerEventData data)
{
if (CurrentState != ButtonStates.ButtonPressed && CurrentState != ButtonStates.ButtonDown)
{
return;
}
CurrentState = ButtonStates.ButtonUp;
if ((Time.timeScale != 0) && (ReleasedDelay > 0))
{
Invoke("InvokeReleased", ReleasedDelay);
}
else
{
ButtonReleased.Invoke();
}
}
public KeyboardKeyInput FromTwoStates(int count)
{
var state1 = new ButtonStates <Key>();
var state2 = new ButtonStates <Key>();
for (int i = 0; i < count; i++)
{
state1.SetPressed((Key)i, true);
}
for (int i = count; i < 2 * count; i++)
{
state2.SetPressed((Key)i, true);
}
return(new KeyboardKeyInput(state1, state2));
}
public int EnumerateBothDifferences(int count)
{
var state1 = new ButtonStates <Key>();
var state2 = new ButtonStates <Key>();
for (int i = 0; i < count; i++)
{
state1.SetPressed((Key)i, true);
}
for (int i = count; i < 2 * count; i++)
{
state2.SetPressed((Key)i, true);
}
return(state1.EnumerateDifference(state2).Pressed.Length);
}
// Method for when mouse is moved (check if it is over)
private void OnMouseMoved(Point mousePosition)
{
if (InputHelper.MouseIsOver(area))
{
if (state != ButtonStates.Hover)
{
state = ButtonStates.Hover;
area.Y += 10; area.Height -= 10; // #DIRTY
AssignDrawPositions();
}
}
else if (!(state == ButtonStates.None))
{
state = ButtonStates.None;
area.Y -= 10; area.Height += 10; // #DIRTY
AssignDrawPositions();
}
}
public void Toggle()
{
switch (ButtonState)
{
case ButtonStates.Off:
ButtonState = ButtonType == ButtonTypes.TwoState ? ButtonStates.On : ButtonStates.Dim;
break;
case ButtonStates.On:
ButtonState = ButtonStates.Off;
break;
case ButtonStates.Dim:
ButtonState = ButtonStates.On;
break;
}
UpdateButton();
}
private void Update()
{
if (_btn.buttonState != btnStates)
{
btnStates = _btn.buttonState;
OnStateChanged.TryInvoke(btnStates);
}
if (_btn.interactable && !interact)
{
interact = true;
OnInteractChange();
}
else if (!_btn.interactable && interact)
{
interact = false;
OnInteractChange();
}
}
/// <summary>
/// Triggers the bound pointer up action
/// </summary>
public virtual void OnPointerUp(PointerEventData data)
{
if (CurrentState != ButtonStates.ButtonPressed && CurrentState != ButtonStates.ButtonDown)
{
return;
}
CurrentState = ButtonStates.ButtonUp;
if (_canvasGroup != null)
{
_canvasGroup.alpha = _initialOpacity;
}
if (AxisReleased != null)
{
AxisReleased.Invoke();
}
AxisPressed.Invoke(0);
}
public void DeHighlight()
{
if (_state == ButtonStates.Enabled || _state == ButtonStates.HighlightEnabled)
{
_state = ButtonStates.Enabled;
_animator.SetNewAnimation((int)ButtonStates.Enabled);
}
else if (_state == ButtonStates.Disabled || _state == ButtonStates.HighlightDisabled)
{
_state = ButtonStates.Disabled;
_animator.SetNewAnimation((int)ButtonStates.Disabled);
}
else if (_state == ButtonStates.Selected || _state == ButtonStates.HighlightSelected)
{
_state = ButtonStates.Selected;
_animator.SetNewAnimation((int)ButtonStates.Selected);
}
}
public void SelectNoEvent()
{
if (_state != ButtonStates.Selected && _state != ButtonStates.Enabled)
{
return;
}
if (_state == ButtonStates.Selected)
{
_animator.SetNewAnimation((int)ButtonStates.Deselect);
_state = ButtonStates.Deselect;
}
else
{
_animator.SetNewAnimation((int)ButtonStates.Select);
_state = ButtonStates.Select;
}
}
void _formChrome_NonClientMouseDown(object sender, NonClientMouseEventArgs e)
{
var state = new ButtonStates(this);
if (state.OverButton != ChromeButton.None || state.OverExtraButton != null)
{
_formChrome.BeginUpdate();
SetOverButton(ChromeButton.None);
SetOverButton(null);
SetDownButton(state.OverButton);
SetDownButton(state.OverExtraButton);
CaptureStart = e.Location;
Form.Capture = true;
_formChrome.EndUpdate();
}
}
void Update()
{
transform.position = _controller.Position;
transform.rotation = _controller.Orientation;
if (BtnState == ButtonStates.JustReleased)
{
BtnState = ButtonStates.Normal;
}
if (_controller.TriggerValue == 0.0f) // When the trigger ISN'T pressed...
{
foreach (Transform child in transform) // Grab all children of the object this script is attached to (the controller, usually)
{
child.transform.parent = null; // Make all childs have no parent.
_drag = false;
}
}
}
internal void ChangeTakeO2State(ButtonStates state)
{
QuickLogger.Debug($"Changing Button State for {nameof(ChangeTakeO2State)}");
switch (state)
{
case ButtonStates.Enabled:
_buttonLbl.text = OxStationBuildable.TakeOxygen();
_giveOIntBtn.OnEnable();
break;
case ButtonStates.Disabled:
_buttonLbl.text = OxStationBuildable.Damaged();
_giveOIntBtn.OnDisable();
break;
default:
throw new ArgumentOutOfRangeException(nameof(state), state, null);
}
}
protected void OnTitlebarButtonReleaseEvent(object o, ButtonReleaseEventArgs args)
{
_titleBarMouseDown = args.Event.Button == 1 && args.Event.Type == EventType.ButtonPress;
ButtonStates tempCloseState = _closeState;
ButtonStates tempMinimizeState = _minimizeState;
this.RedrawControls(GetState(args.Event.X, args.Event.Y, _closeStart, _titleBarMouseDown, _closeState),
GetState(args.Event.X, args.Event.Y, _minimizeStart, _titleBarMouseDown, _minimizeState),
false);
if (tempCloseState == ButtonStates.DownInside && !_titleBarMouseDown)
{
this.CloseApp();
}
else if (tempMinimizeState == ButtonStates.DownInside && !_titleBarMouseDown)
{
this.MinimizeApp();
}
}
public void ButtonPush(Button b)
{
switch (b.Action)
{
case ButtonAction.Quit:
this.ButtonState = ButtonStates.Quit;
break;
case ButtonAction.Other:
this.ButtonState = ButtonStates.Pressed;
this.pressedButtonName = b.text;
break;
case ButtonAction.Close:
this.ButtonState = ButtonStates.Close;
break;
case ButtonAction.Play:
this.ButtonState = ButtonStates.Play;
break;
}
}
//*******************************************************************************************
/// <summary>
///
/// </summary>
/// <param name="e"></param>
//*******************************************************************************************
protected override void OnMouseMove(MouseEventArgs e)
{
if (m_fMouseButtonDown && !m_fButtonLockedDown)
{
ButtonStates nTmpPaintState = ButtonStates.Flat;
if (m_rect.Contains(e.X, e.Y))
{
nTmpPaintState = ButtonStates.Down;
}
if (nTmpPaintState != m_PaintState)
{
m_PaintState = nTmpPaintState;
Invalidate();
}
}
base.OnMouseMove(e);
}
protected virtual void cc_hover(bool hovering)
{
if (!enabled)
{
return;
}
if (hovering)
{
if (state != ButtonStates.PRESSING)
{
state = ButtonStates.HOVERING;
Color = hoverColor;
}
}
else if (state != ButtonStates.PRESSING)
{
state = ButtonStates.NORMAL;
Color = defaultColor;
}
}
public AnimatedButton(Renderer2D r2D, Rectangle bounds, int[] framesPerState, bool[] loopStates)
: base(r2D, bounds)
{
if (framesPerState.Length != loopStates.Length)
{
throw new ArgumentException("framesPerState necessita ter o mesmo número de elementos que loopStates");
}
this.framesPerState = framesPerState;
this.loopStates = loopStates;
int totalFrames = 0;
foreach (int frames in framesPerState)
{
totalFrames += frames;
}
textures = new Texture2D[totalFrames];
lastState = State;
}
public void SelectButton()
{
if (_state == ButtonStates.Disabled || _state == ButtonStates.FadeIn || _state == ButtonStates.FadeOut)
{
return;
}
if (_state == ButtonStates.Selected)
{
_animator.SetNewAnimation((int)ButtonStates.Deselect);
_state = ButtonStates.Deselect;
}
else
{
_animator.SetNewAnimation((int)ButtonStates.Select);
_state = ButtonStates.Select;
}
OnSelected(_args);
}
public void UpdateOwnLogic()
{
if (_animator.AnimationFinished)
{
if (_state == ButtonStates.Disabled || _state == ButtonStates.Enabled || _state == ButtonStates.Selected ||
_state == ButtonStates.HighlightDisabled || _state == ButtonStates.HighlightEnabled || _state == ButtonStates.HighlightSelected)
{
_animator.AdvanceAnimationReplay();
return;
}
if (_state == ButtonStates.Select)
{
if (_type == ButtonType.Standard)
{
_state = ButtonStates.Enabled;
_animator.SetNewAnimation((int)ButtonStates.Enabled);
}
else
{
_state = ButtonStates.Selected;
_animator.SetNewAnimation((int)ButtonStates.Selected);
}
}
if (_state == ButtonStates.Deselect || _state == ButtonStates.FadeIn)
{
_state = ButtonStates.Enabled;
_animator.SetNewAnimation((int)ButtonStates.Enabled);
}
if (_state == ButtonStates.FadeOut)
{
_state = ButtonStates.Hidden;
}
}
else
{
_animator.AdvanceAnimation();
}
}
void Update()
{
if (changeInventoryIcons && inventoryDisplayStates == InventoryDisplayStates.InventoryLegsSpawning)
{
for (int i = 0; i < buttons.Count; i++)
{
buttons[i].GetComponent<Image>().sprite = Resources.Load<Sprite>("Sprites/LegsItems/" + legsItems[i]);
}
inventoryDisplayStates = InventoryDisplayStates.InventoryLegsSpawningDone;
changeInventoryIcons = false;
}
if (buttonStates == ButtonStates.Delete)
{
biographyImageScript.color = Color.clear;
panelImageScript.color = Color.clear;
changeInventoryIcons = false;
inventoryDisplayStates = InventoryDisplayStates.NoInventory;
buttonStates = ButtonStates.Create;
DestroyButtons();
}
}
/// <summary>
/// Updates the mouse location and return true if the state had to change.
/// </summary>
/// <param name="mouseLocation">Updates this button appropriately based on the specified mouse location.</param>
/// <returns>Boolean, true if a change was made.</returns>
public bool UpdateLight(Point mouseLocation)
{
PointF pt = new PointF(mouseLocation.X, mouseLocation.Y);
if (Bounds.Contains(pt))
{
if (_state.IsLit() == false)
{
_state = _state.Lit();
return true;
}
}
else
{
if (_state.IsLit())
{
_state = _state.Darkened();
return true;
}
}
return false;
}
/// <summary>
/// Triggers the bound pointer up action
/// </summary>
public virtual void OnPointerUp(PointerEventData data)
{
if (!Interactable)
{
return;
}
if (CurrentState != ButtonStates.ButtonPressed && CurrentState != ButtonStates.ButtonDown)
{
return;
}
CurrentState = ButtonStates.ButtonUp;
ButtonStateChange?.Invoke(PointerEventData.FramePressState.Released, data);
if ((Time.timeScale != 0) && (ReleasedDelay > 0))
{
Invoke("InvokeReleased", ReleasedDelay);
}
else
{
ButtonReleased.Invoke();
}
}
/// <summary>
/// Triggers the bound pointer down action
/// </summary>
public virtual void OnPointerDown(PointerEventData data)
{
if (Time.time - _lastClickTimestamp < BufferDuration)
{
return;
}
if (CurrentState != ButtonStates.Off)
{
return;
}
CurrentState = ButtonStates.ButtonDown;
_lastClickTimestamp = Time.time;
if ((Time.timeScale != 0) && (PressedFirstTimeDelay > 0))
{
Invoke("InvokePressedFirstTime", PressedFirstTimeDelay);
}
else
{
ButtonPressedFirstTime.Invoke();
}
}
private void Awake()
{
if (!Application.isEditor)
{
Destroy(gameObject);
return;
}
manualController = GetComponent <CustomInputControl>();
currentButtonStates = new ButtonStates();
currentlyVisible = false;
visibilityChanged = false;
controllerId = (uint)Random.value;
InteractionInputSource inputSource = FindObjectOfType <InteractionInputSource>();
if (inputSource != null)
{
isNavigatorUsingRails = inputSource.UseRailsNavigation;
}
}
public void BtnRB()
{
menuState = buttons.GetMenuState();
switch (menuState)
{
case ButtonStates.DEFAULT:
buttons.SetMenu(ButtonStates.DEV_TOOLS);
break;
case ButtonStates.ATTACK:
buttons.SetMenu(ButtonStates.DEFAULT);
break;
case ButtonStates.ITEM:
buttons.SetMenu(ButtonStates.DEFAULT);
break;
case ButtonStates.DEV_TOOLS:
buttons.SetMenu(ButtonStates.DEFAULT);
break;
}
}
//*******************************************************************************************
/// <summary>
/// Press or release the button. If the button does not toggle, this method does nothing.
/// </summary>
/// <param name="fPressed">True if button should be shown pressed.</param>
//*******************************************************************************************
public void PressButton(bool fPressed)
{
CheckDisposed();
if (m_fButtonToggles && m_fButtonLockedDown != fPressed)
{
m_fButtonLockedDown = fPressed;
if (m_fButtonLockedDown)
{
m_PaintState = ButtonStates.Down;
}
else if (ButtonStyle == ButtonStyles.Popup)
{
m_PaintState = ButtonStates.Flat;
}
else
{
m_PaintState = ButtonStates.Up;
}
this.Invalidate();
}
}
public void Handler(ButtonStates state)
{
if (!graphic)
{
graphic = GetComponent <Image>();
normal = graphic.sprite;
}
switch (state)
{
case ButtonStates.Normal:
graphic.sprite = normal;
break;
case ButtonStates.HightLighted:
if (spriteState.highlightedSprite)
{
graphic.sprite = spriteState.highlightedSprite;
}
break;
case ButtonStates.Pressed:
if (spriteState.pressedSprite)
{
graphic.sprite = spriteState.pressedSprite;
}
break;
case ButtonStates.Disabled:
if (spriteState.disabledSprite)
{
graphic.sprite = spriteState.disabledSprite;
}
break;
default:
break;
}
}
/// <summary>
/// Update the button
/// </summary>
/// <param name="panelRect">The rectangle the button resides in</param>
public override void Update(Rect panelRect)
{
int mouseX = Globals.mouseX;
int mouseY = Globals.mouseY;
var events = Globals.eventQueue;
double _mouseX = (mouseX - panelRect.X) / (double)panelRect.W;
double _mouseY = (mouseY - panelRect.Y) / (double)panelRect.H;
bool hovering = false;
bool mouseUp = (events.Any(e =>
e.type == SDL.SDL_EventType.SDL_MOUSEBUTTONUP));
bool mouseDown = (events.Any(e =>
e.type == SDL.SDL_EventType.SDL_MOUSEBUTTONDOWN));
if (_mouseX > x && _mouseX < x + w &&
_mouseY > y && _mouseY < y + h)
{
hovering = true;
}
if (!hovering)
{
State = ButtonStates.Mouseable;
}
if (State == ButtonStates.Mouseable && hovering)
{
State = ButtonStates.Moused;
}
if (State == ButtonStates.Moused && mouseDown)
{
State = ButtonStates.Pressed;
}
if (State == ButtonStates.Pressed && mouseUp)
{
action();
State = ButtonStates.Moused;
}
}
private void ProcessMouseUp()
{
switch (_downButton)
{
case ChromeButton.Minimize:
Form.WindowState = FormWindowState.Minimized;
break;
case ChromeButton.MaximizeRestore:
Form.WindowState = Form.WindowState == FormWindowState.Maximized ? FormWindowState.Normal : FormWindowState.Maximized;
break;
case ChromeButton.Close:
Form.Close();
break;
}
if (_downExtraButton != null)
_downExtraButton.OnClick(EventArgs.Empty);
Form.Capture = false;
CaptureStart = null;
var state = new ButtonStates(this);
_formChrome.BeginUpdate();
SetOverButton(state.OverButton);
SetDownButton(state.DownButton);
SetOverButton(state.OverExtraButton);
SetDownButton(state.DownExtraButton);
_formChrome.EndUpdate();
}
void _formChrome_NonClientAreaPaint(object sender, NonClientPaintEventArgs e)
{
var border = _formChrome.AdjustedResizeBorderThickness;
if (border != _lastBorder)
{
_lastBorder = border;
_dropShadowManager.Synchronize();
}
UpdateBorderColor();
e.Graphics.Clear(SystemColors.Control);
var state = new ButtonStates(this);
if (state.Close.Draw)
DrawButton(e.Graphics, state.Close, e.IsMaximized);
if (state.MaximizeRestore.Draw)
DrawButton(e.Graphics, state.MaximizeRestore, e.IsMaximized);
if (state.Minimize.Draw)
DrawButton(e.Graphics, state.Minimize, e.IsMaximized);
foreach (var extraButton in state.ExtraButtons)
{
DrawButton(e.Graphics, extraButton);
}
int leftOffset = IconOffset.X + border.Left;
if (state.DrawIcon)
{
e.Graphics.DrawImage(
GetFormIcon(),
leftOffset,
IconOffset.Y + border.Top
);
leftOffset += IconSize.Width;
}
leftOffset += TextOffset.X;
var textBounds = new Rectangle(
leftOffset,
TextOffset.Y + border.Top,
state.RightOffset - leftOffset,
int.MaxValue
);
TextRenderer.DrawText(
e.Graphics,
Form.Text,
SystemFonts.MessageBoxFont,
textBounds,
SystemColors.ControlDarkDark,
SystemColors.Control,
TextFormatFlags.NoPrefix | TextFormatFlags.SingleLine | TextFormatFlags.EndEllipsis
);
}
//void OnTriggerExit(Collider other)
//{
// if (other.tag == "models")
// {
// biographyImageScript.color = Color.clear;
// panelImageScript.color = Color.clear;
// changeInventoryIcons = false;
// inventoryDisplayStates = InventoryDisplayStates.NoInventory;
// buttonStates = ButtonStates.Create;
// DestroyButtons();
// }
//}
public void clearDisplay()
{
biographyImageScript.color = Color.clear;
panelImageScript.color = Color.clear;
changeInventoryIcons = false;
inventoryDisplayStates = InventoryDisplayStates.NoInventory;
buttonStates = ButtonStates.Create;
DestroyButtons();
}
/// <summary>
/// Updates the depressed nature of the button based on a mouse click in the specified location
/// </summary>
/// <param name="mouseLocation"></param>
/// <returns></returns>
public bool UpdatePressed(System.Drawing.Point mouseLocation)
{
PointF pt = new PointF((float)mouseLocation.X, (float)mouseLocation.Y);
if (Bounds.Contains(pt))
{
bool test = _state.IsPressed();
_state = _state.InverseDepression();
bool test2 = _state.IsPressed();
return true;
}
return false;
}
void _formChrome_NonClientMouseDown(object sender, NonClientMouseEventArgs e)
{
var state = new ButtonStates(this);
if (state.OverButton != ChromeButton.None)
{
SetOverButton(ChromeButton.None);
SetDownButton(state.OverButton);
CaptureStart = e.Location;
Form.Capture = true;
FormChrome.PaintNonClientArea();
}
}
void SendInput(ControllerInfo info, string inputName, ButtonStates state)
{
foreach (IInputListener listener in info.GetListeners()) {
listener.OnButtonInput(new ButtonInput(info.Name, inputName, state));
}
}
public ButtonInput(string controllerName, string inputName, ButtonStates state)
{
this.controllerName = controllerName;
this.inputName = inputName;
this.state = state;
}
public void SetState(ButtonStates newState)
{
this.currentState = newState;
SetColor();
}
//*******************************************************************************************
/// <summary>
/// Press or release the button. If the button does not toggle, this method does nothing.
/// </summary>
/// <param name="fPressed">True if button should be shown pressed.</param>
//*******************************************************************************************
public void PressButton(bool fPressed)
{
CheckDisposed();
if (m_fButtonToggles && m_fButtonLockedDown != fPressed)
{
m_fButtonLockedDown = fPressed;
if (m_fButtonLockedDown)
m_PaintState = ButtonStates.Down;
else if (ButtonStyle == ButtonStyles.Popup)
m_PaintState = ButtonStates.Flat;
else
m_PaintState = ButtonStates.Up;
this.Invalidate();
}
}
public void SendButtonInput(string inputName, ButtonStates state)
{
for (int i = 0; i < _listeners.Count; i++)
_listeners[i].OnButtonInput(new ButtonInput(Name, inputName, state));
}
// Update is called once per frame
void Update () {
axis = Input.GetAxisRaw("Vertical");
if (axis != 0)
{
if (axisInUse == false)
{
if( axis > 0)
{
if (currentState == ButtonStates.PLAY)
{
currentState = ButtonStates.CREDITS;
}
else
currentState--;
}
else if( axis < 0)
{
if (currentState == ButtonStates.CREDITS)
{
currentState = ButtonStates.PLAY;
}
else
currentState++;
}
axisInUse = true;
}
}
if (Input.GetAxisRaw("Vertical") == 0)
{
axisInUse = false;
}
if (Input.GetAxisRaw("Fire1") != 0)
{
if(currentState == ButtonStates.PLAY)
{
SceneManager.LoadScene("SceneProg");
}
if(currentState == ButtonStates.QUIT)
{
Application.Quit();
}
if (currentState == ButtonStates.CREDITS)
{
inCredits = true;
}
}
if (inCredits)
{
if(!creditsCamInUse)
{
mainCam.transform.position = new Vector3(41.3f,0, -6.23f);
creditsCamInUse = true;
}
CreditsText.transform.Translate(0, 0.1f, 0);
if(CreditsText.transform.position.y > 55)
{
SceneManager.LoadScene(SceneManager.GetActiveScene().name);
}
}
SetColor();
}
// Use this for initialization
void Start () {
currentState = ButtonStates.PLAY;
mainCam = GameObject.Find("Main Camera");
}
//*******************************************************************************************
/// <summary>
///
/// </summary>
/// <param name="e"></param>
//*******************************************************************************************
protected override void OnMouseEnter(EventArgs e)
{
m_PaintState = (m_fButtonLockedDown || m_fMouseButtonDown ? ButtonStates.Down : ButtonStates.Up);
Invalidate();
base.OnMouseEnter(e);
}
private void ProcessMouseMove()
{
var state = new ButtonStates(this);
_formChrome.BeginUpdate();
SetOverButton(state.OverButton);
SetOverButton(state.OverExtraButton);
SetDownButton(state.DownButton);
SetDownButton(state.DownExtraButton);
_formChrome.EndUpdate();
}
private void ProcessMouseUp()
{
switch (_downButton)
{
case ChromeButton.Minimize:
Form.WindowState = FormWindowState.Minimized;
break;
case ChromeButton.MaximizeRestore:
Form.WindowState = Form.WindowState == FormWindowState.Maximized ? FormWindowState.Normal : FormWindowState.Maximized;
break;
case ChromeButton.Close:
Form.Close();
break;
}
Form.Capture = false;
CaptureStart = null;
var state = new ButtonStates(this);
SetOverButton(state.OverButton);
SetDownButton(state.DownButton);
}
protected virtual void ChangeState(ButtonStates newState)
{
CurrentState = newState;
UpdateMaterial((int)newState);
}
private void ProcessMouseMove()
{
var state = new ButtonStates(this);
SetOverButton(state.OverButton);
SetDownButton(state.DownButton);
}
public void SimulateButtonInput(ControllerInfo info, string inputName, ButtonStates state)
{
SendInput(info, inputName, state);
}
//*******************************************************************************************
/// <summary>
///
/// </summary>
/// <param name="e"></param>
//*******************************************************************************************
protected override void OnMouseDown(MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
m_fMouseButtonDown = true;
m_PaintState = ButtonStates.Down;
Invalidate();
}
base.OnMouseDown(e);
}
/// <summary>
/// Updates the mouse location and return true if the state had to change.
/// </summary>
/// <param name="mouseLocation">Updates this button appropriately based on the specified mouse location.</param>
/// <returns>Boolean, true if a change was made.</returns>
public bool UpdateLight(Point mouseLocation)
{
PointF pt = new PointF(mouseLocation.X, mouseLocation.Y);
if (Bounds.Contains(pt))
{
if (_state.IsLit() == false)
{
_state = _state.Lit();
return true;
}
}
else
{
if (_state.IsLit())
{
_state = _state.Darkened();
return true;
}
}
return false;
}
//*******************************************************************************************
/// <summary>
///
/// </summary>
/// <param name="e"></param>
//*******************************************************************************************
protected override void OnMouseLeave(EventArgs e)
{
m_PaintState = (m_fButtonLockedDown ? ButtonStates.Down : ButtonStates.Flat);
Invalidate();
base.OnMouseLeave(e);
}
/// <summary>
/// Updates the depressed nature of the button based on a mouse click in the specified location
/// </summary>
/// <param name="mouseLocation"></param>
/// <returns></returns>
public bool UpdatePressed(Point mouseLocation)
{
PointF pt = new PointF(mouseLocation.X, mouseLocation.Y);
if (Bounds.Contains(pt))
{
_state = _state.InverseDepression();
return true;
}
return false;
}
void _formChrome_NonClientMouseDown(object sender, NonClientMouseEventArgs e)
{
var state = new ButtonStates(this);
if (state.OverButton != ChromeButton.None || state.OverExtraButton != null)
{
_formChrome.BeginUpdate();
SetOverButton(ChromeButton.None);
SetOverButton(null);
SetDownButton(state.OverButton);
SetDownButton(state.OverExtraButton);
CaptureStart = e.Location;
Form.Capture = true;
_formChrome.EndUpdate();
}
}
//*******************************************************************************************
/// <summary>
///
/// </summary>
/// <param name="e"></param>
//*******************************************************************************************
protected override void OnMouseMove(MouseEventArgs e)
{
if (m_fMouseButtonDown && !m_fButtonLockedDown)
{
ButtonStates nTmpPaintState = ButtonStates.Flat;
if (m_rect.Contains(e.X, e.Y))
nTmpPaintState = ButtonStates.Down;
if (nTmpPaintState != m_PaintState)
{
m_PaintState = nTmpPaintState;
Invalidate();
}
}
base.OnMouseMove(e);
}
//*******************************************************************************************
/// <summary>
///
/// </summary>
/// <param name="e"></param>
//*******************************************************************************************
protected override void OnMouseUp(MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
m_fMouseButtonDown = false;
if (!m_fButtonToggles)
{
m_fButtonLockedDown = false;
m_PaintState = ButtonStates.Flat;
Invalidate();
}
else
{
// Only do the following block of code when the button's state is not already
// pushed in or it's not part of a group of option buttons.
if (!m_behaveLikeOptionButton || !m_fButtonLockedDown)
{
// If the mouse pointer is still over the button when the user lifts
// the mouse button, toggle the buttons state. Otherwise, ignore the
// fact that the user ever pressed the mouse button in the first place.
if (m_rect.Contains(e.X, e.Y))
PressButton(!m_fButtonLockedDown);
else
{
m_PaintState = (m_fButtonLockedDown ? ButtonStates.Down : ButtonStates.Flat);
Invalidate();
}
}
}
}
base.OnMouseUp(e);
}
