public static void Update()
{
KeyboardState state = Keyboard.GetState();
previous = current;
current = new KeyboardStatus(state);
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
KeyboardStatus.Subscribe(this);
KeyboardStatus.KeyboardStatusChangeEvent += OnKeyboardStatusChanged;
Window.DecorView.ViewTreeObserver.AddOnGlobalLayoutListener(this); // Why??
ViewModel?.ViewCreated();
}
protected override void OnDestroy()
{
base.OnDestroy();
KeyboardStatus.KeyboardStatusChangeEvent -= OnKeyboardStatusChanged;
KeyboardStatus.Unsubscribe(this);
UnBindEventHandlers();
ViewModel?.ViewDestroyed();
Window.DecorView.ViewTreeObserver.RemoveOnGlobalLayoutListener(this);
}
public void Update( )
{
IEnumerable <ItemEditor> allSelectedEditors = selectedEditors( ).ToList( );
Vector2 newDistance = MouseStatus.WorldPosition - allSelectedEditors.First().ItemProperties.Position;
float factor = newDistance.Length( ) / _canvas.GrabPoint.Length( );
int i = 0;
allSelectedEditors.Where(si => si.CanScale).ForEach(
thingToScale =>
{
//todo: reimplement texture
//if (selitem is TextureItem)
//{
// _mainForm.SetToolStripStatusLabel1("Hold down [X] or [Y] to limit scaling to the according dimension.");
//}
Vector2 newscale = _canvas.ScalesBeforeUserInteraction[i];
if (!KeyboardStatus.IsKeyDown(Keys.Y))
{
newscale.X = _canvas.ScalesBeforeUserInteraction[i].X * (((factor - 1.0f) * 0.5f) + 1.0f);
}
if (!KeyboardStatus.IsKeyDown(Keys.X))
{
newscale.Y = _canvas.ScalesBeforeUserInteraction[i].Y * (((factor - 1.0f) * 0.5f) + 1.0f);
}
thingToScale.Scale = newscale;
if (KeyboardStatus.IsKeyDown(Keys.LeftControl))
{
Vector2 scale;
scale.X = (float)Math.Round(thingToScale.Scale.X * 10) / 10;
scale.Y = (float)Math.Round(thingToScale.Scale.Y * 10) / 10;
thingToScale.Scale = scale;
}
i++;
});
IoC.Model.NotifyChanged(allSelectedEditors);
if (MouseStatus.IsNewRightMouseButtonRelease( ) || KeyboardStatus.IsNewKeyRelease(Keys.D3))
{
_canvas.SetModeToIdle( );
ObjectFactory.GetInstance <IMemento>().EndCommand( );
}
return;
}
void handleInputWhenAddingAnEntity( )
{
//mef: this might need to go back to the main Update method
if (Constants.Instance.SnapToGrid || KeyboardStatus.IsKeyDown(Keys.G))
{
MouseStatus.WorldPosition = SnapToGrid(MouseStatus.WorldPosition);
}
if (MouseStatus.IsNewRightMouseButtonClick( ) || KeyboardStatus.IsNewKeyPress(Keys.D3))
{
//mef: delegate to current primitive plugin
if (_entityCreation.StartedCreating)
{
_entityCreation.StartedCreating = false;
_entityCreation.ClearCurrentEditor( );
//mef: implement
//switch (_currentPrimitiveName)
//{
// case PrimitiveType.Rectangle:
// //_mainForm.SetToolStripStatusLabel1(Resources.Rectangle_Entered);
// break;
// case PrimitiveType.Circle:
// //_mainForm.SetToolStripStatusLabel1(Resources.Circle_Entered);
// break;
// case PrimitiveType.Path:
// //_mainForm.SetToolStripStatusLabel1(Resources.Path_Entered);
// break;
//}
}
else
{
destroyPrimitiveBrush( );
_entityCreation.StartedCreating = false;
}
}
if (_entityCreation.StartedCreating)
{
_entityCreation.CurrentEditor.UserInteractionDuringCreation( );
return;
}
if (MouseStatus.IsNewLeftMouseButtonClick( ) || KeyboardStatus.IsNewKeyPress(Keys.D3))
{
if (_entityCreation.StartedCreating == false)
{
_entityCreation.StartedCreating = true;
_entityCreation.CurrentEditor = buildPrimitiveEditorReadyForDesigning(_entityCreation.CreationProperties);
}
}
}
void handleInput(GameTime gameTime)
{
KeyboardStatus.Update(Keyboard.GetState( ));
MouseStatus.Update(Mouse.GetState( ), Camera);
handleCameraControls(gameTime);
if (_inputActionLookup.ContainsKey(_userActionInEditor))
{
_inputActionLookup[_userActionInEditor]( );
}
}
public void Update( )
{
int i = 0;
IEnumerable <ItemEditor> allSelectedEditors = selectedEditors( ).ToList( );
foreach (ItemEditor eachSelectedEditor in allSelectedEditors)
{
_newPosition = _canvas.PositionsBeforeUserInteraction[i] + MouseStatus.WorldPosition - _canvas.GrabPoint;
if (Constants.Instance.SnapToGrid || KeyboardStatus.IsKeyDown(Keys.G))
{
_newPosition = _canvas.SnapToGrid(_newPosition);
}
//_editor.SnapPoint.Visible = false ;
eachSelectedEditor.SetPosition(_newPosition);
i++;
}
IoC.Model.NotifyChanged(allSelectedEditors);
if (MouseStatus.IsNewLeftMouseButtonReleased( ) || KeyboardStatus.IsNewKeyRelease(Keys.D1))
{
foreach (ItemEditor eachSelectedEditor in allSelectedEditors)
{
eachSelectedEditor.OnMouseButtonUp(MouseStatus.WorldPosition);
}
bool isMoving = _canvas.CurrentUserAction == UserActionInEditor.MovingItems;
_canvas.SetModeToIdle( );
var samePoint = MouseStatus.WorldPosition == _canvas.GrabPoint;
var memento = ObjectFactory.GetInstance <IMemento>();
if (samePoint && isMoving)
{
memento.AbortCommand( );
}
else
{
memento.EndCommand( );
}
}
}
public override void UserInteractionDuringCreation( )
{
_properties.Width = MouseStatus.WorldPosition.X - _properties.Position.X;
_properties.Height = MouseStatus.WorldPosition.Y - _properties.Position.Y;
if (KeyboardStatus.IsKeyDown(Keys.LeftControl))
{
_properties.Width = _properties.Height;
}
if (MouseStatus.IsNewLeftMouseButtonClick( ))
{
PreviewEndedReadyForCreation(this, EventArgs.Empty);
}
WhenUpdatedByUi( );
}
public void SetMousePosition(int screenx, int screeny)
{
Vector2 maincameraposition = Camera.Position;
if (getLevel( ).ActiveLayer != null)
{
Camera.Position *= getLevel( ).ActiveLayer.ScrollSpeed;
}
MouseStatus.WorldPosition = Vector2.Transform(new Vector2(screenx, screeny), Matrix.Invert(Camera.Matrix));
if (Constants.Instance.SnapToGrid || KeyboardStatus.IsKeyDown(Keys.G))
{
MouseStatus.WorldPosition = SnapToGrid(MouseStatus.WorldPosition);
}
Camera.Position = maincameraposition;
}
public override void HandleKeyPressWhenFocused( )
{
if (KeyboardStatus.IsNewKeyPress(Keys.H))
{
IMemento memento = IoC.Memento;
memento.Record("Flip Item(s) Horizontally", () =>
{
FlipHorizontally = !FlipHorizontally;
IoC.Model.NotifyChanged(this);
});
}
if (KeyboardStatus.IsNewKeyPress(Keys.V))
{
IMemento memento = IoC.Memento;
memento.Record("Flip Item(s) Vertically", () =>
{
FlipVertically = !FlipVertically;
IoC.Model.NotifyChanged(this);
});
}
}
public override void UserInteractionDuringCreation( )
{
int lastItemIndex = _properties.WorldPoints.Count - 1;
Vector2 mouseWorldPos = MouseStatus.WorldPosition;
//_properties.WorldPoints[ lastItemIndex ] = mouseWorldPos ;
//_properties.LocalPoints[ lastItemIndex ] = _properties.WorldPoints[0] - mouseWorldPos ;
//}
if (MouseStatus.IsNewLeftMouseButtonClick( ))
{
addWorldPoint(mouseWorldPos);
WhenUpdatedByUi( );
}
if (MouseStatus.IsNewMiddleMouseButtonClick( ))
{
_editorMode = ItemEditorMode.Created;
PreviewEndedReadyForCreation(this, EventArgs.Empty);
}
if (KeyboardStatus.IsNewKeyPress(Keys.Back))
{
if (_properties.WorldPoints.Count > 1)
{
int lastItem = lastItemIndex;
_properties.WorldPoints.RemoveAt(lastItem);
_properties.LocalPoints.RemoveAt(lastItem);
WhenUpdatedByUi( );
}
}
}
public void Update( )
{
IEnumerable <ItemEditor> allSelectedEditors = selectedEditors( ).ToList( );
Vector2 newpos = MouseStatus.WorldPosition - allSelectedEditors.First().ItemProperties.Position;
float deltaTheta = (float)Math.Atan2(_canvas.GrabPoint.Y, _canvas.GrabPoint.X) - (float)Math.Atan2(newpos.Y, newpos.X);
int i = 0;
foreach (ItemEditor eachSelectedItem in allSelectedEditors)
{
if (eachSelectedItem.CanRotate( ))
{
eachSelectedItem.Rotation = _canvas.RotationsBeforeUserInteraction[i] - deltaTheta;
if (KeyboardStatus.IsKeyDown(Keys.LeftControl))
{
eachSelectedItem.Rotation = (float)Math.Round(eachSelectedItem.Rotation / MathHelper.PiOver4)
* MathHelper.PiOver4;
}
i++;
}
IoC.Model.NotifyChanged(allSelectedEditors);
}
if (MouseStatus.IsNewMiddleMouseButtonRelease( ) || KeyboardStatus.IsNewKeyRelease(Keys.D2))
{
_canvas.SetModeToIdle( );
ObjectFactory.GetInstance <IMemento>().EndCommand( );
}
return;
}
public BridgeEnums.EGetKeyboardStatusErrorCode GetKeyboardStatus(ref KeyboardStatus ks)
{
unsafe
{
fixed(byte *responseBufferPtr = &responseBuffer[0])
{
UGetKeyboardStatus(responseBufferPtr, responseBufferSize);
}
responseAsString = System.Text.Encoding.ASCII.GetString(responseBuffer, 0, responseBuffer.Length);
}
// Parse json message we received:
keyboardStatusServerResponse = JsonUtility.FromJson <KeyboardStatusServerJSONResponse>(responseAsString);
if ((BridgeEnums.EGetKeyboardStatusErrorCode)keyboardStatusServerResponse.error_code == BridgeEnums.EGetKeyboardStatusErrorCode.SUCCESS)
{
ks.isVisible = keyboardStatusServerResponse.status.visible;
ks.pairedTrackerID = keyboardStatusServerResponse.status.paired_tracker_id;
}
return((BridgeEnums.EGetKeyboardStatusErrorCode)keyboardStatusServerResponse.error_code);
}
public Input(MouseStatus mouseStatus, KeyboardStatus keyboardStatus)
{
MouseStatus = mouseStatus;
KeyboardStatus = keyboardStatus;
}
public KeyboardStatusChangeEventArgs(KeyboardStatus status, int visibleHeightToDecorHeightDelta)
{
Status = status;
VisibleHeightToDecorHeightDelta = visibleHeightToDecorHeightDelta;
}
public void Update( )
{
//get item under mouse cursor
var model = ObjectFactory.GetInstance <IModel>( );
ItemEditor item = _canvas.ItemUnderMouse;
bool controlButtonPressed = KeyboardStatus.IsKeyDown(Keys.LeftControl);
if (item != null)
{
_mainForm.SetToolStripStatusLabel1(item.ItemProperties.Name);
item.OnMouseOver(MouseStatus.WorldPosition);
if (controlButtonPressed)
{
_mainForm.SetCursorForCanvas(_cursorDuplicate);
}
}
else
{
_mainForm.SetToolStripStatusLabel1(string.Empty);
}
if (item != _lastItem && _lastItem != null)
{
_lastItem.OnMouseOut( );
}
_lastItem = item;
IEnumerable <ITreeItem> editors = selectedEditors( ).ToList( );
if (MouseStatus.IsNewLeftMouseButtonClick() || KeyboardStatus.IsNewKeyPress(Keys.D1))
{
if (item != null)
{
item.OnMouseButtonDown(MouseStatus.WorldPosition);
}
if (controlButtonPressed && item != null)
{
_canvas.StartCopyingSelectedItems( );
}
else if (KeyboardStatus.IsKeyDown(Keys.LeftShift) && item != null)
{
model.ToggleSelectionOnItem(item);
}
else if (editors.Contains(item))
{
_canvas.StartMovingSelectedItems( );
}
else if (!selectedEditors().Contains(item))
{
if (item != null)
{
_model.SelectEditor(item);
_canvas.StartMovingSelectedItems( );
}
else
{
_canvas.CreateSelectionRectangle( );
}
}
}
//MIDDLE MOUSE BUTTON CLICK
bool anyEditorsSelected = editors.Any();
if (MouseStatus.IsNewMiddleMouseButtonClick( ) || KeyboardStatus.IsNewKeyPress(Keys.D2))
{
if (item != null)
{
item.OnMouseOut( );
}
if (controlButtonPressed)
{
_canvas.StartMovingCamera( );
}
else
{
if (anyEditorsSelected)
{
_canvas.StartRotatingItems( );
}
}
}
//RIGHT MOUSE BUTTON CLICK
if (MouseStatus.IsNewRightMouseButtonClick( ) || KeyboardStatus.IsNewKeyPress(Keys.D3))
{
if (item != null)
{
item.OnMouseOut( );
}
if (anyEditorsSelected)
{
_canvas.StartScalingSelectedItems( );
}
}
selectedEditors( ).ForEach(e => e.HandleKeyPressWhenFocused());
}
public SearchBoxKeyBoardEventArgs(bool isSelection, KeyboardStatus status)
{
IsClosingAfterSelection = isSelection;
Status = status;
}
void handleCameraControls(GameTime gameTime)
{
int scrollWheelDelta = MouseStatus.ScrollwheelDelta;
if (scrollWheelDelta > 0 /* && kstate.IsKeyDown(Keys.LeftControl)*/)
{
float zoom = (float)Math.Round(Camera.Scale * 10) * 10.0f + 10.0f;
_mainForm.SetZoomComboText(zoom.ToString( ) + "%");
Camera.Scale = zoom / 100.0f;
}
if (scrollWheelDelta < 0 /* && kstate.IsKeyDown(Keys.LeftControl)*/)
{
float zoom = (float)Math.Round(Camera.Scale * 10) * 10.0f - 10.0f;
if (zoom <= 0.0f)
{
return;
}
_mainForm.SetZoomComboText(zoom.ToString( ) + "%");
Camera.Scale = zoom / 100.0f;
}
//Camera movement
float delta;
if (KeyboardStatus.IsKeyDown(Keys.LeftShift))
{
delta = Constants.Instance.CameraFastSpeed * (float)gameTime.ElapsedGameTime.TotalSeconds;
}
else
{
delta = Constants.Instance.CameraSpeed * (float)gameTime.ElapsedGameTime.TotalSeconds;
}
bool leftControlKeyNotPressed = KeyboardStatus.IsKeyUp(Keys.LeftControl);
if (KeyboardStatus.IsKeyDown(Keys.W) && leftControlKeyNotPressed)
{
Camera.Position += (new Vector2(0, -delta));
}
if (KeyboardStatus.IsKeyDown(Keys.S) && leftControlKeyNotPressed)
{
Camera.Position += (new Vector2(0, +delta));
}
if (KeyboardStatus.IsKeyDown(Keys.A) && leftControlKeyNotPressed)
{
Camera.Position += (new Vector2(-delta, 0));
}
if (KeyboardStatus.IsKeyDown(Keys.D) && leftControlKeyNotPressed)
{
Camera.Position += (new Vector2(+delta, 0));
}
if (KeyboardStatus.IsKeyDown(Keys.Subtract))
{
var zoom = (float)(Camera.Scale * 0.995);
_mainForm.SetZoomComboText(textualRepresentationOfZoom(zoom));
Camera.Scale = zoom;
}
if (KeyboardStatus.IsKeyDown(Keys.Add))
{
var zoom = (float)(Camera.Scale * 1.005);
_mainForm.SetZoomComboText(textualRepresentationOfZoom(zoom));
Camera.Scale = zoom;
}
//get mouse world position considering the ScrollSpeed of the current layer
Vector2 maincameraposition = Camera.Position;
if (getLevel( ).ActiveLayer != null)
{
Camera.Position *= getLevel( ).ActiveLayer.ScrollSpeed;
}
MouseStatus.UpdateCamera(Camera);
MouseStatus.WorldPosition = Vector2.Transform(MouseStatus.ScreenPosition, Matrix.Invert(Camera.Matrix));
MouseStatus.WorldPosition = MouseStatus.WorldPosition.Round( );
_mainForm.SetToolStripStatusLabel3(
"Mouse: ({0}, {1})".FormatWith(MouseStatus.WorldPosition.X, MouseStatus.WorldPosition.Y));
Camera.Position = maincameraposition;
}
public KeyboardStatusChangeEventArgs(KeyboardStatus status)
{
Status = status;
}
// Listen to keys events
void Update()
{
if (Input.anyKeyDown)
{
switch (Input.inputString)
{
// ---------------------------------------------------------------------
// Keyboard functions examples
// ---------------------------------------------------------------------
case "a":
// Set keyboard to visible
errorCode = (int)BridgeSDK.Instance.bridgeSDK.SetKeyboardVisibility(true);
Debug.Log(errorCode == 0 ? "Keyboard is now visible" : "Error with code: " + errorCode);
break;
case "s":
// Set keyboard to hidden
errorCode = (int)BridgeSDK.Instance.bridgeSDK.SetKeyboardVisibility(false);
Debug.Log(errorCode == 0 ? "Keyboard is now hidden" : "Error with code: " + errorCode);
break;
case "d":
// Get keyboard status
KeyboardStatus ks = new KeyboardStatus();
errorCode = (int)BridgeSDK.Instance.bridgeSDK.GetKeyboardStatus(ref ks);
Debug.Log(errorCode == 0 ? ("Keyboard visible: " + ks.isVisible + ", id: '" + ks.pairedTrackerID + "'") : ("Error with code: " + errorCode));
break;
case "f":
// Get supported keyboards and their respective skins
SupportedKeyboards sk = new SupportedKeyboards();
errorCode = (int)BridgeSDK.Instance.bridgeSDK.GetSupportedKeyboards(ref sk);
Debug.Log(errorCode == 0 ? (sk.Print()) : "Error with code: " + errorCode);
break;
case "g":
// Set the "CrashTest" skin
errorCode = (int)BridgeSDK.Instance.bridgeSDK.SetSkin("CrashTest");;
Debug.Log(errorCode == 0 ? "Skin CrashTest applied" : "Error with code: " + errorCode);
break;
// ---------------------------------------------------------------------
// Hands functions examples
// ---------------------------------------------------------------------
case "z":
// Set hands to visible
errorCode = (int)BridgeSDK.Instance.bridgeSDK.SetHandsVisibility(true);
Debug.Log(errorCode == 0 ? "Hands are now visible" : "Error with code: " + errorCode);
break;
case "x":
// Set hands to hidden
errorCode = (int)BridgeSDK.Instance.bridgeSDK.SetHandsVisibility(false);
Debug.Log(errorCode == 0 ? "Hands are now hidden" : "Error with code: " + errorCode);
break;
case "c":
// Get hands status
HandsFeedbackStatus hs = new HandsFeedbackStatus();
errorCode = (int)BridgeSDK.Instance.bridgeSDK.GetHandsStatus(ref hs);
Debug.Log(errorCode == 0 ? ("Hands feedback status: " + hs.isVisible + ", " + hs.eHandsRepresentationMode + ", (" + hs.color[0] + ", " + hs.color[1] + ", " + hs.color[2] + "), " + hs.opacityLevel + "," + hs.segmentationThreshold) : "Error with code: " + errorCode);
break;
case "v":
// Set hands representation to "Hands Segmentation"
errorCode = (int)BridgeSDK.Instance.bridgeSDK.SetHandsRepresentationMode(BridgeEnums.EHandsRepresentationMode.HANDS_SEGMENTATION);
Debug.Log(errorCode == 0 ? "Hands representation set to 'Hands Segmentation'" : "Error with code: " + errorCode);
break;
case "b":
// Set hands representation to "Seethrough"
errorCode = (int)BridgeSDK.Instance.bridgeSDK.SetHandsRepresentationMode(BridgeEnums.EHandsRepresentationMode.SEETHRU);
Debug.Log(errorCode == 0 ? "Hands representation set to 'Seethrough'" : "Error with code: " + errorCode);
break;
case "n":
// Set random hand color in 'Hands segmentation' mode
errorCode = (int)BridgeSDK.Instance.bridgeSDK.SetHandsColor(BridgeEnums.EHandsRepresentationMode.HANDS_SEGMENTATION, Random.Range(0, 255), Random.Range(0, 255), Random.Range(0, 255));
Debug.Log(errorCode == 0 ? "Hands set to random color in 'Hands Segmentation' mode" : "Error with code: " + errorCode);
break;
case "m":
// Set Hands Segmentation threshold to 10%
errorCode = (int)BridgeSDK.Instance.bridgeSDK.SetHandsSegmentationThreshold(BridgeEnums.EHandsRepresentationMode.HANDS_SEGMENTATION, 0.1f);
Debug.Log(errorCode == 0 ? "Hands Segmentation threshold set to 10%" : "Error with code: " + errorCode);
break;
case "j":
// Set Hands Segmentation threshold to 30%
errorCode = (int)BridgeSDK.Instance.bridgeSDK.SetHandsSegmentationThreshold(BridgeEnums.EHandsRepresentationMode.HANDS_SEGMENTATION, 0.3f);
Debug.Log(errorCode == 0 ? "Hands Segmentation threshold set to 30%" : "Error with code: " + errorCode);
break;
case "k":
// Set Hands opacity to 70%
errorCode = (int)BridgeSDK.Instance.bridgeSDK.SetHandsOpacity(BridgeEnums.EHandsRepresentationMode.HANDS_SEGMENTATION, 1.0f);
Debug.Log(errorCode == 0 ? "Hands Segmentation opacity set to 100%" : "Error with code: " + errorCode);
break;
case "l":
// Set Hands opacity to 70%
errorCode = (int)BridgeSDK.Instance.bridgeSDK.SetHandsOpacity(BridgeEnums.EHandsRepresentationMode.HANDS_SEGMENTATION, 0.7f);
Debug.Log(errorCode == 0 ? "Hands Segmentation opacity set to 70%" : "Error with code: " + errorCode);
break;
}
}
}
