private void nativeEvent(IntPtr widget, int left, int top, MouseButtonCode button)
{
//Fill out the MouseEventArgs
eventArgs.Button = button;
eventArgs.Position = new IntVector2(left, top);
fireEvent(eventArgs);
}
private static bool IsButtonPressed(uint buttonsPressedBitmask, MouseButtonCode mouseButtonCode)
{
var buttonPressedMacroResult = SDL.SDL_BUTTON((uint)mouseButtonCode);
var bitmaskComparisonResult = buttonsPressedBitmask & buttonPressedMacroResult;
return(bitmaskComparisonResult > 0);
}
internal static string PrettyButtonName(MouseButtonCode button)
{
switch (button)
{
case MouseButtonCode.MB_BUTTON0:
return("Left Click");
case MouseButtonCode.MB_BUTTON1:
return("Right Click");
case MouseButtonCode.MB_BUTTON2:
return("Mouse Button 2");
case MouseButtonCode.MB_BUTTON3:
return("Mouse Button 3");
case MouseButtonCode.MB_BUTTON4:
return("Mouse Button 4");
case MouseButtonCode.MB_BUTTON5:
return("Mouse Button 5");
case MouseButtonCode.MB_BUTTON6:
return("Mouse Button 6");
case MouseButtonCode.MB_BUTTON7:
return("Mouse Button 7");
default:
return("Unknown Mouse Button");
}
}
public static void changeMouseButton(MouseButtonCode newMouseButton)
{
MoveCamera.removeButton(currentMouseButton);
currentMouseButton = newMouseButton;
MoveCamera.addButton(currentMouseButton);
}
public bool injectMouseRelease(int absx, int absy, MouseButtonCode id)
{
mouseX = absx;
mouseY = absy;
bool handled = InputManager_injectMouseRelease(inputManager, absx, absy, id);
if (MouseButtonReleased != null)
{
MouseButtonReleased.Invoke(absx, absy, id);
}
return(handled);
}
void InputManager_MouseButtonPressed(int x, int y, MouseButtonCode button)
{
int left = window.AbsoluteLeft;
int top = window.AbsoluteTop;
int right = left + window.Width;
int bottom = top + window.Height;
if ((x < left || x > right || y < top || y > bottom) && !(MDIManager != null && MDIManager.isControlWidgetAtPosition(x, y) || keepOpenFromPoint(x, y)))
{
Visible = false;
}
}
internal void fireButtonDown(MouseButtonCode button)
{
int index = (int)button;
buttonDownStatus[index] = true;
pressedThisFrame[index] = true;
if (ButtonDown != null)
{
ButtonDown.Invoke(this, button);
}
}
void mouse_ButtonDown(Mouse mouse, MouseButtonCode buttonCode)
{
if (eventLayer.EventProcessingAllowed)
{
IntVector3 mousePos = mouse.AbsolutePosition;
gui.HandledMouseButtons = inputManager.injectMousePress(mousePos.x, mousePos.y, buttonCode);
if (gui.HandledMouseButtons || inputManager.isModalAny())
{
eventLayer.alertEventsHandled();
eventLayer.Locked = true;
}
}
}
void MouseButtonPressed(int x, int y, MouseButtonCode button)
{
if (!KeepOpen && !InputManager.Instance.isModalAny())
{
int left = widget.AbsoluteLeft;
int top = widget.AbsoluteTop;
int right = left + widget.Width;
int bottom = top + widget.Height;
if ((x < left || x > right || y < top || y > bottom) && !keepOpenFromPoint(x, y))
{
hide();
}
}
}
private int MouseButton ( MouseButtonCode code )
{
int aux = 0;
switch (code)
{
case MouseButtonCode.LEFT:
aux = 0;
break;
case MouseButtonCode.RIGHT:
aux = 1;
break;
case MouseButtonCode.MIDDLE:
aux = 2;
break;
}
return aux;
}
internal void fireButtonUp(MouseButtonCode button)
{
int index = (int)button;
//Make sure the button is down
if (buttonDownStatus[index])
{
buttonDownStatus[index] = false;
if (pressedThisFrame[index])
{
downAndUpThisFrame[index] = true;
}
if (ButtonUp != null)
{
ButtonUp.Invoke(this, button);
}
}
}
private int MouseButton(MouseButtonCode code)
{
int aux = 0;
switch (code)
{
case MouseButtonCode.LEFT:
aux = 0;
break;
case MouseButtonCode.RIGHT:
aux = 1;
break;
case MouseButtonCode.MIDDLE:
aux = 2;
break;
}
return(aux);
}
/// <summary>
/// Constructs a new <see cref="MouseButton"/> using the given code.
/// </summary>
/// <param name="code">The code for the mouse button represented by this <see cref="MouseButton"/>.</param>
public MouseButton(MouseButtonCode code)
{
this.code = code;
}
private static bool IsButtonPressed(uint buttonsPressedBitmask, MouseButtonCode mouseButtonCode)
{
var buttonPressedMacroResult = SDL.SDL_BUTTON((uint)mouseButtonCode);
var bitmaskComparisonResult = buttonsPressedBitmask & buttonPressedMacroResult;
return bitmaskComparisonResult > 0;
}
/// <summary>
/// Remove a mouse button binding from the event.
/// </summary>
/// <param name="button">The button to remove.</param>
public void removeButton(MouseButtonCode button)
{
mouseButtons.Remove(button);
}
/// <summary>
/// Add a mouse button binding to the event.
/// </summary>
/// <param name="button">The button to add.</param>
public void addButton(MouseButtonCode button)
{
mouseButtons.Add(button);
}
protected void fireButtonUp(MouseButtonCode button)
{
mouse.fireButtonUp(button);
}
/// <summary>
/// Inject a mouse up event externally to the hardware mouse.
///
/// Since we need to treat touches as mouse events this input handler provides a way to inject
/// mouse inputs that will follow the normal mouse path. This is only needed on touch only devices
/// that need to simulate the mouse.
/// </summary>
/// <param name="code">The mouse button to simulate.</param>
public override void injectButtonUp(MouseButtonCode code)
{
createdMouse.injectButtonUp(code);
}
/// <summary>
/// Determines if the specified button is pressed.
/// </summary>
/// <returns>True if the button is pressed. False if it is not.</returns>
public bool buttonDown(MouseButtonCode button)
{
return(buttonDownStatus[(int)button]);
}
internal void injectButtonUp(MouseButtonCode button)
{
fireButtonUp(button);
}
internal void injectButtonDown(MouseButtonCode button)
{
fireButtonDown(button);
}
private static void fireButtonUp(MouseButtonCode id, IntPtr instanceHandle)
{
GCHandle handle = GCHandle.FromIntPtr(instanceHandle);
(handle.Target as NativeMouse).fireButtonUp(id);
}
/// <summary> /// Checks if the given mouse button is currently down. /// </summary> /// <param name="code">The <see cref="MouseButtonCode"/> representing the button to check.</param> /// <returns>True if the mouse button is currently down; false if not.</returns> public bool GetMouseButtonDown(MouseButtonCode code) => coreState.Mouse.Buttons[(int)(code)];
private static void nativeEvent(IntPtr widget, int left, int top, MouseButtonCode button, IntPtr instanceHandle)
{
GCHandle handle = GCHandle.FromIntPtr(instanceHandle);
(handle.Target as EventMouseDragTranslator).nativeEvent(widget, left, top, button);
}
void Mouse_ButtonDown(Mouse mouse, MouseButtonCode buttonCode)
{
context.ProcessMouseButtonDown((int)buttonCode, 0);
}
void applyButton_MouseButtonClick(Widget source, EventArgs e)
{
switch (cameraSpeedCombo.SelectedIndex)
{
case 0:
MedicalConfig.CameraTransitionTime = 0.01f;
break;
case 1:
MedicalConfig.CameraTransitionTime = 0.25f;
break;
case 2:
MedicalConfig.CameraTransitionTime = 0.5f;
break;
case 3:
MedicalConfig.CameraTransitionTime = 1.0f;
break;
}
MedicalConfig.EnableMultitouch = enableMultitouchCheck.Checked;
MedicalConfig.ShowDeveloperTools = enableDeveloper.Checked;
MedicalConfig.EngineConfig.ShowStatistics = showStatsCheck.Checked;
MouseButtonCode cameraButtonCode = (MouseButtonCode)cameraButtonCombo.SelectedIndex;
MedicalConfig.CameraMouseButton = cameraButtonCode;
CameraInputController.changeMouseButton(cameraButtonCode);
MedicalConfig.DefaultScene = defaultSceneCombo.SelectedItemData?.ToString() ?? MedicalConfig.DefaultScene;
bool videoOptionsChanged = false;
if (MedicalConfig.ExtraScaling != (UIExtraScale)uiSize.SelectedItemData)
{
MedicalConfig.ExtraScaling = (UIExtraScale)uiSize.SelectedItemData;
videoOptionsChanged = true;
}
if (OgreConfig.FSAA != aaCombo.getItemNameAt(aaCombo.SelectedIndex))
{
OgreConfig.FSAA = aaCombo.getItemNameAt(aaCombo.SelectedIndex);
videoOptionsChanged = true;
}
if (OgreConfig.VSync != vsyncCheck.Checked)
{
OgreConfig.VSync = vsyncCheck.Checked;
videoOptionsChanged = true;
}
if (MedicalConfig.EngineConfig.Fullscreen != fullscreenCheck.Checked)
{
MedicalConfig.EngineConfig.Fullscreen = fullscreenCheck.Checked;
videoOptionsChanged = true;
}
String[] res = resolutionCombo.getItemNameAt(resolutionCombo.SelectedIndex).Split(seps, StringSplitOptions.RemoveEmptyEntries);
int horizRes = NumberParser.ParseInt(res[0]);
int vertRes = NumberParser.ParseInt(res[1]);
if (MedicalConfig.EngineConfig.HorizontalRes != horizRes || MedicalConfig.EngineConfig.VerticalRes != vertRes)
{
MedicalConfig.EngineConfig.HorizontalRes = horizRes;
MedicalConfig.EngineConfig.VerticalRes = vertRes;
videoOptionsChanged = true;
}
int maxFpsValue = maxFPS.IntValue;
if (maxFpsValue < EngineConfig.MinimumAllowedFramerate && maxFpsValue != 0)
{
maxFpsValue = EngineConfig.MinimumAllowedFramerate;
}
if (MedicalConfig.EngineConfig.FPSCap != maxFpsValue)
{
MedicalConfig.EngineConfig.FPSCap = maxFpsValue;
videoOptionsChanged = true;
}
if (videoOptionsChanged && VideoOptionsChanged != null)
{
VideoOptionsChanged.Invoke(this, EventArgs.Empty);
}
this.hide();
}
/// <summary> /// Inject a mouse up event externally to the hardware mouse. /// /// Since we need to treat touches as mouse events this input handler provides a way to inject /// mouse inputs that will follow the normal mouse path. This is only needed on touch only devices /// that need to simulate the mouse. /// </summary> /// <param name="code">The mouse button to simulate.</param> public abstract void injectButtonUp(MouseButtonCode code);
protected void fireButtonDown(MouseButtonCode button)
{
mouse.fireButtonDown(button);
}
public static bool IsMouseButtonPressed(MouseButtonCode mouseButton)
{
return(IsMouseButtonPressed_Native(mouseButton));
}
void OptionsDialog_Showing(object sender, EventArgs e)
{
//Program options
float cameraTransitionTime = MedicalConfig.CameraTransitionTime;
if (cameraTransitionTime >= 1.0f)
{
cameraSpeedCombo.SelectedIndex = 3;
}
else if (cameraTransitionTime >= 0.5f)
{
cameraSpeedCombo.SelectedIndex = 2;
}
else if (cameraTransitionTime >= 0.25f)
{
cameraSpeedCombo.SelectedIndex = 1;
}
else
{
cameraSpeedCombo.SelectedIndex = 0;
}
enableMultitouchCheck.Checked = MedicalConfig.EnableMultitouch;
enableDeveloper.Checked = MedicalConfig.ShowDeveloperTools;
MouseButtonCode cameraButtonCode = MedicalConfig.CameraMouseButton;
cameraButtonCombo.SelectedIndex = (uint)cameraButtonCode;
//Default Scene
uint count = defaultSceneCombo.ItemCount;
String defaultScene = MedicalConfig.DefaultScene;
if (defaultSceneCombo.ItemCount > 0)
{
bool defaultSceneNotFound = true;
for (uint i = 0; i < defaultSceneCombo.ItemCount; ++i)
{
if (defaultSceneCombo.getItemDataAt(i).ToString() == defaultScene)
{
defaultSceneCombo.SelectedIndex = i;
defaultSceneNotFound = false;
break;
}
}
if (defaultSceneNotFound)
{
defaultSceneCombo.SelectedIndex = 0;
}
}
else
{
defaultSceneCombo.Enabled = false;
}
uint scalingIndex = uiSize.findItemIndexWithData(MedicalConfig.ExtraScaling);
if (scalingIndex != ComboBox.Invalid)
{
uiSize.SelectedIndex = scalingIndex;
}
else
{
uiSize.SelectedIndex = uiSize.findItemIndexWithData(UIExtraScale.Normal);
}
//Graphics Options
fullscreenCheck.Checked = MedicalConfig.EngineConfig.Fullscreen;
vsyncCheck.Checked = OgreConfig.VSync;
showStatsCheck.Checked = MedicalConfig.EngineConfig.ShowStatistics;
String resString = String.Format("{0} x {1}", MedicalConfig.EngineConfig.HorizontalRes, MedicalConfig.EngineConfig.VerticalRes);
uint resIndex = resolutionCombo.findItemIndexWith(resString);
if (resIndex == uint.MaxValue)
{
resolutionCombo.addItem(resString);
resolutionCombo.SelectedIndex = resolutionCombo.ItemCount - 1;
}
else
{
resolutionCombo.SelectedIndex = resIndex;
}
uint aaIndex = aaCombo.findItemIndexWith(OgreConfig.FSAA);
if (aaIndex == uint.MaxValue)
{
if (aaCombo.ItemCount == 0)
{
aaCombo.addItem(OgreConfig.FSAA);
aaCombo.SelectedIndex = aaCombo.ItemCount - 1;
}
else
{
aaCombo.SelectedIndex = 0;
}
}
else
{
aaCombo.SelectedIndex = aaIndex;
}
maxFPS.IntValue = MedicalConfig.EngineConfig.FPSCap;
}
/// <summary>
/// Determins if the button was pressed on this frame, will be true the first frame the
/// button is down and false every frame after that until it is released. This is intended
/// to catch down / up events that happen before an update can be called.
/// </summary>
/// <param name="button"></param>
/// <returns></returns>
public bool buttonDownAndUpThisFrame(MouseButtonCode button)
{
return(downAndUpThisFrame[(int)button]);
}
private static extern bool IsMouseButtonPressed_Native(MouseButtonCode mouseButton);
