public static void DockForm(Form form, Screen screen, ScreenPosition position) { switch (position) { case ScreenPosition.BottomRight: CommentSetting.PositionTop = screen.WorkingArea.Height - form.Size.Height; CommentSetting.PositionLeft = screen.WorkingArea.Width - form.Size.Width; break; case ScreenPosition.BottomLeft: CommentSetting.PositionTop = screen.WorkingArea.Height - form.Size.Height; CommentSetting.PositionLeft = 0; break; case ScreenPosition.TopRight: CommentSetting.PositionTop = 0; CommentSetting.PositionLeft = screen.WorkingArea.Width - form.Size.Width; break; case ScreenPosition.TopLeft: CommentSetting.PositionTop = 0; CommentSetting.PositionLeft = 0; break; default: CommentSetting.PositionTop = 0; CommentSetting.PositionLeft = 0; break; } UpdateScreenPosition(form, screen); }
public string GetDebugInformation() { String returnString = "Name : " + name + " (Key: " + Key + ")" + "\n" + "" + "\nTile Size : " + tileSize.ToString() + "\nState : " + State.ToString() + "\nIs Valid : " + IsValid.ToString() + "\nBaseScrPosition : " + BaseScreenPosition.ToString() + "\nScreenPosition : " + ScreenPosition.ToString() + "\nOrigin : " + BaseOrigin.ToString() + "\nShape Origin : " + ShapeOrigin.ToString() + "\nCursor Offset : " + CursorReturnOffset.ToString() + "\nRotation : " + rotation + " radians" + "\nRotation idx : " + currentRotationIdx + "\nCurrent Dimensions : " + CurrentMatrixDimensions.ToString() + "\n[Flipping : " + IsFlipping + "] [Rotating : " + IsRotating + "]" + "\n[FlippedX : " + isFlippedHorizontal + "] [FlippedY : " + isFlippedVertical + "]"; returnString += "\n\nCurrent Matrix: "; returnString += "\n-----\n"; for (int y = 0; y < CurrentMatrixDimensions.Y; y++) { for (int x = 0; x < CurrentMatrixDimensions.X; x++) { returnString += CurrentMatrix[y][x] + " "; } returnString += "\n"; } return(returnString); }
public async Task ShowVideo( string mediaItemFilePath, ScreenPosition screenPosition, Guid mediaItemId, TimeSpan startOffset, bool startFromPaused) { _mediaItemId = mediaItemId; _startPosition = startOffset; _lastPosition = TimeSpan.Zero; ScreenPositionHelper.SetScreenPosition(_mediaElement.FrameworkElement, screenPosition); if (startFromPaused) { _mediaElement.Position = _startPosition; await _mediaElement.Play(); OnMediaChangeEvent(new MediaEventArgs { MediaItemId = _mediaItemId, Change = MediaChange.Started }); } else { OnMediaChangeEvent(new MediaEventArgs { MediaItemId = _mediaItemId, Change = MediaChange.Starting }); _mediaElement.Source = new Uri(mediaItemFilePath); } }
private void SetPositionByValue(int value) { Position = (ScreenPosition)ScreenPosition.ToObject(typeof(ScreenPosition), value); //~ Debug.Log(string.Format("value: {0} , Enum : {1}", value, Position)); UpdatePosition(); }
protected override async Task OnAfterRenderAsync(bool firstRender) { if (firstRender && firstSelect.Id != null && dateTimeFilter.Id != null) { await jSRuntime.InvokeVoidAsync("gridJsFunctions.focusElement", firstSelect); ScreenPosition sp = await jSRuntime.InvokeAsync <ScreenPosition>("gridJsFunctions.getPosition", dateTimeFilter); ScreenPosition gridComponentSP = await jSRuntime.InvokeAsync <ScreenPosition>("gridJsFunctions.getPosition", GridHeaderComponent.GridComponent.Gridmvc); if (GridHeaderComponent.GridComponent.Grid.Direction == GridShared.GridDirection.RTL) { if (sp != null && gridComponentSP != null && sp.X < Math.Max(25, gridComponentSP.X)) { _offset = -sp.X + Math.Max(25, gridComponentSP.X); StateHasChanged(); } } else { if (sp != null && gridComponentSP != null && sp.X + sp.Width > Math.Min(sp.InnerWidth, gridComponentSP.X + gridComponentSP.Width + 25)) { _offset = sp.X + sp.Width - Math.Min(sp.InnerWidth, gridComponentSP.X + gridComponentSP.Width + 25) + 25; StateHasChanged(); } } } }
protected override async Task OnAfterRenderAsync(bool firstRender) { if (firstRender && boolFilter.Id != null) { await jSRuntime.InvokeVoidAsync("gridJsFunctions.focusElement", boolFilter); ScreenPosition sp = await jSRuntime.InvokeAsync <ScreenPosition>("gridJsFunctions.getPosition", boolFilter); if (GridHeaderComponent.GridComponent.Grid.Direction == GridShared.GridDirection.RTL) { if (sp != null && sp.X < 0) { _offset = -sp.X + 25; StateHasChanged(); } } else { if (sp != null && sp.X + sp.Width > sp.InnerWidth) { _offset = sp.X + sp.Width - sp.InnerWidth + 25; StateHasChanged(); } } } }
private static void ScreenPosition_PropertyChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e) { Overview overview = sender as Overview; ScreenPosition position = (ScreenPosition)e.NewValue; if (overview != null) { switch (position) { case ScreenPosition.TopLeft: overview.VerticalContentAlignment = VerticalAlignment.Top; overview.HorizontalContentAlignment = HorizontalAlignment.Left; break; case ScreenPosition.TopRight: overview.VerticalContentAlignment = VerticalAlignment.Top; overview.HorizontalContentAlignment = HorizontalAlignment.Right; break; case ScreenPosition.BottomLeft: overview.VerticalContentAlignment = VerticalAlignment.Bottom; overview.HorizontalContentAlignment = HorizontalAlignment.Left; break; case ScreenPosition.BottomRight: overview.VerticalContentAlignment = VerticalAlignment.Bottom; overview.HorizontalContentAlignment = HorizontalAlignment.Right; break; default: break; } } }
protected override async Task OnAfterRenderAsync(bool firstRender) { if (firstRender && listFilter.Id != null) { await jSRuntime.InvokeVoidAsync("gridJsFunctions.focusElement", listFilter); ScreenPosition sp = await jSRuntime.InvokeAsync <ScreenPosition>("gridJsFunctions.getPosition", listFilter); ScreenPosition gridTableSP = await jSRuntime.InvokeAsync <ScreenPosition>("gridJsFunctions.getPosition", GridHeaderComponent.GridComponent.GridTable); if (sp != null && gridTableSP != null) { if (gridTableSP.X + gridTableSP.Width < sp.X + sp.Width) { _offset = gridTableSP.X + gridTableSP.Width - sp.X - sp.Width; StateHasChanged(); } else if (sp.X < gridTableSP.X) { _offset = gridTableSP.X - sp.X; StateHasChanged(); } } } }
protected override async Task OnAfterRenderAsync(bool firstRender) { if (tooltip.Id != null) { await jSRuntime.InvokeVoidAsync("gridJsFunctions.focusElement", tooltip); ScreenPosition sp = await jSRuntime.InvokeAsync <ScreenPosition>("gridJsFunctions.getPosition", tooltip); if (GridComponent.Grid.Direction == GridShared.GridDirection.RTL) { if (sp != null && GridComponent.ScreenPosition != null && sp.X < Math.Max(35, GridComponent.ScreenPosition.X)) { _offset = -sp.X - Math.Max(35, GridComponent.ScreenPosition.X); StateHasChanged(); } } else { if (sp != null && GridComponent.ScreenPosition != null && sp.X + sp.Width > Math.Min(sp.InnerWidth, GridComponent.ScreenPosition.X + GridComponent.ScreenPosition.Width + 35)) { _offset = sp.X + sp.Width - Math.Min(sp.InnerWidth, GridComponent.ScreenPosition.X + GridComponent.ScreenPosition.Width + 35) - 35; StateHasChanged(); } } } }
public override void Draw(BMapControl c, Graphics g) { if (IsVisible) { this.map = c; ScreenPosition = map.LatLngToPoint(Position); Point p = ScreenPosition.GetOffSet(OffSet.X, OffSet.Y); var rect = ScreenArea = new Rectangle(p, Size); if (IsMouseOver) { g.FillEllipse(new SolidBrush(Color.FromArgb(0xaa, 0xff, 0xff, 0xff)), rect); //if (ToolTip!=null) //{ // ToolTip.IsOpen=IsMouseOver; //} } p.Offset(3, 3); var rect1 = new Rectangle(p.X, p.Y, Size.Width - 6, Size.Height - 6); g.FillEllipse(new SolidBrush(Color.FromArgb(0xFF, 0x11, 0x11, 0xff)), rect1); ToolTip.Draw(c, g); } }
public Options() { // defaults AlwaysOnTop = true; WindowedAlwaysOnTop = true; LogEventLevel = LogEventLevel.Information; MediaFolder = FileUtils.GetOnlyMDefaultMediaFolder(); ImageFadeType = ImageFadeType.CrossFade; ImageFadeSpeed = FadeSpeed.Normal; CacheImages = true; ShowVideoSubtitles = false; AllowVideoScrubbing = true; AllowVideoPause = true; AllowVideoPositionSeeking = true; PermanentBackdrop = true; JwLibraryCompatibilityMode = true; ConfirmVideoStop = false; MaxItemCount = DefaultMaxItemCount; MagnifierZoomLevel = DefaultMagnifierZoomLevel; BrowserZoomLevelIncrement = DefaultBrowserZoomLevelIncrement; MagnifierShape = MagnifierShape.Circle; MagnifierSize = MagnifierSize.Medium; MagnifierFrameThickness = DefaultBrowserFrameThickness; VideoScreenPosition = new ScreenPosition(); ImageScreenPosition = new ScreenPosition(); WebScreenPosition = new ScreenPosition(); AllowMirror = true; MirrorZoom = DefaultMirrorZoom; Sanitize(); }
public static void SetSubtitleBlockScreenPosition(TextBlock element, ScreenPosition position) { var parent = GetParentWindow(element); if (parent != null) { if (position.IsFullScreen()) { element.Margin = new Thickness(0, 0, 0, parent.ActualHeight / 10); element.FontSize = parent.ActualHeight / 22; } else { double leftMargin = (parent.ActualWidth * position.LeftMarginPercentage) / 100.0; double topMargin = (parent.ActualHeight * position.TopMarginPercentage) / 100.0; double rightMargin = (parent.ActualWidth * position.RightMarginPercentage) / 100.0; double bottomMargin = (parent.ActualHeight * position.BottomMarginPercentage) / 100.0; var displayHeight = parent.ActualHeight - topMargin - bottomMargin; element.Margin = new Thickness(leftMargin, topMargin, rightMargin, bottomMargin + (displayHeight / 10)); element.FontSize = displayHeight / 22; } } }
private static void SetScreenMarginValue( ScreenPosition screenPosition, ScreenMarginSide marginSide, int newMarginValue) { switch (marginSide) { case ScreenMarginSide.Left: screenPosition.LeftMarginPercentage = newMarginValue; break; case ScreenMarginSide.Right: screenPosition.RightMarginPercentage = newMarginValue; break; case ScreenMarginSide.Top: screenPosition.TopMarginPercentage = newMarginValue; break; case ScreenMarginSide.Bottom: screenPosition.BottomMarginPercentage = newMarginValue; break; default: throw new ArgumentException(); } }
public static void make(string text, ScreenPosition position, float duration, float fontSize = 30.0f) { Debug.Log(UIControllerGame.getInstance().announcementSampleObject); UILabel gameObject = (UILabel)GameObject.Instantiate(UIControllerGame.getInstance().announcementSampleObject); gameObject.text = text; switch (position) { case ScreenPosition.MiddleBottom: gameObject.transform.parent = UIControllerGame.getInstance().panel_AnnouncementsMiddleBottom.transform; break; case ScreenPosition.MiddleCenter: gameObject.transform.parent = UIControllerGame.getInstance().panel_AnnouncementsMiddleCenter.transform; break; case ScreenPosition.MiddleTop: gameObject.transform.parent = UIControllerGame.getInstance().panel_AnnouncementsMiddleTop.transform; break; } gameObject.transform.localPosition = Vector3.zero; gameObject.transform.localScale = new Vector3(fontSize, fontSize, 1); GameObject.Destroy(gameObject.gameObject, duration); }
public static Vector2 screenPositionToScreenCoordonate(ScreenPosition position) { switch (position) { case ScreenPosition.upperLeft: return(new Vector2(2 / 3f, 1 / 3f)); case ScreenPosition.lowerLeft: return(new Vector2(2 / 3f, 2 / 3f)); case ScreenPosition.upperRight: return(new Vector2(1 / 3f, 1 / 3f)); case ScreenPosition.lowerRight: return(new Vector2(1 / 3f, 2 / 3f)); case ScreenPosition.centerLeft: return(new Vector2(2 / 3f, 0.5f)); case ScreenPosition.centerRight: return(new Vector2(1 / 3f, 0.5f)); case ScreenPosition.centerUp: return(new Vector2(0.5f, 1 / 3f)); case ScreenPosition.centerLow: return(new Vector2(0.5f, 2 / 3f)); } return(new Vector2(0.5f, 0.5f)); // absolute center }
public LogicEngine() { ImgUtils.Init(); KeyUtils.WindowToSendKeysIn = Constants.KO_WINDOW; _gos = new List <GameObject>(); _initTimer = new CTimer(); _initTimer.Interval = START_DELAY * 1000; _initTimer.AutoReset = false; _updateTimer = new CTimer(); _updateTimer.Elapsed += OnUpdate; _updateTimer.AutoReset = false; _updateTimer.Interval = UPDATE_DELAY * 1000; GameObject go = new GameObject(); CharacterStateMachine sm = new CharacterStateMachine(); Character character = new Character(sm); DirComponent direction = new DirComponent(); ScreenPosition screenPos = new ScreenPosition(); go.AddComponent(screenPos); go.AddComponent(sm); go.AddComponent(direction); go.AddComponent(character); _gos.Add(go); _sendStart = true; }
private void Move(EDirection direction, Action onCompleted = null) { this.onMoveCompleted = onCompleted; this.direction = direction; KeyUtils.SendCharUp('w'); startPos = Character.Position; double angle = GetAngleForDirection(); Point newPoint = ScreenPosition.RotateDirection(initialDirection, angle); ActionManager.SendDelayedAction(0.25f, () => { ClickAt(newPoint, () => { if (!IsActive) { return; } timerStuck.Start(); ScreenPosition.SetClickPoint(newPoint); KeyUtils.SendCharDown('w'); Character.PositionChanged -= OnMove; Character.PositionChanged += OnMove; }); }); }
public Vertex ToScreenCoords(Size size) { var ret = new Vertex(ScreenPosition.ToScreenCoords(size), Normal, Tangent, Binormal, WorldPosition, TextureCoords); ret.ClipW = ScreenPosition.W; return(ret); }
public void ExitToRight() { var from = rect.anchoredPosition; var to = positionRight; moving = new LerpHelper <Vector2>(from, to, Vector2.Lerp, speed, Vector2.Distance(from, to)); screenPosition = ScreenPosition.Left; }
public Vector2 GetPositionInCameraView(FlxCamera camera = null) { if (camera == null) { camera = FlxG.Camera; } return(camera.ViewportAdapter.PointToScreen(ScreenPosition.ToPoint()).ToVector2()); }
public void SetColor(ScreenPosition screenPosition, Color value) { Text textField = GetTextField(screenPosition); if (textField != null) { textField.color = value; } }
private Point GetScreenPoint() { Vector destinationDirection = destination - Character.Position; destinationDirection.Normalize(); Point screenPoint = ScreenPosition.GetPointForDirection(destinationDirection); return(screenPoint); }
public override void OnLeave() { base.OnLeave(); Character.PositionChanged -= OnPositionChanged; KeyUtils.SendCharUp('w'); ScreenPosition.StopCalculateDirection(); timerStuck.Elapsed -= OnStuck; timerStuck.Stop(); }
public Scoreboard(string board, string title, ScreenPosition pos) { this.Board = board; if (title.Length < 32) this.Title = title; else this.Title = title.Substring(0, 32); this.Position = pos; }
private void MoveBack() { Vector destinationDirection = startPos - Character.Position; destinationDirection.Normalize(); Point screenPoint = ScreenPosition.GetPointForDirection(destinationDirection); PerformClickMove(screenPoint); }
public void SetSize(ScreenPosition screenPosition, int value) { Text textField = GetTextField(screenPosition); if (textField != null) { textField.fontSize = value; } }
public void SetText(ScreenPosition screenPosition, string value) { Text textField = GetTextField(screenPosition); if (textField != null) { textField.text = value; } }
public void SetVisible(ScreenPosition screenPosition, bool isVisible, bool forceAlpha = false) { Text textField = GetTextField(screenPosition); if (textField != null) { textField.gameObject.SetActive(isVisible); } }
public void Hide() { GetComponent <RectTransform>().anchoredPosition = positionLeft; screenPosition = ScreenPosition.Left; if (moving != null) { moving = null; } }
public void StartConversation (string conversationFilePathInResources, ScreenPosition position = ScreenPosition.Right) { EventController.Event(PSEventType.StartConversation); Show(); SetConversation ( new Conversation(conversationFilePathInResources), position ); }
public void Show() { GetComponent <RectTransform>().anchoredPosition = Vector2.zero; screenPosition = ScreenPosition.Center; if (moving != null) { moving = null; } OnEnter(transitionedFrom); }
public static Size GetWindowSize(IntPtr h) { ScreenPosition lpRect = default; GetClientRect(h, ref lpRect); var result = default(Size); result.Width = lpRect.PosRight - lpRect.PosLeft; result.Height = lpRect.PosBottom - lpRect.PosTop; return(result); }
/// <summary> /// Sets the form's screen position in independent coordinates. /// </summary> /// <remarks> /// Position is set relative to the form's current screen. /// </remarks> public static void SetScreenPosition(this MainForm form, ScreenPosition position) { var screen = Screen.FromControl(form); var start = form.ResolveScreenPositionEdge(position); var end = screen.ResolveScreenPosition(position); var move = end.Difference(start); //System.Diagnostics.Trace.WriteLine(string.Format("From {0} to {1} => {2}.", start, end, move)); var original = form.Location; form.Location = new Point(original.X + move.X, original.Y + move.Y); }
public void TogglePortraits (ScreenPosition position) { switch(position) { case ScreenPosition.Left: CharacterPortraitLeft.enabled = true; CharacterPortraitRight.enabled = false; break; case ScreenPosition.Right: CharacterPortraitLeft.enabled = false; CharacterPortraitRight.enabled = true; break; } }
/// <summary> /// Sets the form's screen position in independent coordinates. /// </summary> /// <remarks> /// Position is set relative to the form's current screen. /// </remarks> public static void SetScreenPosition(this MainForm form, ScreenPosition position) { var screen = Screen.FromControl(form); Point start = form.ResolveScreenPositionEdge(position); Point end = screen.ResolveScreenPosition(position); Point move = new Point(start.X - end.X, start.Y - end.Y); #if DEBUG Console.WriteLine("From {0} to {1} => {2}.", start, end, move); #endif var original = form.Location; form.Location = new Point(original.X + move.X, original.Y + move.Y); }
private static Point ResolveScreenPositionToRectangle(Rectangle rect, ScreenPosition position) { switch (position) { case ScreenPosition.TopLeft: return new Point(rect.X, rect.Y); case ScreenPosition.TopRight: return new Point(rect.X + rect.Width, rect.Y); case ScreenPosition.BottomLeft: return new Point(rect.X, rect.Y + rect.Height); case ScreenPosition.BottomRight: return new Point(rect.X + rect.Width, rect.Y + rect.Height); case ScreenPosition.Center: return new Point(rect.X + (rect.Width / 2), rect.Y + (rect.Height / 2)); default: throw new ArgumentException("Invalid ScreenPosition value."); } }
public void Update(GameTime gameTime, ScreenPosition playerScreenPosition, MoveDirection playerMoveDirection) { if (mCurrentState == CharacterState.Walking) { var movement = new Movement { Direction = _currentDirection, Type = MovementType.Walking }; if (_currentDirection == MoveDirection.Left) { if (Position.X - _minX <= 20) { _currentFrameIndex = 0; _currentDirection = MoveDirection.Right; } } else if (_currentDirection == MoveDirection.Right) { if (_maxX - Position.X <= 20) { _currentFrameIndex = 1; _currentDirection = MoveDirection.Left; } } UpdateMovement(movement, playerScreenPosition, playerMoveDirection); _hpBar.UpdateFrameIndex(Position, Data.MaxHp, Data.CurrentHp); _hpBar.Update(gameTime, mSpeed, mDirection); base.Update(gameTime, mSpeed, mDirection); } if (IsDead) { if (_deadTime.HasValue) { if ((gameTime.TotalGameTime - _deadTime.Value).Milliseconds > 250) { DoRemove = true; } } else { _deadTime = gameTime.TotalGameTime; } } }
public void SetCharacter (string characterName, ScreenPosition position, Sprite characterPortrait = null) { Image portraitFrame = null; switch (position) { case ScreenPosition.Left: portraitFrame = CharacterPortraitLeft; break; case ScreenPosition.Right: portraitFrame = CharacterPortraitRight; break; } if (characterPortrait != null) { portraitFrame.sprite = characterPortrait; } TogglePortraits(position); SetName(characterName); }
/// <summary> /// Places a Transform at one of the 9 positions around the screen edge. /// </summary> /// <param name="target"> /// A <see cref="Transform"/> /// </param> /// <param name="position"> /// A <see cref="ScreenPosition"/> /// </param> /// <param name="pixelsFromEdge"> /// A <see cref="Vector2"/> /// </param> public static void ScreenPlacement(this Transform target, ScreenPosition position, Vector2 pixelsFromEdge){ DoScreenPlacement(target.transform, position, pixelsFromEdge, Camera.main); }
//Placement execution: private static void DoScreenPlacement(this Transform target, ScreenPosition position, Vector2 pixelsFromEdge, Camera renderingCamera){ Vector3 screenPosition = Vector3.zero; float zPosition = -renderingCamera.transform.position.z + target.position.z; switch (position) { //uppers: case ScreenPosition.UpperLeft: screenPosition = renderingCamera.ScreenToWorldPoint(new Vector3(pixelsFromEdge.x, Screen.height-pixelsFromEdge.y, zPosition)); break; case ScreenPosition.UpperMiddle: screenPosition = renderingCamera.ScreenToWorldPoint(new Vector3(Screen.width/2, Screen.height-pixelsFromEdge.y, zPosition)); break; case ScreenPosition.UpperRight: screenPosition = renderingCamera.ScreenToWorldPoint(new Vector3(Screen.width-pixelsFromEdge.x, Screen.height-pixelsFromEdge.y, zPosition)); break; //mids: case ScreenPosition.Left: screenPosition = renderingCamera.ScreenToWorldPoint(new Vector3(pixelsFromEdge.x, Screen.height/2, zPosition)); break; case ScreenPosition.Middle: screenPosition = renderingCamera.ScreenToWorldPoint(new Vector3((Screen.width/2) + pixelsFromEdge.x, (Screen.height/2) + pixelsFromEdge.y, zPosition)); break; case ScreenPosition.Right: screenPosition = renderingCamera.ScreenToWorldPoint(new Vector3(Screen.width-pixelsFromEdge.x, Screen.height/2, zPosition)); break; //lowers: case ScreenPosition.LowerLeft: screenPosition = renderingCamera.ScreenToWorldPoint(new Vector3(pixelsFromEdge.x, pixelsFromEdge.y, zPosition)); break; case ScreenPosition.LowerMiddle: screenPosition = renderingCamera.ScreenToWorldPoint(new Vector3(Screen.width/2, pixelsFromEdge.y, zPosition)); break; case ScreenPosition.LowerRight: screenPosition = renderingCamera.ScreenToWorldPoint(new Vector3(Screen.width-pixelsFromEdge.x, pixelsFromEdge.y, zPosition)); break; } target.transform.position = screenPosition; }
/// <summary> /// Places a GameObject at one of the 9 positions around the screen edge. /// </summary> /// <param name="target"> /// A <see cref="GameObject"/> /// </param> /// <param name="position"> /// A <see cref="ScreenPosition"/> /// </param> /// <param name="pixelsFromEdge"> /// A <see cref="Vector2"/> /// </param> /// <param name="renderingCamera"> /// A <see cref="Camera"/> /// </param> public static void ScreenPlacement(this GameObject target, ScreenPosition position, Vector2 pixelsFromEdge, Camera renderingCamera){ DoScreenPlacement(target.transform, position, pixelsFromEdge, renderingCamera); }
/// <summary> /// Gets the coordinates matching an independent screen position value. /// </summary> /// <param name="ctrl">Target control for which the coordinates should be resolved.</param> /// <param name="position">Screen position value.</param> /// <returns>Pixel point in screen coordinates.</returns> public static Point ResolveScreenPositionEdge(this Control ctrl, ScreenPosition position) { var ctrlRegion = ctrl.RectangleToScreen(ctrl.ClientRectangle); return ResolveScreenPositionToRectangle(ctrlRegion, position); }
/// <summary> /// Gets the coordinates point matching an independent screen position value. /// </summary> /// <param name="position">Screen position value.</param> /// <returns>Pixel point in screen coordinates.</returns> public static Point ResolveScreenPosition(this Screen screen, ScreenPosition position) { var rect = screen.WorkingArea; return ResolveScreenPositionToRectangle(rect, position); }
public ScoreboardShow(string board, ScreenPosition pos) { this.Board = board; this.Position = pos; }
//Transform overrides: /// <summary> /// Places a Transform at one of the 9 positions around the screen edge. /// </summary> /// <param name="target"> /// A <see cref="Transform"/> /// </param> /// <param name="position"> /// A <see cref="ScreenPosition"/> /// </param> public static void ScreenPlacement(this Transform target, ScreenPosition position){ DoScreenPlacement(target.transform, position, Vector2.zero, Camera.main); }
/// <summary> /// Places a Transform at one of the 9 positions around the screen edge. /// </summary> /// <param name="target"> /// A <see cref="Transform"/> /// </param> /// <param name="position"> /// A <see cref="ScreenPosition"/> /// </param> /// <param name="renderingCamera"> /// A <see cref="Camera"/> /// </param> public static void ScreenPlacement(this Transform target, ScreenPosition position, Camera renderingCamera){ DoScreenPlacement(target.transform, position, Vector2.zero, renderingCamera); }
private void UpdateMovement(Movement movement, ScreenPosition playerScreenPosition, MoveDirection playerMoveDirection) { if (mCurrentState == CharacterState.Walking) { mSpeed = Vector2.Zero; mDirection = Vector2.Zero; mSpeed.X = Data.Speed; if (movement.Direction == MoveDirection.Left && playerScreenPosition == ScreenPosition.Right) { mSpeed.X = Data.Speed + (Data.Speed / 2); } if (movement.Direction == MoveDirection.Left && playerScreenPosition == ScreenPosition.Left) { mSpeed.X = Data.Speed / 2; } if (movement.Direction == MoveDirection.Right && playerScreenPosition == ScreenPosition.Left) { mSpeed.X = Data.Speed + (Data.Speed / 2); } if (movement.Direction == MoveDirection.Right && playerScreenPosition == ScreenPosition.Right) { if (playerMoveDirection == MoveDirection.Right) mSpeed.X = Data.Speed / 2; } if (movement.Direction == MoveDirection.Up || movement.Direction == MoveDirection.Down) mDirection.Y = AnimatedSprite.Constants.DirectionOffsets[movement.Direction]; else mDirection.X = AnimatedSprite.Constants.DirectionOffsets[movement.Direction]; } }
public static void Draw(Texture2D tex, ScreenPosition postion, float scaleW, float scaleH) { throw new NotImplementedException("Método não implementado!"); }
public void SetConversation (Conversation conversation, ScreenPosition position = ScreenPosition.Right) { this._conversation = conversation; SetText(); SetCharacter( this._conversation.GetCurrentSpeaker(), position ); }
public ScreenState(ScreenPosition pos, DateTime start, DateTime end) { this._start = start; this._end = end; this._pos = pos; }
public ScreenState(ScreenState goalState) { this._start = goalState._start; this._end = goalState._end; this._pos = goalState._pos; }