public override bool ProcessMouse(MouseConsoleState state)
{
if (isEnabled)
{
if (isMouseOver)
{
Point mouseControlPosition = TransformConsolePositionByControlPosition(state.CellPosition);
if (mouseControlPosition.X == VerticalBarX)
{
VerticalBar.ProcessMouse(state);
}
if (mouseControlPosition.Y == HorizontalBarY)
{
HorizontalBar.ProcessMouse(state);
}
}
else
{
base.ProcessMouse(state);
}
}
return(false);
}
protected override void OnMouseMove(MouseConsoleState state)
{
if (imageControl != null)
{
var position = state.CellPosition;
var relativeX = position.X - imageControl.Position.X - 1;
var relativeY = position.Y - imageControl.Position.Y - 1;
if (relativeX >= 0 && relativeX < image.Width && relativeY >= 0 && relativeY < image.Height)
{
var pixel = image[relativeX, relativeY];
if (state.Mouse.LeftButtonDown)
{
pixel.Symbol = brush.Symbol;
pixel.Color = brush.ForeColor;
pixel.BackgroundColor = brush.BackColor;
}
else if (state.Mouse.RightButtonDown)
{
brush.Symbol = (char?)pixel.Symbol;
brush.ForeColor = pixel.Color;
brush.BackColor = pixel.BackgroundColor;
}
}
}
base.OnMouseMove(state);
}
/// <summary>
/// If the mouse is not over the console, causes the protected <see cref="OnMouseExit"/> method to run which raises the <see cref="MouseExit"/> event.
/// </summary>
/// <param name="state"></param>
public void LostMouse(MouseConsoleState state)
{
if (IsMouseOver)
{
OnMouseExit(state);
}
}
public override bool ProcessMouse(MouseConsoleState state)
{
mouseCursor.IsVisible = state.IsOnConsole;
mouseCursor.Position = state.ConsoleCellPosition;
return(base.ProcessMouse(state));
}
private void Selection(MouseConsoleState state)
{
if (!MakingSelection)
{
// Start selection box
MakingSelection = true;
StartPoint = state.ConsoleCellPosition;
EndPoint = state.ConsoleCellPosition;
ControlSystem.StartSelectionBox();
}
else
{
// Change selection box
EndPoint = state.ConsoleCellPosition;
}
// Find selection box edges
int minX = Math.Min(StartPoint.X, EndPoint.X);
int minY = Math.Min(StartPoint.Y, EndPoint.Y);
int maxX = Math.Max(StartPoint.X, EndPoint.X);
int maxY = Math.Max(StartPoint.Y, EndPoint.Y);
// Add 1 to make border around selection area
Point StartCorner = new Point(minX - 1, minY - 1);
Point EndCorner = new Point(maxX + 1, maxY + 1);
// Update selection box
Point size = EndCorner - StartCorner + new Point(1, 1);
Rectangle selection = new Rectangle(StartCorner, size);
ControlSystem.UpdateSelectionBox(selection);
}
/// <summary>
/// Raises the <see cref="MouseExit"/> event.
/// </summary>
/// <param name="state">Current mouse state in relation to this console.</param>
protected virtual void OnMouseExit(MouseConsoleState state)
{
// Force mouse off just in case
IsMouseOver = false;
MouseExit?.Invoke(this, new MouseEventArgs(state));
}
public override void ProcessMouse(SadConsole.Console console, MouseConsoleState state, out bool handled)
{
if (state.IsOnConsole)
{
if (state.Mouse.LeftButtonDown && state.Mouse.IsOnScreen)
{
Selection(state);
}
else
{
if (MakingSelection)
{
MakingSelection = false;
ControlSystem.ClearSelectionBox();
}
}
if (state.Mouse.RightClicked)
{
ControlSystem.GiveMoveOrders(state.ConsoleCellPosition);
}
}
handled = true;
}
public void ProcessMouse(MouseConsoleState info, ISurface surface, bool isInBounds)
{
if (info.IsOnConsole)
{
if (info.Mouse.LeftButtonDown)
{
var cell = info.Cell;
cell.Glyph = CharacterPickPanel.SharedInstance.SettingCharacter;
cell.Foreground = CharacterPickPanel.SharedInstance.SettingForeground;
cell.Background = CharacterPickPanel.SharedInstance.SettingBackground;
cell.Mirror = CharacterPickPanel.SharedInstance.SettingMirrorEffect;
surface.IsDirty = true;
}
if (info.Mouse.RightButtonDown)
{
var cell = info.Cell;
CharacterPickPanel.SharedInstance.SettingCharacter = cell.Glyph;
CharacterPickPanel.SharedInstance.SettingForeground = cell.Foreground;
CharacterPickPanel.SharedInstance.SettingBackground = cell.Background;
CharacterPickPanel.SharedInstance.SettingMirrorEffect = cell.Mirror;
}
}
}
public override bool ProcessMouse(MouseConsoleState state)
{
if (state != null)
{
MousePosition = state.CellPosition;
}
return(base.ProcessMouse(state));
}
public override void ProcessMouse(SadConsole.Console console, MouseConsoleState state, out bool handled)
{
if (state.Mouse.RightClicked)
{
console.Parent = SadConsole.Global.CurrentScreen;
console.Components.Remove(this);
}
handled = false;
}
protected override void OnRightMouseClicked(MouseConsoleState info)
{
var location = this.TransformConsolePositionByControlPosition(info.CellPosition);
if (location.X >= Width - 3)
{
RightClickedColor?.Invoke(this, EventArgs.Empty);
base.OnRightMouseClicked(info);
}
}
public override bool ProcessMouse(MouseConsoleState info)
{
base.ProcessMouse(info);
if (info.Mouse.RightClicked)
{
Hide();
}
return(true);
}
/// <summary>
/// Processes the mouse.
/// </summary>
/// <param name="state">The mouse state related to this console.</param>
/// <returns>True when the mouse is over this console and processing should stop.</returns>
public virtual bool ProcessMouse(MouseConsoleState state)
{
if (!IsVisible)
{
return(false);
}
foreach (var component in ComponentsMouse.ToArray())
{
component.ProcessMouse(this, state, out bool isHandled);
if (isHandled)
{
return(true);
}
}
if (!UseMouse)
{
return(false);
}
if (state.IsOnConsole)
{
if (IsMouseOver != true)
{
IsMouseOver = true;
OnMouseEnter(state);
}
OnMouseMove(state);
if (state.Mouse.LeftClicked)
{
OnMouseLeftClicked(state);
}
if (state.Mouse.RightClicked)
{
OnRightMouseClicked(state);
}
return(true);
}
if (IsMouseOver)
{
IsMouseOver = false;
OnMouseExit(state);
}
return(false);
}
public override bool ProcessMouse(MouseConsoleState state)
{
// Process mouse for each console
var childState = new MouseConsoleState(controlsConsole, state.Mouse);
if (childState.IsOnConsole)
{
return(controlsConsole.ProcessMouse(childState));
}
return(false);
}
public void ProcessMouse(MouseConsoleState info, ISurface surface, bool isInBounds)
{
if (info.IsOnConsole && info.Mouse.LeftClicked)
{
var cell = surface.GetCell(info.ConsolePosition.X, info.ConsolePosition.Y);
var editor = MainScreen.Instance.ActiveEditor as Editors.GameObjectEditor;
if (editor != null)
{
editor.SetAnimationCenter(new Point(info.ConsolePosition.X, info.ConsolePosition.Y));
}
}
}
public override bool ProcessMouse(MouseConsoleState state)
{
// Check the scroll bar for mouse info first. If mouse not handled by scroll bar, then..
// Create a mouse state based on the controlsHost
if (!_controlsHost.ProcessMouse(new MouseConsoleState(_controlsHost, state.Mouse)))
{
// Process this console normally.
return(_mainConsole.ProcessMouse(state));
}
return(false);
}
public override void ProcessMouse(SadConsole.Console console, MouseConsoleState state, out bool handled)
{
if (state.Mouse.IsOnScreen)
{
console.Print(0, 0, "cellposition X : " + state.CellPosition.X + " ; Y : " + state.CellPosition.Y);
//console.SetBackground(state.CellPosition.X, state.CellPosition.Y, Color.HotPink);
var child = console.Children[0];
child.Position = state.CellPosition;
//console.Clear();
}
handled = false;
}
public void ProcessMouse(MouseConsoleState info, ISurface surface, bool isInBounds)
{
if (info.IsOnConsole && info.Mouse.LeftClicked)
{
MainScreen.Instance.AllowKeyboardToMoveConsole = false;
writing = true;
tempConsole.TextSurface = (ISurface)surface;
tempConsole.VirtualCursor.Position = Brush.Position = info.ConsolePosition;
Brush.IsVisible = true;
}
}
public override bool ProcessMouse(MouseConsoleState state)
{
mouseCursor.IsVisible = state.IsOnConsole;
mouseCursor.Position = state.ConsoleCellPosition;
List <string> tooltipItems = GetToolTipItems(state.ConsoleCellPosition.X, state.ConsoleCellPosition.Y);
if (tooltipItems.Count > 0)
{
tooltip.Resize(tooltipItems.GetLengthOfLongestItem(), tooltipItems.Count, true);
int lineCounter = 0;
foreach (var item in tooltipItems)
{
if (item.StartsWith("Ship"))
{
tooltip.Print(0, lineCounter, item, Color.White, Color.Black);
}
if (item.StartsWith("Star"))
{
tooltip.Print(0, lineCounter, item, Color.Yellow, Color.Black);
}
if (item.StartsWith("Planet"))
{
tooltip.Print(0, lineCounter, item, Color.CornflowerBlue, Color.Black);
}
if (item.StartsWith("Asteroid"))
{
tooltip.Print(0, lineCounter, item, Color.SandyBrown, Color.Black);
}
if (item.StartsWith("Moon"))
{
tooltip.Print(0, lineCounter, item, Color.GhostWhite, Color.Black);
}
if (item.StartsWith("Warpgate"))
{
tooltip.Print(0, lineCounter, item, Color.GreenYellow, Color.Black);
}
lineCounter++;
}
tooltip.Position = state.ConsoleCellPosition + new Point(1, 1);
tooltip.IsVisible = true;
}
else
{
tooltip.IsVisible = false;
}
if ((tooltip.Position.X + tooltip.Width) > Width)
{
tooltip.Position = state.ConsoleCellPosition - new Point(tooltip.Width + 2, 0);
}
return(base.ProcessMouse(state));
}
protected virtual void OnMouseLeftClicked(MouseConsoleState state)
{
if (MoveToFrontOnMouseClick && Parent != null && Parent.Children.IndexOf(this) != Parent.Children.Count - 1)
{
Parent.Children.MoveToTop(this);
}
if (FocusOnMouseClick && !IsFocused)
{
IsFocused = true;
}
MouseButtonClicked?.Invoke(this, new MouseEventArgs(state));
}
public override bool ProcessMouse(MouseConsoleState state)
{
// Create a new temp state based on the our "behind the scenes" console that holds the scroll bar
var stateForScroll = new MouseConsoleState(controlsContainer, state.Mouse);
// Check if this state, based on the console holding the scroll bar
if (stateForScroll.IsOnConsole)
{
controlsContainer.ProcessMouse(stateForScroll);
return(true);
}
// if we're here, process the mouse like normal.
return(base.ProcessMouse(state));
}
public override bool ProcessMouse(MouseConsoleState mouseState)
{
if (isMouseOver)
{
var scrollValue = mouseState.Mouse.ScrollWheelValueChange;
if (scrollValue > 0)
{
scroll.Value += scroll.Step;
}
if (scrollValue < 0)
{
scroll.Value -= scroll.Step;
}
}
return(base.ProcessMouse(mouseState));
}
public override bool ProcessMouse(MouseConsoleState state)
{
// Process mouse for each console
var childState = new MouseConsoleState(mainView, state.Mouse);
if (childState.IsOnConsole)
{
return(mainView.ProcessMouse(childState));
}
childState = new MouseConsoleState(subView, state.Mouse);
if (childState.IsOnConsole)
{
return(subView.ProcessMouse(childState));
}
return(false);
}
/// <summary>
/// Processes the mouse.
/// </summary>
/// <param name="state"></param>
/// <returns>True when the mouse is over this console.</returns>
public virtual bool ProcessMouse(MouseConsoleState state)
{
var handlerResult = MouseHandler?.Invoke(this, state) ?? false;
if (!handlerResult)
{
if (this.IsVisible && this.UseMouse)
{
if (state.IsOnConsole)
{
if (isMouseOver != true)
{
isMouseOver = true;
OnMouseEnter(state);
}
OnMouseMove(state);
if (state.Mouse.LeftClicked)
{
OnMouseLeftClicked(state);
}
if (state.Mouse.RightClicked)
{
OnRightMouseClicked(state);
}
return(true);
}
else
{
if (isMouseOver)
{
isMouseOver = false;
OnMouseExit(state);
}
}
}
}
return(handlerResult);
}
public override bool ProcessMouse(MouseConsoleState state)
{
if (!IsVisible)
{
return(false);
}
foreach (var component in ComponentsMouse.ToArray())
{
component.ProcessMouse(this, state, out bool isHandled);
if (isHandled)
{
return(true);
}
}
return(false);
}
public override bool ProcessMouse(MouseConsoleState state)
{
// Lose focus if we click outside of the textbox
if (!_textInput.DisableKeyboard && state.Mouse.LeftClicked && !_textInput.MouseBounds.Contains(state.CellPosition))
{
_textInput.Text = "Type here..";
_textInput.FocusLost();
_textInputInUse = false;
return(true);
}
// Clear input when clicking on the field
if (_textInput.DisableKeyboard && state.Mouse.LeftClicked && _textInput.MouseBounds.Contains(state.CellPosition))
{
_textInput.Text = string.Empty;
_textInputInUse = true;
}
return(base.ProcessMouse(state));
}
protected override void OnMouseLeftClicked(MouseConsoleState state)
{
base.OnMouseLeftClicked(state);
var position = state.CellPosition;
GameScreen.Link foundlink = null;
foreach (GameScreen.Link link in GameScreen.links)
{
if (link.points.Contains(position))
{
foundlink = link;
break;
}
}
if (foundlink != null)
{
QuestLike.Game.ProcessInput(foundlink.text, true);
}
}
protected override void OnLeftMouseClicked(MouseConsoleState info)
{
if (!DisableColorPicker)
{
var location = this.TransformConsolePositionByControlPosition(info.CellPosition);
if (location.X >= Width - 3)
{
_popup.SelectedColor = _selectedColor;
_popup.Show(true);
base.OnLeftMouseClicked(info);
}
}
else if (EnableCharacterPicker)
{
var location = this.TransformConsolePositionByControlPosition(info.CellPosition);
if (location.X >= Width - 3)
{
base.OnLeftMouseClicked(info);
}
}
}
/// <summary>
/// Processing the mouse ignoring the attached <see cref="MouseHandler"/>.
/// </summary>
/// <param name="state">The mouse state related to this console.</param>
/// <returns>True when the mouse is over this console and processing should stop.</returns>
public bool ProcessMouseNonHandler(MouseConsoleState state)
{
var handlerResult = MouseHandler?.Invoke(this, state) ?? false;
if (handlerResult || !IsVisible || !UseMouse)
{
return(false);
}
if (state.IsOnConsole)
{
if (isMouseOver != true)
{
isMouseOver = true;
OnMouseEnter(state);
}
OnMouseMove(state);
if (state.Mouse.LeftClicked)
{
OnMouseLeftClicked(state);
}
if (state.Mouse.RightClicked)
{
OnRightMouseClicked(state);
}
return(true);
}
if (isMouseOver)
{
isMouseOver = false;
OnMouseExit(state);
}
return(false);
}
protected override void OnMouseLeftClicked(MouseConsoleState state)
{
base.OnMouseLeftClicked(state);
var objects = GetAllObjectsAtPoint(state.ConsoleCellPosition);
if (objects.Count == 1)
{
QuestLike.Game.ProcessInput($"look at {objects.First().ID}", true);
}
else if (objects.Count > 1)
{
Utilities.PromptSelection <GameObject>($"There are {objects.Count} items at this position, what do you want to look at?", objects.ToArray(), (gameobject, canceled) =>
{
if (canceled)
{
return;
}
QuestLike.Game.ProcessInput($"look at {gameobject.ID}", true);
});
}
}
