private void button1_Click(object sender, EventArgs e)
{
ResetButtons();
button1.BackColor = System.Drawing.SystemColors.ButtonHighlight;
label1.Text = "Select actor to add on the right, the click on the left...";
CurrentMouseMode = MouseMode.Add;
}
private void button5_Click(object sender, EventArgs e)
{
ResetButtons();
button5.BackColor = System.Drawing.SystemColors.ButtonHighlight;
label1.Text = "Paint rectangle to select actors...";
CurrentMouseMode = MouseMode.Select;
}
public static void CreateRectangle()
{
System.Windows.Forms.Cursor.Current = System.Windows.Forms.Cursors.Cross;
if (CurrentLevel != null)
{
Mousemode = MouseMode.DrawRectangle;
//CurrentLevel.Rectangles.Add(new PhysicsRectangle(new Vector2(10, 10), 100, 100, 0));
}
}
private void ChangeMouseMode(MouseMode mouseMode)
{
rayTracingControl1.MouseMode = mouseMode;
switch (mouseMode)
{
case MouseMode.Pan :
btnMouseModePan.Checked = true;
btnMouseModeArcBall.Checked = false;
break;
case MouseMode.ArcBall:
btnMouseModePan.Checked = false;
btnMouseModeArcBall.Checked = true;
break;
}
}
public void Render(RenderInfo renderInfo, MouseMode mouseMode, Control control, InputState inputState)
{
using (_canvas.SetUpFrame(renderInfo, mouseMode))
{
if (inputState.Mouse != null)
{
/* Convert the screen coordinates into virtual canvas coordinates. */
inputState.Mouse.Position.X *= _canvas.Width / renderInfo.Width;
inputState.Mouse.Position.Y *= _canvas.Height / renderInfo.Height;
}
control.HandleInput(inputState);
control.Render(_canvas);
DrawFps(_canvas);
}
}
void Update()
{
currFramePosition = Camera.main.ScreenToWorldPoint(Input.mousePosition);
currFramePosition.z = 0;
if (Input.GetKeyUp(KeyCode.Escape))
{
if (currentMode == MouseMode.BUILD)
{
currentMode = MouseMode.SELECT;
}
else if (currentMode == MouseMode.SELECT)
{
Debug.Log("Show Game Menu?");
}
}
updateDrag();
updateCameraMovement();
lastFramePosition = Camera.main.ScreenToWorldPoint(Input.mousePosition); //Per camera ortografica -- raycast per la prospettiva
lastFramePosition.z = 0;
}
private void validateMouseMode(MouseEventArgs e)
{
if (e.X < _currentSight.Width - 10 && e.Y < _currentSight.Height - 10)
{
_aquariumControl.Cursor = Cursors.Hand;
_mouseMode = MouseMode.Move;
}
else if (e.X >= _currentSight.Width - 10 && e.Y < _currentSight.Height - 10)
{
_aquariumControl.Cursor = Cursors.SizeWE;
_mouseMode = MouseMode.ResizeWidth;
}
else if (e.X < _currentSight.Width - 10 && e.Y >= _currentSight.Height - 10)
{
_aquariumControl.Cursor = Cursors.SizeNS;
_mouseMode = MouseMode.ResizeHeight;
}
else
{
_aquariumControl.Cursor = Cursors.SizeNWSE;
_mouseMode = MouseMode.ResizeBoth;
}
}
/// <summary>
/// Determines if a mouse click has occurred and execute or cancel the appropriate command.
/// </summary>
private void GetClick()
{
if (Input.GetMouseButtonDown(0))
{
if (mouseMode == MouseMode.Command)
{
command(GetGroundPosition(Input.mousePosition)); //perform selected action (move, attack, patrol, etc.)
mouseMode = MouseMode.Standard; //action performed, return to standard mouse mode
}
//unit selection script handles standard left mouse clicks by default
}
else if (Input.GetMouseButtonDown(1))
{
if (mouseMode == MouseMode.Command)
{
mouseMode = MouseMode.Standard; //cancel command
}
else if (mouseMode == MouseMode.Standard)
{
moveCommand.MoveUnits(GetGroundPosition(Input.mousePosition)); //standard right click is always to move selected units
}
}
}
public void SelectTile(TileButton button)
{
//Cleanup prev obj
if (cursorObj != null)
{
GameObject.Destroy(cursorObj);
}
if (currentButton != null)
{
currentButton.SetSelected(false);
}
//Set tile
currentButton = button;
currentTile = currentButton != null?button.GetTile() : null;
//Load new obj
if (currentTile != null)
{
cursorObj = GameObject.Instantiate(currentTile.gameObject);
mouseMode = MouseMode.PAINT;
}
}
/// <summary>
/// This action is performed when you want the system to treat it as if 'escape' was pressed.
/// </summary>
private void OnEscape()
{
/* Will do the following;
* Stop dragging
* Selection = null
* If it was caused by a left click and we aren't panning then turn off tooltips (for UI)
* If the currentMode is default then it'll handle context menu
* It also reset the current mode if it isn't UI (and if it is inventory then panning == false).
*/
IsDragging = false;
Selection = null;
if (currentMode == MouseMode.BUILD || currentMode == MouseMode.INVENTORY || currentMode == MouseMode.COORDINATES)
{
// If it is Build or Default then set to default
// Else if it is inventory and panning == false then set to default
if (currentMode != MouseMode.INVENTORY || IsPanning == false)
{
currentMode = MouseMode.COORDINATES;
}
}
}
private void ProfileEventsViewer_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
{
m_LastX = e.X;
m_LastY = e.Y;
if (e.Button == MouseButtons.Left)
{
if (shiftIsDown)
{
m_MouseMode = MouseMode.Pan;
Capture = true;
}
else if (ctrlIsDown)
{
m_FocusTime = ConvertXToTime(e.X);
m_MouseMode = MouseMode.ZoomOnLocation;
Capture = true;
}
else
{
if (openFileName != null)
{
m_eventSelection = GetEventFromMousePosition(e.X, e.Y);
Invalidate();
}
}
}
if (e.Button == MouseButtons.Right)
{
Capture = true;
m_MouseMode = MouseMode.MarkRange;
m_RangeStart = ConvertXToTime(e.X);
m_RangeEnd = m_RangeStart;
m_FocusTime = m_RangeStart;
}
}
void CreateLines(Transform[] points, int id)
{
// Creates the graphical strings.
SpawnerOutput lGraphic = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(ButtonWrapper));
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Image>(lGraphic, "Image").rectTransform.pivot = new Vector2(0.5f, 0);
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Text>(lGraphic, "Text").text = "";
// Adds event for changing of button colors
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Button>(lGraphic).onClick.AddListener(() => {
switch (mMode)
{
case MouseMode.EDIT_CONN:
int[] linkData = abilityData.linkAddresses.l[id];
if (!LoadedData.GetVariableType(abilityData.subclasses.l[linkData[0]].classType, linkData[1], VariableTypes.PERMENANT_TYPE))
{
linkData[4] = (int)lMode;
UpdateLineColor(id);
mMode = MouseMode.NONE;
}
break;
case MouseMode.REMOVE_CONN:
RemoveLine(id);
mMode = MouseMode.NONE;
break;
}
});
LineData line = new LineData(points[0], points[1], lGraphic);
lineData.ModifyElementAt(id, line);
UpdateLineColor(id);
UpdateLines(id);
}
public void RestartLevel()
{
AllPawn = new List <Pawn>();
AllPawnTransform = new List <Transform>();
AllEscapingAI = new List <EscapingAI>();
AllEscapingTransform = new List <Transform>();
BuildPointGO = new List <GameObject>();
BuildPointMR = new List <MeshRenderer>();
BuildPointTrn = new List <Transform>();
BuildPointOld = new List <GameObject>();
oldCountPoint = 0;
TowersGOOne = new List <GameObject>();
TowersGOTwo = new List <GameObject>();
TowersGOThree = new List <GameObject>();
AllBuildTowers = new List <GameObject>();
EnemyGO = new List <GameObject>();
CurrentMouseMode = MouseMode.Empty;
}
private void PictureBox1_MouseWheel(object sender, MouseEventArgs e)
{
if (e.Delta != 0)
{
if (e.Delta <= 0)
{
//set minimum size to zoom
if (pictureBox1.Width < 800)
{
return;
}
}
else
{
//set maximum size to zoom
if (pictureBox1.Width > 10000)
{
return;
}
}
ZoomInOut(e.Delta, e.Location);
if (pictureBox1.Width > panel1.Width || pictureBox1.Height > panel1.Height)
{
Cursor = Cursors.Hand;
mouseModeEnum = MouseMode.PANNING;
}
else
{
mouseModeEnum = MouseMode.NONE;
Cursor = Cursors.Default;
}
pictureBox1.Invalidate();
}
}
//Enters DragDrop
private void DlgLineEntityConnect_PreviewMouseDown(object sender, MouseEventArgs e)
{
Rectangle convertedConnecter = sender as Rectangle;
if (convertedConnecter == null)
{
return;
}
mouseMode = MouseMode.Connect;
mw.tbMouseMode.Text = "Connect";
DlgLineEntity.Selected = convertedConnecter.Tag as DlgLineEntity;
DlgLineEntity.Selected.HideConnects();
Dlg.InteractionConnection.Selected = new Dlg.InteractionConnection();
Dlg.InteractionConnection.Selected.startRect = convertedConnecter;
Dlg.InteractionConnection.Selected.startInteraction = DlgLineEntity.Selected.interaction;
Point relativePoint = GetRelativeLocation(convertedConnecter, mapCanvas);
relativePoint.X += convertedConnecter.Width / 2;
relativePoint.Y += convertedConnecter.Height / 2;
Dlg.InteractionConnection.Selected.arrow = new Dlg.Arrow(relativePoint, mapCanvas);
//currentConnection.arrow.StrokeThickness = 4;
//currentConnection.arrow.Stroke = System.Windows.Media.Brushes.Black;
Dlg.InteractionConnection.Selected.arrow.Fill = System.Windows.Media.Brushes.Black;
Dlg.InteractionConnection.Selected.arrow.IsHitTestVisible = false;
Dlg.InteractionConnection.Selected.arrow.Opacity = 0.6;
DragDrop.DoDragDrop(convertedConnecter, new DataObject(DlgLineEntity.Selected), DragDropEffects.Move);
Dlg.InteractionConnection.Selected = null;
//Hide all drops and do more
//Disable HitTestVisible for all interactionConnections
}
public void StartBuildMode()
{
_mode = MouseMode.Build;
}
/// <summary>
/// Starts moving the mouse in the radar mode, in the specified
/// direction
/// </summary>
/// <param name="direction">clockwise/counter-clockwise</param>
private void startRadarSweep(RadarMouseMover.RadarSweepDirections direction)
{
if (_radarMouseMover.IsIdle())
{
_mode = MouseMode.Radar;
pause();
_radarMouseMover.SetSweepDirection(direction);
AuditLog.Audit(new AuditEventMouseMover("radar", direction.ToString()));
_radarMouseMover.Start();
}
}
/// <summary>
/// Handles state changes in the grid/radar mouse movers. If the
/// scanner is paused, resumes animation, and resets the mode
/// </summary>
/// <param name="e">event args</param>
private void handleStateChanged(MouseMoverStateChangedEventArgs e)
{
if (e.State == MouseMoverStates.Idle)
{
if (_scannerCommon.IsPaused)
{
resume();
}
_mode = MouseMode.None;
}
}
public MouseModeChangedEventArguments(MouseMode mode, bool locked)
{
Mode = mode;
MouseLocked = locked;
}
public void StartBuildMode()
{
currentMode = MouseMode.BUILD;
}
private void moveCameraRadioButton_CheckedChanged(object sender, EventArgs e)
{
if (moveCameraRadioButton.Checked)
{
hedMouseMode = MouseMode.MoveCamera;
editableHeightField.ShowBrush = false;
}
}
public static void PushButtonMap(MouseMode mode)
{
button_map.Add(null);
mouse_mode.Add(mode);
RemoveHighlight();
RemoveMouseover();
}
private void btnClearSelection_Click(object sender, RoutedEventArgs e)
{
try
{
_Model.PerformSelectionOperation(new SelectionOperation() { Clear = true });
UpdateMap(false);
_mouseMode = MouseMode.None;
canvas.Cursor = Cursors.Arrow;
}
catch (Exception ex)
{
HandleError(ex);
}
}
static LevelManager()
{
Mousemode = MouseMode.Select;
}
public static void MouseUp(Vector2 position)
{
//lastMouseDownPos = position;
switch (Mousemode)
{
case MouseMode.Select:
CurrentObject = null;
CurrentObjectOffset = Vector2.Zero;
break;
case MouseMode.DrawRectangle:
tempRectangle.BottomRight = position;
tempRectangle.Width = Math.Abs(tempRectangle.Width);
tempRectangle.Height = Math.Abs(tempRectangle.Height);
//CurrentLevel.Rectangles.Add(tempRectangle);
//tempRectangle = PhysicsRectangle.Empty;
Mousemode = MouseMode.DrawRectangleRotate;
rotatePoint = tempRectangle.Position;
break;
}
}
public static void MouseDown(Vector2 position)
{
//lastMouseDownPos = position;
switch (Mousemode)
{
case MouseMode.Select:
//if (GetCircleAABB(startPoint.Position, StartPoint.radius).Contains((int)position.X, (int)position.Y))
//startPoint.SetPosition(position);
if (GetCircleAABB(startPoint.Position, StartPoint.radius).ContainsVector(position))
//if (startPoint.ContainsPoint(position))
{
CurrentObject = startPoint;
CurrentObjectOffset = CurrentObject.GetPosition() - position;
}
break;
case MouseMode.DrawRectangle:
tempRectangle = new PhysicsRectangle(position, position *2, 0);
tempRectangle.TopLeft = position;
break;
case MouseMode.DrawRectangleRotate:
//tempRectangle = new PhysicsRectangle(position, Vector2.Zero, 0);
tempRectangle.Rotation = (float)Math.Atan2(rotatePoint.Y - position.Y, rotatePoint.X - position.X);
CurrentLevel.Rectangles.Add(tempRectangle);
tempRectangle = PhysicsRectangle.Empty;
Mousemode = MouseMode.Select;
break;
}
}
//*************************************************************************
// Constructor: NodeXLControl()
//
/// <summary>
/// Initializes a new instance of the <see cref="NodeXLControl" /> class.
/// </summary>
//*************************************************************************
public NodeXLControl()
{
m_oGraph = new Graph();
m_oGraphDrawer = new GraphDrawer(this);
m_oAsyncLayout = new FruchtermanReingoldLayout();
OnNewLayout(m_oAsyncLayout);
m_oLastLayoutContext =
new LayoutContext(System.Drawing.Rectangle.Empty);
m_oLastGraphDrawingContext = null;
m_eLayoutState = LayoutState.Stable;
m_eMouseMode = MouseMode.Select;
m_bMouseAlsoSelectsIncidentEdges = true;
m_bAllowVertexDrag = true;
m_oVerticesBeingDragged = null;
m_oMarqueeBeingDragged = null;
m_oTranslationBeingDragged = null;
m_oSelectedVertices = new HashSet<IVertex>();
m_oSelectedEdges = new HashSet<IEdge>();
m_oCollapsedGroups = new Dictionary<String, IVertex>();
m_oDoubleClickedVertexInfo = null;
m_bShowVertexToolTips = false;
m_oLastMouseMoveLocation = new Point(-1, -1);
// Create a helper object for displaying vertex tooltips.
CreateVertexToolTipTracker();
m_oVertexToolTip = null;
m_bGraphZoomCentered = false;
this.AddLogicalChild(m_oGraphDrawer.VisualCollection);
CreateTransforms();
// Prevent a focus rectangle from being drawn around the control when
// it captures keyboard focus. The focus rectangle does not behave
// properly when the layout and render transforms are applied --
// sometimes the rectangle disappears, and sometimes it gets magnified
// by the render layout.
this.FocusVisualStyle = null;
// AssertValid();
}
private void moveCameraToolStripMenuItem_Click(object sender, EventArgs e)
{
this.mouseModeToolStripButton.Image = global::ModelViewer.Properties.Resources.camera;
mouseMode = MouseMode.MoveCamera;
}
void Awake()
{
pointerPosition = new Vector2(Screen.width / 2, Screen.height / 2); //Set pointer position to center of screen
instance = this;
mode_ = MouseMode.RELATIVE;
}
private void btnMoveSelected_Click(object sender, RoutedEventArgs e)
{
_mouseMode = MouseMode.MoveSelected;
canvas.Cursor = Cursors.SizeAll;
}
/// <summary>
/// Handling mouse leave event of the cotnrol.
/// </summary>
/// <param name="e">EventArgs</param>
protected override void OnMouseLeave(EventArgs e)
{
base.OnMouseLeave(e);
State = MouseMode.Normal;
Invalidate();
}
private void btnMoveSelection_Click(object sender, RoutedEventArgs e)
{
_mouseMode = MouseMode.MoveSelection;
canvas.Cursor = Cursors.ScrollAll;
}
private bool HandleEvent(int code, IntPtr wParam, IntPtr lParam)
{
//Debug.WriteLineIf(DEBUG, string.Format("Code: {0} wParam: {1} lParam: {2}", code, wParam, lParam));
ExtraMouse mouseEvent = new ExtraMouse(wParam, lParam);
switch (mouseEvent.Action)
{
case ExtraMouseActions.Down:
Debug.WriteLineIf(DEBUG, string.Format("{0} button _DOWN_ X: {1} Y: {2}", mouseEvent.Button, mouseEvent.Position.X, mouseEvent.Position.Y));
if (m_mouseMode == MouseMode.Toggle || m_mouseMode == MouseMode.WheelBtn)
{
return(false);
}
if (m_bUsingClassicCurveOnly && mouseEvent.Button != m_btnToggle)
{
break; //raise event
}
if (m_mouseHoldDownBtn == null)
{
m_mouseHoldDownBtn = mouseEvent;
m_cEnableHoldDownBtn.Start();
return(true);
}
else
{
if (!m_bUsingDoublebtn)
{
return(false);
}
//m_wndUnderCursor = GetWndUnderCursor.FromPoint(mouseEvent.Position);
m_mouseMode = MouseMode.DoubleBtn;
// second button has not been pushed yet
if (m_mouseExecuteBtn == null)
{
m_cEnableHoldDownBtn.Stop();
m_mouseExecuteBtn = mouseEvent;
Debug.WriteLineIf(DEBUG, "Start Timer OnDoubleBtnAction Notify Only");
RestartMouseInactivityTimer();
//OnDoubleBtnAction(m_mouseTrigger.ToMouseEvent(), m_mouseModifier.ToMouseEvent(), true);
return(true);
}
// second button was already released, use it again
else if (m_mouseExecuteBtn.Action == ExtraMouseActions.Up)
{
m_mouseExecuteBtn = mouseEvent;
Debug.WriteLineIf(DEBUG, "Start Timer OnDoubleBtnAction Notify Only");
RestartMouseInactivityTimer();
//OnDoubleBtnAction(m_mouseTrigger.ToMouseEvent(), m_mouseModifier.ToMouseEvent(), true);
return(true);
}
}
break;
case ExtraMouseActions.Up:
Debug.WriteLineIf(DEBUG, string.Format("{0} button ^UP^ X: {1} Y: {2}", mouseEvent.Button, mouseEvent.Position.X, mouseEvent.Position.Y));
if (m_mouseMode == MouseMode.Toggle && m_mouseHoldDownBtn.Button == mouseEvent.Button)
{
m_mouseHoldDownBtn = null;
m_mouseMode = MouseMode.None;
StopMouseInactivityTimer();
//SimulateHiddenAction(ExtraMouseActions.Up, mouseEvent.Position);
RaiseMouseEvent(mouseEvent);
return(true);
}
else if (m_mouseMode == MouseMode.WheelBtn && m_mouseHoldDownBtn.Button == mouseEvent.Button)
{
Debug.WriteLineIf(DEBUG, "Raise OnWheelBtnAction - Hold-down button released");
OnWheelBtnAction(m_mouseHoldDownBtn.ToMouseEvent(), ExtraMouseActions.None);
m_mouseHoldDownBtn = null;
m_mouseMode = MouseMode.None;
return(true);
}
//raise event...
if (m_mouseHoldDownBtn == null)
{
RaiseMouseEvent(mouseEvent);
if (isEventCancelled())
{
return(true);
}
else
{
return(false);
}
}
if (m_mouseHoldDownBtn.Button == mouseEvent.Button)
{
StopMouseInactivityTimer();
m_cEnableHoldDownBtn.Stop();
if (m_mouseExecuteBtn == null)
{
// mouse click action is raised
lock (this)
{
//RaiseMouseEvent(m_mouseTrigger); //action down
//SimulateMouseAction(m_mouseTrigger);
//RaiseMouseEvent(mouseEvent); //action up
//SimulateMouseAction(mouseEvent.Button, ExtraMouseActions.Click);
RaiseMouseEvent(new ExtraMouse(m_mouseHoldDownBtn.Button, ExtraMouseActions.Click, m_mouseHoldDownBtn.Position));
if (!isEventCancelled())
{
SimulateMouseAction(mouseEvent.Button, ExtraMouseActions.Down);
System.Threading.Thread.Sleep(10);
SimulateMouseAction(mouseEvent.Button, ExtraMouseActions.Up);
}
}
m_mouseHoldDownBtn = null;
m_mouseMode = MouseMode.None;
return(true);
}
else if (m_mouseExecuteBtn.Action == ExtraMouseActions.Down)
{
Debug.WriteLineIf(DEBUG, "Trigger ^UP^ & Modifier _DOWN_ => Swap MODIFIER & TRIGGER");
m_mouseHoldDownBtn = m_mouseExecuteBtn;
m_mouseExecuteBtn = mouseEvent;
//m_mouseMode = MouseMode.DoubleBtn;
return(true);
}
else
{
m_mouseExecuteBtn = null;
m_mouseHoldDownBtn = null;
m_mouseMode = MouseMode.None;
return(true);
}
}
else if (m_mouseExecuteBtn != null)
{
if (m_mouseExecuteBtn.Button == mouseEvent.Button)
{
StopMouseInactivityTimer();
m_mouseExecuteBtn = mouseEvent;
if (m_mouseHoldDownBtn != null)
{
//m_wndUnderCursor = GetWndUnderCursor.FromPoint(mouseEvent.Position);
Debug.WriteLineIf(DEBUG, "Raise OnDoubleBtnAction");
OnDoubleBtnAction(m_mouseHoldDownBtn.ToMouseEvent(), m_mouseExecuteBtn.ToMouseEvent(), false);
//m_mouseModifier = null;
return(true);
}
}
}
break;
case ExtraMouseActions.WheelDown:
case ExtraMouseActions.WheelUp:
if (!m_bUsingWheelBtn)
{
return(false);
}
if (m_mouseHoldDownBtn != null && m_mouseMode == MouseMode.None)
{
m_mouseMode = MouseMode.WheelBtn;
m_cEnableHoldDownBtn.Stop();
//m_wndUnderCursor = GetWndUnderCursor.FromPoint(m_mouseTrigger.Position);
Debug.WriteLineIf(DEBUG, "Raise OnWheelBtnAction");
OnWheelBtnAction(m_mouseHoldDownBtn.ToMouseEvent(), mouseEvent.Action);
return(true);
}
else if (m_mouseMode == MouseMode.WheelBtn)
{
Debug.WriteLineIf(DEBUG, "Raise OnWheelBtnAction");
OnWheelBtnAction(m_mouseHoldDownBtn.ToMouseEvent(), mouseEvent.Action);
return(true);
}
break;
case ExtraMouseActions.Move:
if (m_mouseHoldDownBtn != null && m_mouseMode == MouseMode.None)
{
if (IsDistanceLessThan(m_mouseHoldDownBtn.Position, mouseEvent.Position, m_sensibleZone))
{
return(false);
}
if (m_mouseHoldDownBtn.Button == m_btnToggle && m_bUsingClassicCurve)
{
m_mouseMode = MouseMode.Toggle;
m_cEnableHoldDownBtn.Stop();
Debug.WriteLineIf(DEBUG, "Mouse start moving & ToggleBtn _DOWN_ => RaiseMouseHookEvent()");
OnMouseDownGesture(m_mouseHoldDownBtn.ToMouseEvent());
StartMouseInactivityTimer();
//m_wndUnderCursor = GetWndUnderCursor.FromPoint(m_mouseTrigger.Position);
//SimulateHiddenAction(ExtraMouseActions.Down, m_mouseTrigger.Position);
//return true;
}
else
{
m_mouseMode = MouseMode.None;
m_cEnableHoldDownBtn.Stop();
ExtraMouse mouseTemp = new ExtraMouse(m_mouseHoldDownBtn); //backup mouse trigger so it can be changed during this process
RaiseMouseEvent(mouseTemp);
if (!isEventCancelled())
{
SimulateMouseAction(mouseTemp);
}
m_mouseHoldDownBtn = null;
}
}
else if (m_mouseMode == MouseMode.Toggle)
{
m_pCurrentPosition = mouseEvent.Position;
}
break;
}
if (code == Win32.HC_ACTION)
{
RaiseMouseEvent(mouseEvent);
}
return(false);
}
private void btnSelectTiles_Click(object sender, RoutedEventArgs e)
{
_mouseMode = MouseMode.SelectTiles;
canvas.Cursor = Cursors.IBeam;
}
void ComecaUmaConexao()
{
if (Event.current.type == EventType.mouseDown && modoAtualDoMouse == MouseMode.IDLE )
{
if(Event.current.button==0)
{
for(int i=0; i< listaDeWNodes.Count;i++)
{
Porta porta=listaDeWNodes[i].MouseDownPorta(Event.current.mousePosition, Event.current.button);
if (porta!=null)
{
//verifica ja existe uma conexão
if (JaExisteEsseLink(porta) == -1 || porta.tipoDaPorta == TipoDePorta.SAIDA)
{
_portaSelecionadaAtualmente = porta;
modoAtualDoMouse = MouseMode.CONNECTING;
}
else //essa parte desconecta um nó já com link
{
int link = JaExisteEsseLink(porta);
if (listaDeLinks[link].portas[0].nodoDono.Id == porta.nodoDono.Id)
{
_portaSelecionadaAtualmente = listaDeLinks[link].portas[1];
Debug.Log("o que?");
modoAtualDoMouse = MouseMode.CONNECTING;
listaDeLinks.RemoveAt(link);
}
else
{
_portaSelecionadaAtualmente = listaDeLinks[link].portas[0];
//revisar essa parte do codigo obs: fazer pra que cada porta tenha um link somente!
_portaSelecionadaAtualmente.Link = null;
listaDeLinks[link].portas[1].Link = null;
modoAtualDoMouse = MouseMode.CONNECTING;
listaDeLinks.RemoveAt(link);
}
}
}
}
}
}
}
/// <summary>
/// Allows the user to click on the layout and drag a rectangle where they want to insert an element
/// </summary>
public void AddElementWithMouse(LayoutElement le)
{
_elementToAddWithMouse = le;
ClearSelection();
_mouseMode = MouseMode.StartInsertNewElement;
Cursor = Cursors.Cross;
}
//Изменение режима
public static void ChangeMode(MouseMode mouseMode)
{
Cell.mouseMode = mouseMode;
}
private void LayoutControl_MouseDown(object sender, MouseEventArgs e)
{
//When the user clicks down we start tracking the mouses location
_mouseStartPoint = new PointF(e.X, e.Y);
_lastMousePoint = new PointF(e.X, e.Y);
PointF mousePointPaper = ScreenToPaper(_mouseStartPoint);
//Deals with left buttons clicks
if (e.Button == MouseButtons.Left)
{
switch (_mouseMode)
{
case MouseMode.Default:
//Handles resizing stuff
if (_resizeSelectedEdge != Edge.None)
{
_mouseMode = MouseMode.ResizeSelected;
_selectedLayoutElements[0].Resizing = true;
if (_selectedLayoutElements[0].ResizeStyle != ResizeStyle.HandledInternally)
{
RectangleF selecteScreenRect = PaperToScreen(_selectedLayoutElements[0].Rectangle);
_resizeTempBitmap = new Bitmap(Convert.ToInt32(selecteScreenRect.Width), Convert.ToInt32(selecteScreenRect.Height), PixelFormat.Format32bppArgb);
Graphics graph = Graphics.FromImage(_resizeTempBitmap);
graph.SmoothingMode = _drawingQuality;
graph.ScaleTransform(96F / 100F * _zoom, 96F / 100F * _zoom);
graph.TranslateTransform(-_selectedLayoutElements[0].Rectangle.X, -_selectedLayoutElements[0].Rectangle.Y);
_selectedLayoutElements[0].Draw(graph, false);
graph.Dispose();
}
return;
}
//Starts moving selected elements
if (ModifierKeys != Keys.Control)
{
foreach (LayoutElement le in _selectedLayoutElements)
{
if (le.IntersectsWith(mousePointPaper))
{
_mouseMode = MouseMode.MoveSelection;
Cursor = Cursors.SizeAll;
return;
}
}
}
//Starts the selection code.
_mouseMode = MouseMode.CreateSelection;
_mouseBox = new RectangleF(e.X, e.Y, 0F, 0F);
break;
//Start drag rectangle insert new element
case MouseMode.StartInsertNewElement:
_mouseMode = MouseMode.InsertNewElement;
_mouseBox = new RectangleF(e.X, e.Y, 0F, 0F);
break;
//Starts the pan mode for the map
case MouseMode.StartPanMap:
_mouseMode = MouseMode.PanMap;
_mouseBox = new RectangleF(e.X, e.Y, 0F, 0F);
break;
}
}
//Deals with right button clicks
if (e.Button == MouseButtons.Right)
{
switch (_mouseMode)
{
//If the user was in insert mode we cancel it
case (MouseMode.StartInsertNewElement):
_mouseMode = MouseMode.Default;
_elementToAddWithMouse = null;
Cursor = Cursors.Default;
break;
}
}
}
/// <summary>
/// Starts moving the mouse in the grid mode, in the specified
/// direction
/// </summary>
/// <param name="direction">down or up</param>
private void startGridSweep(GridMouseMover.GridSweepDirections direction)
{
if (_gridMouseMover.IsIdle())
{
_mode = MouseMode.Grid;
pause();
_gridMouseMover.SetGridSweepDirection(direction);
AuditLog.Audit(new AuditEventMouseMover("grid", direction.ToString()));
_gridMouseMover.Start();
}
}
private void LayoutControl_MouseUp(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
//Handles various different mouse modes
switch (_mouseMode)
{
//If we are dealing with a selection we look here
case MouseMode.CreateSelection:
PointF selectBoxTL = ScreenToPaper(_mouseBox.Location);
PointF selectBoxBR = ScreenToPaper(_mouseBox.Location.X + _mouseBox.Width, _mouseBox.Location.Y + _mouseBox.Height);
RectangleF selectBoxPaper = new RectangleF(selectBoxTL.X, selectBoxTL.Y, selectBoxBR.X - selectBoxTL.X, selectBoxBR.Y - selectBoxTL.Y);
if (ModifierKeys == Keys.Control)
{
foreach (LayoutElement le in _layoutElements)
{
if (le.IntersectsWith(selectBoxPaper))
{
if (_selectedLayoutElements.Contains(le))
_selectedLayoutElements.Remove(le);
else
_selectedLayoutElements.Add(le);
//If the box is just a point only select the top most
if (_mouseBox.Width <= 1 && _mouseBox.Height <= 1)
break;
}
}
}
else
{
_selectedLayoutElements.Clear();
foreach (LayoutElement le in _layoutElements)
{
if (le.IntersectsWith(selectBoxPaper))
{
_selectedLayoutElements.Add(le);
//If the box is just a point only select the top most
if (_mouseBox.Width <= 1 && _mouseBox.Height <= 1)
break;
}
}
}
OnSelectionChanged(null);
_mouseMode = MouseMode.Default;
Invalidate();
break;
//Stops moving the selection
case MouseMode.MoveSelection:
_mouseMode = MouseMode.Default;
Cursor = Cursors.Default;
break;
//Turns of resize
case MouseMode.ResizeSelected:
if (_resizeTempBitmap != null)
_resizeTempBitmap.Dispose();
_resizeTempBitmap = null;
_mouseMode = MouseMode.Default;
Cursor = Cursors.Default;
_selectedLayoutElements[0].Resizing = false;
_selectedLayoutElements[0].Size = _selectedLayoutElements[0].Size;
Invalidate(new Region(PaperToScreen(_selectedLayoutElements[0].Rectangle)));
break;
case MouseMode.InsertNewElement:
if (_mouseBox.Width == 0)
_mouseBox.Width = 200;
if (_mouseBox.Height == 0)
_mouseBox.Height = 100;
if (_mouseBox.Width < 0)
{
_mouseBox.X = _mouseBox.X + _mouseBox.Width;
_mouseBox.Width = -_mouseBox.Width;
}
if (_mouseBox.Height < 0)
{
_mouseBox.Y = _mouseBox.Y + _mouseBox.Height;
_mouseBox.Height = -_mouseBox.Height;
}
_elementToAddWithMouse.Rectangle = ScreenToPaper(_mouseBox);
AddToLayout(_elementToAddWithMouse);
AddToSelection(_elementToAddWithMouse);
_elementToAddWithMouse = null;
_mouseMode = MouseMode.Default;
_mouseBox.Inflate(5, 5);
Invalidate(new Region(_mouseBox));
break;
case MouseMode.PanMap:
if (_mouseBox.Width != 0 || _mouseBox.Height != 0)
PanMap(_selectedLayoutElements[0] as LayoutMap, _mouseBox.Width, _mouseBox.Height);
_mouseMode = MouseMode.StartPanMap;
break;
case MouseMode.Default:
break;
}
}
else if (e.Button == MouseButtons.Right)
{
switch (_mouseMode)
{
case MouseMode.Default:
if (_selectedLayoutElements.Count < 1)
{
for (int i = 0; i < _contextMenuRight.MenuItems.Count; i++)
_contextMenuRight.MenuItems[i].Enabled = false;
}
else if (_selectedLayoutElements.Count == 1)
{
_cMnuSelAli.Enabled = false;
_cMnuSelFit.Enabled = false;
}
_contextMenuRight.Show(this, e.Location);
for (int i = 0; i < _contextMenuRight.MenuItems.Count; i++)
_contextMenuRight.MenuItems[i].Enabled = true;
break;
}
}
}
void Update()
{
float dt = Time.deltaTime;
if ((Input.GetKey(KeyCode.RightControl) || Input.GetKey(KeyCode.LeftControl)) && Input.GetKeyDown(KeyCode.Q))
{
doQuit();
}
if (Input.GetKeyDown(KeyCode.H) || Input.GetKeyDown(KeyCode.F1))
{
helpScreen.ToggleVisibility();
}
if (Input.GetKeyDown(KeyCode.Escape))
{
helpScreen.Hide();
}
if (Input.GetKeyDown(KeyCode.Space))
{
ResetMousePos();
// Space bar toggles mode (walk/draw)
if (mouseMode == MouseMode.Look)
{
mouseMode = MouseMode.Stick;
sb.makeVisible();
}
else if (mouseMode == MouseMode.Stick)
{
sb.makeInvisible();
mouseMode = MouseMode.Look;
}
}
if (Input.GetKeyDown(KeyCode.LeftAlt) || Input.GetKeyDown(KeyCode.RightAlt) || Input.GetMouseButtonDown(1))
{
// Alt or RMB means "temporarily activate rotate mode"
// Save current mode, make sure the stick/laser is hidden, and link
// mouse position to object orientation.
ResetMousePos();
savedMode = mouseMode;
if (mouseMode == MouseMode.Stick)
{
sb.makeInvisible();
}
mouseMode = MouseMode.Rotate;
surfaceDelta = surface.transform.position - camera.transform.position;
}
if (Input.GetKeyUp(KeyCode.LeftAlt) || Input.GetKeyUp(KeyCode.RightAlt) || Input.GetMouseButtonUp(1))
{
// Alt or RMB release means restore previous mode
ResetMousePos();
mouseMode = savedMode;
if (mouseMode == MouseMode.Stick)
{
sb.makeVisible();
}
}
if (Input.GetKeyDown(KeyCode.Z))
{
// Clear all drawing on the PaintableTexture
pt.Clear();
}
if (Input.GetKeyDown(KeyCode.P))
{
// Klein-Poincare toggle
h2c.ToggleModel();
h2c.ExportMode();
}
if (Input.GetKeyDown(KeyCode.O))
{
// Reset view position
h2c.ResetPreTransformation();
h2c.ExportPreTransformation();
}
if (Input.GetKey(KeyCode.I))
{
h2c.ComposePreTransformation(HypUtil.BoostY(-h2speed * dt));
h2c.ExportPreTransformation();
}
if (Input.GetKey(KeyCode.K))
{
h2c.ComposePreTransformation(HypUtil.BoostY(h2speed * dt));
h2c.ExportPreTransformation();
}
if (Input.GetKey(KeyCode.J))
{
h2c.ComposePreTransformation(HypUtil.BoostX(h2speed * dt));
h2c.ExportPreTransformation();
}
if (Input.GetKey(KeyCode.L))
{
h2c.ComposePreTransformation(HypUtil.BoostX(-h2speed * dt));
h2c.ExportPreTransformation();
}
// Walk & strafe according to keyboard
float horiz = Input.GetAxis("Horizontal") * speed;
float depth = Input.GetAxis("Vertical") * speed;
camera.transform.Translate(horiz * dt, 0f, depth * dt);
if (mouseMode == MouseMode.Rotate)
{
surface.transform.position = camera.transform.position + surfaceDelta;
}
if (mouseMode == MouseMode.Look)
{
Vector2 mp = AbsMousePos();
camera.transform.localRotation = cameraInitQ * Quaternion.Euler(0, turnRange * mp.x, 0);
}
if (mouseMode == MouseMode.Stick)
{
if (Input.GetKey(KeyCode.LeftShift) || Input.GetMouseButton(0))
{
sb.makeActive();
}
else
{
sb.makeInactive();
}
Vector2 mp = AbsMousePos();
stickHolder.transform.localRotation = stickInitQ * Quaternion.Euler(-0.5f * stickRange * mp.y, 0, -0.5f * stickRange * mp.x);
}
if (mouseMode == MouseMode.Rotate)
{
Vector2 mp = AbsMousePos();
// TODO: Make this a more intuitive trackball-style object rotation interface.
surface.transform.localRotation = Quaternion.AngleAxis(turnRange * mp.y, camera.transform.right) * Quaternion.AngleAxis(-turnRange * mp.x, camera.transform.up) * surfaceInitQ;
}
}
/// <summary>
/// Call this to indicate the selection has changed
/// </summary>
/// <param name="e"></param>
private void OnSelectionChanged(EventArgs e)
{
if (_layoutMapToolStrip != null)
{
if (_selectedLayoutElements.Count == 1 && _selectedLayoutElements[0] is LayoutMap)
_layoutMapToolStrip.Enabled = true;
else
{
_layoutMapToolStrip.Enabled = false;
if (_mouseMode == MouseMode.StartPanMap || _mouseMode == MouseMode.PanMap)
_mouseMode = MouseMode.Default;
}
}
if (SelectionChanged != null)
SelectionChanged(this, e);
}
public void StartSelectMode()
{
_mode = MouseMode.Select;
}
private void SetMode(MouseMode mode)
{
tsbSelect.Checked = false;
tsbPan.Checked = false;
tsbZoom.Checked = false;
tsbRotate.Checked = false;
viewman.Mode = mode;
((ToolStripButton)this.tsStatic.Items.Find("tsb" + mode.ToString(), true)[0]).Checked = true;
}
private void moveDirectionalLightToolStripMenuItem_Click(object sender, EventArgs e)
{
this.mouseModeToolStripButton.Image = global::ModelViewer.Properties.Resources.lightbulb;
mouseMode = MouseMode.MoveDirectionalLight;
}
private void toolStripButton2_Click(object sender, EventArgs e)
{
mMode = MouseMode.SELECT_REGION_MODE;
}
void OnToggleMouseMode(InputValue button)
{
mode_ = (mode_ == MouseMode.RELATIVE ? MouseMode.ABSOLUTE : MouseMode.RELATIVE);
}
void TerminaUmaConexao()
{
if (Event.current.type == EventType.MouseUp && modoAtualDoMouse == MouseMode.CONNECTING )
{
if (Event.current.button == 0)
{
for (int i = 0; i < listaDeWNodes.Count; i++)
{
if (listaDeWNodes[i].MouseUp(Event.current.mousePosition) == true)
{
//cria conexão
Porta porta = listaDeWNodes[i].MouseUpPorta(Event.current.mousePosition);
//se alguma porta for null
if (porta == null || _portaSelecionadaAtualmente == null)
{
modoAtualDoMouse = MouseMode.IDLE;
Debug.Log("porta nula");
}
else
if (JaExisteEsseLink(porta,_portaSelecionadaAtualmente) == -1 && porta.cor==_portaSelecionadaAtualmente.cor ) //se forem de cores diferentes
{
//se as portas forem diferente
if (_portaSelecionadaAtualmente.nodoDono.Id != porta.nodoDono.Id)
{
if (_portaSelecionadaAtualmente.tipoDaPorta == porta.tipoDaPorta)
{
modoAtualDoMouse = MouseMode.IDLE;
Debug.Log("ops portas iguais");
}
else
{
if (porta.Posicao.x < _portaSelecionadaAtualmente.Posicao.x || ( porta.Posicao.x > _portaSelecionadaAtualmente.Posicao.x && porta.tipoDaPorta == TipoDePorta.SAIDA) )
{
modoAtualDoMouse = MouseMode.IDLE;
Debug.Log("conectar para trás: considerei esse um comportamento incoreto, tirar esse if se tiver esse objetivo");
}
else
{
// Debug.Log("criando conexão");
Conectar(_portaSelecionadaAtualmente, porta);
modoAtualDoMouse = MouseMode.IDLE;
}
}
}
else
{
_portaSelecionadaAtualmente = null;
modoAtualDoMouse = MouseMode.IDLE;
Debug.Log("mesmo dono!");
}
}
else
{
modoAtualDoMouse = MouseMode.IDLE;
_portaSelecionadaAtualmente = null;
Debug.Log("ja existe esse link!");
}
}
}
}
if (Event.current.button == 1)
{
_portaSelecionadaAtualmente = null;
modoAtualDoMouse = MouseMode.IDLE;
}
}
if(Event.current.type == EventType.mouseDown && modoAtualDoMouse == MouseMode.CONNECTING)
{
if (Event.current.button == 1)
{
modoAtualDoMouse = MouseMode.IDLE;
}
}
}
protected virtual void HandleMouseUp(object sender, MouseButtonEventArgs e)
{
MouseMode = MouseMode.PreSelectionRectangle;
}
/// <summary>
/// Register a handler for a mouse mode.
/// </summary>
/// <param name="mouseMode"> The mouse mode to register for. </param>
/// <param name="handler"> The handler to register to the mouse mode. </param>
public void RegisterModeHandler(MouseMode mouseMode, IMouseHandler handler)
{
mouseHandlers[(int)mouseMode] = handler;
}
private void toolStripButton1_Click(object sender, EventArgs e)
{
mMode = MouseMode.PENCIL_MODE;
}
/// <summary>
/// Unregister the handler for the mouse mode.
/// </summary>
/// <param name="mouseMode"> The mouse mode to unregister the handler from. </param>
public void UnRegisterModeHandler(MouseMode mouseMode)
{
mouseHandlers[(int)mouseMode] = null;
}
/// <summary>
/// Handling mouse hover event of the control.
/// </summary>
/// <param name="e">EventArgs</param>
protected override void OnMouseHover(EventArgs e)
{
base.OnMouseHover(e);
State = MouseMode.Hovered;
Invalidate();
}
internal static extern void Input_SetMouseMode(IntPtr handle, MouseMode mode, bool suppressEvent);
private void adjustHeightRadioButton_CheckedChanged(object sender, EventArgs e)
{
if (adjustHeightRadioButton.Checked)
{
hedMouseMode = MouseMode.AdjustHeight;
editableHeightField.ShowBrush = true;
}
}
/// <summary>
/// Set the mouse mode.
/// Set the mouse mode behaviour.
/// MM_ABSOLUTE is the default behaviour, allowing the toggling of operating system cursor visibility and allowing the cursor to escape the window when visible.
/// When the operating system cursor is invisible in absolute mouse mode, the mouse is confined to the window.
/// If the operating system and UI cursors are both invisible, interaction with the Urho UI will be limited (eg: drag move / drag end events will not trigger).
/// SetMouseMode(MM_ABSOLUTE) will call SetMouseGrabbed(false).
/// MM_RELATIVE sets the operating system cursor to invisible and confines the cursor to the window.
/// The operating system cursor cannot be set to be visible in this mode via SetMouseVisible(), however changes are tracked and will be restored when another mouse mode is set.
/// When the virtual cursor is also invisible, UI interaction will still function as normal (eg: drag events will trigger).
/// SetMouseMode(MM_RELATIVE) will call SetMouseGrabbed(true).
/// MM_WRAP grabs the mouse from the operating system and confines the operating system cursor to the window, wrapping the cursor when it is near the edges.
/// SetMouseMode(MM_WRAP) will call SetMouseGrabbed(true).
/// MM_FREE does not grab/confine the mouse cursor even when it is hidden. This can be used for cases where the cursor should render using the operating system
/// outside the window, and perform custom rendering (with SetMouseVisible(false)) inside.
/// </summary>
public void SetMouseMode(MouseMode mode, bool suppressEvent = false)
{
Runtime.ValidateRefCounted(this);
Input_SetMouseMode(handle, mode, suppressEvent);
}
public SetMouseModeEvent(MouseMode mode)
{
Mode = mode;
}
private void ToggleRightClickMode()
{
MouseMode = MouseMode == MouseMode.RightClickSelection ? MouseMode.RightClickTile : MouseMode.RightClickSelection;
switch (MouseMode)
{
case MouseMode.RightClickSelection:
TlsTileCommands.Visible = true;
SetHelpText(Reuben.Properties.Resources.RightClickSelectHelper);
break;
case MouseMode.RightClickTile:
TlsTileCommands.Visible = false;
SetHelpText(Reuben.Properties.Resources.RightClickTileHelper);
break;
}
LblRightClickMode.Text = "Right Click Mode: " + (MouseMode == MouseMode.RightClickSelection ? "Selector" : "Tile Placement");
}
public void StartSpawnMode()
{
currentMode = MouseMode.SPAWN_INVENTORY;
}
void AlterarTamanhoNode()
{
if (Event.current.Equals(Event.KeyboardEvent("s")) && modoAtualDoMouse == MouseMode.IDLE)
{
if(nodoSelecionadoAtualmente!=null)
{
modoAtualDoMouse=MouseMode.RESIZING;
}
else
{
Debug.Log("selecione um nó!");
}
}
if(modoAtualDoMouse==MouseMode.RESIZING)
{
EditorGUIUtility.AddCursorRect(new Rect(Event.current.mousePosition.x, Event.current.mousePosition.y, 10, 10), MouseCursor.ResizeUpLeft);
GUI.Box(new Rect(Event.current.mousePosition.x, Event.current.mousePosition.y, 10, 10),"");
Repaint();
if ( Event.current.type==EventType.mouseDrag)
{
if(Event.current.button==0)
{
if (Event.current.delta.magnitude < 300)
{
nodoSelecionadoAtualmente._tamanho.x += Event.current.delta.x ;
nodoSelecionadoAtualmente._tamanho.y += Event.current.delta.y ;
Repaint();
}
}
}
if (Event.current.type==EventType.scrollWheel)
{
if (Event.current.delta.magnitude < 100)
{
nodoSelecionadoAtualmente._tamanho.x -= Event.current.delta.y*2 ;
nodoSelecionadoAtualmente._tamanho.y -= Event.current.delta.y*2 ;
Repaint();
}
}
//comfirma transformação
if (Event.current.type == EventType.mouseUp)
{
modoAtualDoMouse = MouseMode.IDLE;
}
}
}
