/// <summary> /// Redraws the overlay<br/> /// We need to know the stage bounds because we want to inteligently place the label (not to be clipped) /// </summary> /// <param name="bounds"></param> /// <param name="stageBounds"></param> /// <param name="text"></param> public void Redraw(Rectangle bounds, Rectangle stageBounds, string text) { //Debug.Log("Setting overlay to: " + bounds + "; stageBounds: " + stageBounds); _overlayBounds = bounds; _stageBounds = stageBounds; Text = text; InvalidateSize(); InvalidateDisplayList(); }
public DragProxyTween(object target, Rectangle oldBounds, Rectangle newBounds) { Target = target; OldBounds = oldBounds; NewBounds = newBounds; //Duration = DefaultDuration; //Easer = DefaultEaser; Add(Tween.New().SetOptions( new TweenOption(TweenOptionType.Property, "X"), new TweenOption(TweenOptionType.Duration, DefaultDuration), new TweenOption(TweenOptionType.Easer, DefaultEaser), new TweenOption(TweenOptionType.StartValue, OldBounds.X), new TweenOption(TweenOptionType.EndValue, NewBounds.X) )); Add(Tween.New().SetOptions( new TweenOption(TweenOptionType.Property, "Y"), new TweenOption(TweenOptionType.Duration, DefaultDuration), new TweenOption(TweenOptionType.Easer, DefaultEaser), new TweenOption(TweenOptionType.StartValue, OldBounds.Y), new TweenOption(TweenOptionType.EndValue, NewBounds.Y) )); Add(Tween.New().SetOptions( new TweenOption(TweenOptionType.Property, "Width"), new TweenOption(TweenOptionType.Duration, DefaultDuration), new TweenOption(TweenOptionType.Easer, DefaultEaser), new TweenOption(TweenOptionType.StartValue, OldBounds.Width), new TweenOption(TweenOptionType.EndValue, NewBounds.Width) //new TweenOption(TweenOptionType.Proxy, new SetActualWidthProxy(Target)) )); Add(Tween.New().SetOptions( new TweenOption(TweenOptionType.Property, "Height"), new TweenOption(TweenOptionType.Duration, DefaultDuration), new TweenOption(TweenOptionType.Easer, DefaultEaser), new TweenOption(TweenOptionType.StartValue, OldBounds.Height), new TweenOption(TweenOptionType.EndValue, NewBounds.Height) //new TweenOption(TweenOptionType.Proxy, new SetActualHeightProxy(Target)) )); /*Property = "Bounds"; //Interpolator = new RectangleInterpolator(); Duration = DefaultDuration; Easer = DefaultEaser; StartValueReader = new PropertyReader("Bounds");*/ }
// ReSharper restore UnassignedField.Global #endif public static Rectangle CalculateBounds(float parentWidth, float parentHeight, float? left, float? right, float? top, float? bottom, float? width, float? height) { #if DEBUG if (DebugMode) Debug.Log( string.Format("CalculateBounds parentWidth: {0}; parentHeight: {1}; left: {2}; right: {3}; top: {4}; bottom: {5}; width: {6}; height: {7};", parentWidth, parentHeight, left, right, top, bottom, width, height)); #endif float x = left ?? 0; float y = top ?? 0; float w; float h; /*Debug.Log("parentWidth: " + parentWidth); Debug.Log("left: " + left); Debug.Log("right: " + right);*/ if (null != width) // explicit width defined w = (int)width; else { w = parentWidth; if (null != left) w -= (float) left; if (null != right) w -= (float) right; w = Math.Max(0, w); } if (null != height) // explicit width defined h = (int)height; else { h = parentHeight; if (null != top) h -= (float)top; if (null != bottom) h -= (float)bottom; h = Math.Max(0, h); } Rectangle b = new Rectangle(x, y, w, h); //Debug.Log(b); return b; }
public ScaleBoundsTween(object target, Rectangle oldBounds, Rectangle newBounds) { Target = target; OldBounds = oldBounds; NewBounds = newBounds; //Duration = DefaultDuration; //Easer = DefaultEaser; Add(Tween.New().SetOptions( new TweenOption(TweenOptionType.Property, "X"), new TweenOption(TweenOptionType.Duration, DefaultDuration), new TweenOption(TweenOptionType.Easer, DefaultEaser), new TweenOption(TweenOptionType.StartValue, OldBounds.X), new TweenOption(TweenOptionType.EndValue, NewBounds.X) )); Add(Tween.New().SetOptions( new TweenOption(TweenOptionType.Property, "Y"), new TweenOption(TweenOptionType.Duration, DefaultDuration), new TweenOption(TweenOptionType.Easer, DefaultEaser), new TweenOption(TweenOptionType.StartValue, OldBounds.Y), new TweenOption(TweenOptionType.EndValue, NewBounds.Y) )); Add(Tween.New().SetOptions( new TweenOption(TweenOptionType.Property, "Width"), new TweenOption(TweenOptionType.Duration, DefaultDuration), new TweenOption(TweenOptionType.Easer, DefaultEaser), new TweenOption(TweenOptionType.StartValue, OldBounds.Width), new TweenOption(TweenOptionType.EndValue, NewBounds.Width)/*, new TweenOption(TweenOptionType.Proxy, new SetActualWidthProxy(target))*/ )); Add(Tween.New().SetOptions( new TweenOption(TweenOptionType.Property, "Height"), new TweenOption(TweenOptionType.Duration, DefaultDuration), new TweenOption(TweenOptionType.Easer, DefaultEaser), new TweenOption(TweenOptionType.StartValue, OldBounds.Height), new TweenOption(TweenOptionType.EndValue, NewBounds.Height)/*, new TweenOption(TweenOptionType.Proxy, new SetActualHeightProxy(target))*/ )); }
//private readonly Rectangle _retVal = new Rectangle(); public object Interpolate(float fraction, object startValue, object endValue) { _startValue = (Rectangle)startValue; _endValue = (Rectangle)endValue; // NOTE: Beware! // You cannot use _retVal with reference types! // That is because the first time the _retVal is being returned from this interpolator, it Bounds of the target object start referencing it // The next moment, we are changing values here (on the same object), and when "appliing" the new values to the object, // Equals returns true because those values are already there (it's the same Rectangle), so nothing happens //_retVal.X = _startValue.X + (_endValue.X - _startValue.X) * fraction; //_retVal.Y = _startValue.Y + (_endValue.Y - _startValue.Y) * fraction; //_retVal.Width = _startValue.Width + (_endValue.Width - _startValue.Width) * fraction; //_retVal.Height = _startValue.Height + (_endValue.Height - _startValue.Height) * fraction; //return _retVal; return new Rectangle(_startValue.X + (_endValue.X - _startValue.X) * fraction, _startValue.Y + (_endValue.Y - _startValue.Y) * fraction, _startValue.Width + (_endValue.Width - _startValue.Width) * fraction, _startValue.Height + (_endValue.Height - _startValue.Height) * fraction); }
protected override void ValidateChild(DisplayObject child) { _childBounds = child.Transform.Bounds; _isClippingGroup = null != _group && _group.ClipAndEnableScrolling; _childRenderingPosition = _isClippingGroup ? child.Transform.Position : // parent is clipping. Origin is the distance from (0, 0) of the parent _imc.Transform.RenderingPosition.Add(child.Transform.Position); // add to rendering position _childGlobalPosition = _imc.Transform.GlobalPosition.Add(child.Transform.Position); _childRenderingRect = new Rect(_childRenderingPosition.X, _childRenderingPosition.Y, _childBounds.Width, _childBounds.Height); _childLocalRenderingRect = new Rect(0, 0, _childBounds.Width, _childBounds.Height); child.Transform.Apply(_childRenderingPosition, _childGlobalPosition, _childRenderingRect, _childLocalRenderingRect); child.Transform.ValidateChildren(); // RECURSION! (skin etc.) }
/// <summary> /// Gets align bounds /// </summary> /// <param name="childrenBounds"></param> /// <param name="containerBounds"></param> /// <returns></returns> public static Rectangle GetAlignBounds(Rectangle childrenBounds, Rectangle containerBounds) { float width = Math.Max(childrenBounds.Width, containerBounds.Width); float height = Math.Max(childrenBounds.Height, containerBounds.Height); return new Rectangle(0, 0, width, height); }
/// <summary> /// Centers the inner rectangle inside the given outer rectangle /// </summary> /// <param name="outer">Outer rectangle</param> /// <param name="inner">Inner rectangle</param> /// <returns>Centered rectangle</returns> public static Rectangle CenterRectangle(Rectangle outer, Rectangle inner) { return new Rectangle((outer.Width - inner.Width) / 2, (outer.Height - inner.Height) / 2, inner.Width, inner.Height); }
/// <summary> /// Render slot /// </summary> /// <param name="parameters"></param> public void RenderSlot(params object[] parameters) { // Checking if the current component moved and/or resized // NOTE: Using brute force checking here (instead of listening to move and resize events) // because the component may choose not to dispatch any events // However - no harm done - the DesignerOverlay should be off in the production if (null == _stage) return; if (null != _hoveredComponent && !_previousHoveredBounds.Equals(_hoveredComponent.Transform.GlobalBounds) && IsInspectable(_hoveredComponent)) { _stage.Hover(_hoveredComponent); _previousHoveredBounds = _hoveredComponent.Transform.GlobalBounds; } if (null != _selectedComponent && !_previousSelectedBounds.Equals(_selectedComponent.Transform.GlobalBounds) && IsInspectable(_selectedComponent)) { _stage.Select(_selectedComponent); _previousSelectedBounds = _selectedComponent.Transform.GlobalBounds; } }
public static Rectangle CenterRect(Rectangle inner, Rectangle outer) { //Debug.Log("inner: " + inner + "; outer: " + outer); return new Rectangle((outer.Width - inner.Width) / 2, (outer.Height - inner.Height) / 2, inner.Width, inner.Height); }
/** * */ override internal Rectangle GetElementBoundsRightOfScrollRect(Rectangle scrollRect) { var bounds = new Rectangle(); // Find the column that spans or is to the right of the scrollRect right edge. int column = (int) Math.Floor((double) ((scrollRect.Right + 1 + _horizontalGap) / (_columnWidth + _horizontalGap))); bounds.Left = LeftEdge(column); bounds.Right = RightEdge(column); return bounds; }
/// <summary> /// Returns true if two rectangles intersect /// </summary> /// <param name="rectangle"></param> /// <returns></returns> public bool Intersects(Rectangle rectangle) { // reverse logic - early exit return !(Left > rectangle.Right || Right < rectangle.Left || Top > rectangle.Bottom || Bottom < rectangle.Top); }
/// <summary> /// Checks if a given rectangle is placed inside this rectangle /// </summary> /// <param name="rectangle"></param> /// <returns></returns> public bool Contains(Rectangle rectangle) { return (rectangle.Left >= Left && rectangle.Right <= Right && rectangle.Top >= Top && rectangle.Bottom <= Bottom); }
/// <summary> /// We should listen the mouse move events over the component /// If mouse moved over the event, we should check border and draw overlay /// </summary> /// <param name="e"></param> private void ComponentMouseMoveHandler(Event e) { if (!Enabled) return; Debug.Log(string.Format("ComponentMouseMoveHandler [{0}, {1}]", e.Phase, e.CurrentTarget)); if (!(e.Target is DisplayListMember)) return; DisplayListMember dlm = (DisplayListMember)e.Target; MouseEvent me = (MouseEvent)e; //Container container = _component as Container; //Point coordsInComponentSpace = null != container ? // container.GlobalToContent(dlm.LocalToGlobal(me.LocalPosition)) : // _component.GlobalToLocal(dlm.LocalToGlobal(me.LocalPosition)); Point coordsInComponentSpace = _component.GlobalToLocal(dlm.LocalToGlobal(me.LocalPosition)); // if some component is already being dragged/resized, do not draw borders on hover if (DragManager.IsDragging) return; if (_constraintMode) { _constrainedRect = _constraintMetrics.GetConstrainedRectangle(_component.Transform.LocalBounds); DoRenderOverlay = _constrainedRect.Contains(coordsInComponentSpace); } else { DoRenderOverlay = true; } if (DoRenderOverlay) { e.Cancel(); } }
public virtual Rectangle GlobalToLocal(Rectangle r) { Rectangle r2 = (Rectangle)r.Clone(); r2.Position = GlobalToLocal(r2.Position); return r2; }
/// <summary> /// Constrains this rectangle with the outer one /// </summary> /// <param name="outer"></param> /// <returns></returns> public Rectangle GetConstrainedRectangle(Rectangle outer) { Rectangle rect = new Rectangle(); if (null != Left) rect.X = outer.X + (float) Left; if (null != Width) rect.Width = (float)Width; else if (null != Right) rect.Width = outer.Width - rect.X - (float)Right; if (null != Top) rect.Y = outer.Y + (float)Top; if (null != Height) rect.Height = (float)Height; else if (null != Bottom) rect.Height = outer.Height - rect.Y - (float)Bottom; //Debug.Log((" -> result: " + rect)); return rect; }
/// <summary> /// /// </summary> /// <returns></returns> protected Point CalculatePopUpPosition() { Point regPoint = new Point(); /*if (!matrix) return regPoint;*/ var popUpBounds = new Rectangle(); var popUpAsDisplayObject = _popup as DisplayObject; DeterminePosition(_popupPosition, popUpAsDisplayObject.Width, popUpAsDisplayObject.Height, /*matrix, */regPoint, popUpBounds); PopupPosition adjustedPosition = PopupPosition.Above; bool isAdjusted = false; var screenSize = SystemManager.Instance.ScreenSize; // Position the popUp in the opposite direction if it // does not fit on the screen. switch(_popupPosition) { case PopupPosition.Below : if (popUpBounds.Bottom > screenSize.Y) { adjustedPosition = PopupPosition.Above; isAdjusted = true; } break; case PopupPosition.Above : if (popUpBounds.Top < 0) { adjustedPosition = PopupPosition.Below; isAdjusted = true; } break; case PopupPosition.Left : if (popUpBounds.Left < 0) { adjustedPosition = PopupPosition.Right; isAdjusted = true; } break; case PopupPosition.Right : if (popUpBounds.Right > screenSize.X) { adjustedPosition = PopupPosition.Left; isAdjusted = true; } break; } // Get the new registration point based on the adjusted position if (isAdjusted) { var adjustedRegPoint = new Point(); var adjustedBounds = new Rectangle(); DeterminePosition((PopupPosition) adjustedPosition, popUpAsDisplayObject.Width, popUpAsDisplayObject.Height, /*matrix, */adjustedRegPoint, adjustedBounds); // If we adjusted the position but the popUp still doesn't fit, // then revert to the original position. switch(adjustedPosition) { case PopupPosition.Below : if (adjustedBounds.Bottom > screenSize.Y) isAdjusted = false; break; case PopupPosition.Above : if (adjustedBounds.Top < 0) isAdjusted = false; break; case PopupPosition.Left : if (adjustedBounds.Left < 0) isAdjusted = false; break; case PopupPosition.Right : if (adjustedBounds.Right > screenSize.X) isAdjusted = false; break; } if (isAdjusted) { regPoint = adjustedRegPoint; popUpBounds = adjustedBounds; } } /*MatrixUtil.decomposeMatrix(decomposition, matrix, 0, 0); var concatScaleX:Number = decomposition[3]; var concatScaleY:Number = decomposition[4]; */ // If the popUp still doesn't fit, then nudge it // so it is completely on the screen. Make sure to include scale. if (popUpBounds.Top < 0) regPoint.Y += (0 - popUpBounds.Top); // / concatScaleY; else if (popUpBounds.Bottom > screenSize.Y) regPoint.Y -= (popUpBounds.Bottom - screenSize.Y); // / concatScaleY; if (popUpBounds.Left < 0) regPoint.X += (0 - popUpBounds.Left); // / concatScaleX; else if (popUpBounds.Right > screenSize.X) regPoint.X -= (popUpBounds.Right - screenSize.X);// / concatScaleX; return LocalToGlobal(regPoint); //return matrix.transformPoint(regPoint); }
internal void RenderHandler(object parameter) { if (null == _stage) // could be null on application recompile return; if (_sticky != Sticky) { #if DEBUG if (DebugMode) Debug.Log("Sticky changed"); #endif _sticky = Sticky; if (!_sticky) HideOverlay(); } // Checking if the current component moved and/or resized // NOTE: Using brute force checking here (instead of listening to move and resize events) // because the component may choose not to dispatch any events // However - no harm done - the GuiInspector should be off in the production if (null != _currentComponent) // && null != _stage) { if (!_previousBounds.Equals(_currentComponent.Transform.GlobalBounds) && IsInspectable(_currentComponent)) { _stage.DoShowOverlay(_currentComponent); _previousBounds = _currentComponent.Transform.GlobalBounds; } } }
/// <summary> /// Centers THIS rectangle inside the given outer rectangle /// </summary> /// <param name="outerRectangle"></param> /// <returns>Centered (THIS) rectangle</returns> public Rectangle CenterInside(Rectangle outerRectangle) { //Debug.Log("outerRectangle: " + outerRectangle); return CenterRectangle(outerRectangle, this); }
private void ComponentMouseDownHandler(Event e) { Debug.Log(string.Format("ComponentMouseDownHandler [{0}, {1}]", e.Phase, e.CurrentTarget)); if (!Enabled) return; if (AutoBringToFront) _component.BringToFront(); MouseEvent me = (MouseEvent) e; //var container = _component.Parent as Container; // 20121125 (because dragging didn't work well when parent scrolled) //_startCoordinates = null != container ? // container.GlobalToContent(_component.Transform.GlobalPosition) : // GlobalToContent no more - TODO // _component.Parent.GlobalToLocal(_component.Transform.GlobalPosition); _clickCoordinates = me.GlobalPosition; if (_constraintMode) { _constrainedRect = _constraintMetrics.GetConstrainedRectangle(_component.Transform.LocalBounds); if (!_constrainedRect.Contains(me.LocalPosition)) return; } e.CancelAndStopPropagation(); DragManager.IsDragging = true; SystemEventDispatcher.Instance.AddEventListener(MouseEvent.MOUSE_MOVE, MouseMoveHandler); SystemEventDispatcher.Instance.AddEventListener(MouseEvent.MOUSE_UP, MouseUpHandler); if (-1 == _cursorId) { _cursorId = CursorManager.Instance.SetCursor(CursorType.Move, CursorPriority.High); } }
/// <summary> /// Constrains this rectangle inside another rectangle's bounds /// </summary> /// <param name="rectangle"></param> public void ConstrainWithin(Rectangle rectangle) { X = Math.Max(X, rectangle.X); Y = Math.Max(Y, rectangle.Y); Right = Math.Min(Right, rectangle.Right); Bottom = Math.Min(Bottom, rectangle.Bottom); }
private static Color _transparent = new Color(1, 1, 1, 0); // transparent private void DrawPixels(Rectangle fillRect, int yMax, int yMin, int xMin, int xMax, bool hasStroke, Color[] pixels, int count) { //if (null == Fill) // Fill = new Fill(new Color(1, 1, 1, 0)); // transparent for (int y = yMax; y > yMin; y--) { for (int x = xMin; x < xMax; x++) { _isFill = false; _isStroke = false; _point.X = x; _point.Y = y; _isFill = fillRect.Contains(_point); if (hasStroke && !_isFill) _isStroke = Bounds.Contains(_point); _color = _transparent; // new Color(1, 1, 1, 0); // transparent if (_isFill && null != Fill) { _color = CalculatePixelColor(Fill, y, x); } else if (_isStroke && null != Stroke) { _color = CalculatePixelColor(Stroke, x, y); } pixels[count] = _color; count++; } } }
/// <summary> /// Equality /// </summary> /// <param name="other"></param> /// <returns></returns> public bool Equals(Rectangle other) { if (ReferenceEquals(null, other)) return false; //if (ReferenceEquals(this, other)) return true; // commented 20120625 return other._x == _x && other._y == _y && other._width == _width && other._height == _height; }
internal virtual Rectangle GetElementBoundsAboveScrollRect(Rectangle scrollRect) // TEMP internal (protected) { return new Rectangle { Top = scrollRect.Top - 1, Bottom = scrollRect.Top }; }
/** * */ override internal int GetNavigationDestinationIndex(int currentIndex, NavigationUnit navigationUnit, bool arrowKeysWrapFocus) { if (null == Target || Target.NumberOfContentChildren < 1) return -1; int maxIndex = Target.NumberOfContentChildren - 1; // Special case when nothing was previously selected if (currentIndex == -1) { if (navigationUnit == NavigationUnit.Up || navigationUnit == NavigationUnit.Left) return arrowKeysWrapFocus ? maxIndex : -1; if (navigationUnit == NavigationUnit.Down || navigationUnit == NavigationUnit.Right) return 0; } // Make sure currentIndex is within range bool inRows = _orientation == TileOrientation.Rows; currentIndex = Math.Max(0, Math.Min(maxIndex, currentIndex)); // Find the current column and row int currentRow; int currentColumn; if (inRows) { // Is the TileLayout initialized with valid values? if (_columnCount == 0 || _rowHeight + _verticalGap == 0) return currentIndex; currentRow = currentIndex / _columnCount; currentColumn = currentIndex - currentRow * _columnCount; } else { // Is the TileLayout initialized with valid values? if (_rowCount == 0 || _columnWidth + _horizontalGap == 0) return currentIndex; currentColumn = currentIndex / _rowCount; currentRow = currentIndex - currentColumn * _rowCount; } int newRow = currentRow; int newColumn = currentColumn; // Handle user input, almost all range checks are // performed after the calculations, at the end of the method. switch (navigationUnit) { case NavigationUnit.Left: { // If we are at the first column, can // we go to the previous element (last column, previous row)? if (newColumn == 0 && inRows && newRow > 0) { newRow--; newColumn = _columnCount - 1; } else if (arrowKeysWrapFocus && newColumn == 0 && inRows && newRow == 0) { newRow = _rowCount - 1; newColumn = _columnCount - 1; } else newColumn--; break; } case NavigationUnit.Right: { // If we are at the last column, can // we go to the next element (first column, next row)? if (newColumn == _columnCount - 1 && inRows && newRow < _rowCount - 1) { newColumn = 0; newRow++; } else if (arrowKeysWrapFocus && newColumn == _columnCount - 1 && inRows && newRow == _rowCount - 1) { newColumn = 0; newRow = 0; } else newColumn++; break; } case NavigationUnit.Up: { // If we are at the first row, can we // go to the previous element (previous column, last row)? if (newRow == 0 && !inRows && newColumn > 0) { newColumn--; newRow = _rowCount - 1; } else if (arrowKeysWrapFocus && newRow == 0 && !inRows && newColumn == 0) { newColumn = _columnCount - 1; newRow = _rowCount - 1; } else newRow--; break; } case NavigationUnit.Down: { // If we are at the last row, can we // go to the next element (next column, first row)? if (newRow == _rowCount - 1 && !inRows && newColumn < _columnCount - 1) { newColumn++; newRow = 0; } else if (arrowKeysWrapFocus && newRow == _rowCount - 1 && !inRows && newColumn == _columnCount - 1) { newColumn = 0; newRow = 0; } else newRow++; break; } case NavigationUnit.PageUp: case NavigationUnit.PageDown: { // Ensure we have a valid scrollRect as we use it for calculations below Rectangle scrollRect = GetScrollRect(); if (null == scrollRect) scrollRect = new Rectangle(0, 0, Target.ContentWidth, Target.ContentHeight); if (inRows) { int firstVisibleRow = (int) Mathf.Ceil(scrollRect.Top / ((float)_rowHeight + _verticalGap)); int lastVisibleRow = (int) Mathf.Floor(scrollRect.Bottom / ((float)_rowHeight + _verticalGap)); if (navigationUnit == NavigationUnit.PageUp) { // Is the current row visible, somewhere in the middle of the scrollRect? if (firstVisibleRow < currentRow && currentRow <= lastVisibleRow) newRow = firstVisibleRow; else newRow = 2 * firstVisibleRow - lastVisibleRow; } else { // Is the current row visible, somewhere in the middle of the scrollRect? if (firstVisibleRow <= currentRow && currentRow < lastVisibleRow) newRow = lastVisibleRow; else newRow = 2 * lastVisibleRow - firstVisibleRow; } } else { int firstVisibleColumn = (int) Mathf.Ceil(scrollRect.Left / ((float)_columnWidth + _horizontalGap)); int lastVisibleColumn = (int) Mathf.Floor(scrollRect.Right / ((float)_columnWidth + _horizontalGap)); if (navigationUnit == NavigationUnit.PageUp) { // Is the current column visible, somewhere in the middle of the scrollRect? if (firstVisibleColumn < currentColumn && currentColumn <= lastVisibleColumn) newColumn = firstVisibleColumn; else newColumn = 2 * firstVisibleColumn - lastVisibleColumn; } else { // Is the current column visible, somewhere in the middle of the scrollRect? if (firstVisibleColumn <= currentColumn && currentColumn < lastVisibleColumn) newColumn = lastVisibleColumn; else newColumn = 2 * lastVisibleColumn - firstVisibleColumn; } } break; } default: return base.GetNavigationDestinationIndex(currentIndex, navigationUnit, arrowKeysWrapFocus); } // Make sure rows and columns are within range newRow = Math.Max(0, Math.Min(_rowCount - 1, newRow)); newColumn = Math.Max(0, Math.Min(_columnCount - 1, newColumn)); // Calculate the new index based on orientation if (inRows) { // Make sure we don't return an index for an empty space in the last row. // newRow is guaranteed to be greater than zero: // Step 1: We can end up at the empty space in the last row if we moved right from // the last item. if (currentIndex == maxIndex && newColumn > currentColumn) newColumn = currentColumn; // Step 2: We can end up at the empty space in the last row if we moved down from // the previous row. if (newRow == _rowCount - 1 && newColumn > maxIndex - _columnCount * (_rowCount - 1)) newRow--; return newRow * _columnCount + newColumn; } else { // Make sure we don't return an index for an empty space in the last column. // newColumn is guaranteed to be greater than zero: // Step 1: We can end up at the empty space in the last column if we moved down from // the last item. if (currentIndex == maxIndex && newRow > currentRow) newRow = currentRow; // Step 2: We can end up at the empty space in the last column if we moved right from // the previous column. if (newColumn == _columnCount - 1 && newRow > maxIndex - _rowCount * (_columnCount - 1)) newColumn--; return newColumn * _rowCount + newRow; } }
/// <summary> /// Mouse move handler /// Fires when in processing mode (resizing) /// </summary> /// <param name="e"></param> private void MouseMoveHandler(Event e) { if (!IsResizing) return; e.CancelAndStopPropagation(); MouseEvent me = (MouseEvent)e; Point position; position = me.GlobalPosition; var delta = position.Subtract(_clickCoords); switch (_resizeMode) { case ResizeMode.Right: _newBounds = _origBounds.Expand(0, delta.X, 0, 0); break; case ResizeMode.Left: _newBounds = _origBounds.Expand(-delta.X, 0, 0, 0); break; case ResizeMode.Top: _newBounds = _origBounds.Expand(0, 0, -delta.Y, 0); break; case ResizeMode.Bottom: _newBounds = _origBounds.Expand(0, 0, 0, delta.Y); break; case ResizeMode.TopLeft: _newBounds = _origBounds.Expand(-delta.X, 0, -delta.Y, 0); break; case ResizeMode.TopRight: _newBounds = _origBounds.Expand(0, delta.X, -delta.Y, 0); break; case ResizeMode.BottomLeft: _newBounds = _origBounds.Expand(-delta.X, 0, 0, delta.Y); break; case ResizeMode.BottomRight: _newBounds = _origBounds.Expand(0, delta.X, 0, delta.Y); break; } // gracefully handle the minimum sizes set by the user _newBounds.X = Mathf.Min(_newBounds.X, _origBounds.Right - _component.MinWidth); _newBounds.Y = Mathf.Min(_newBounds.Y, _origBounds.Bottom - _component.MinHeight); _newBounds.Width = Mathf.Min(Mathf.Max(_newBounds.Width, _component.MinWidth), _component.MaxWidth); // MeasuredMinWidth _newBounds.Height = Mathf.Min(Mathf.Max(_newBounds.Height, _component.MinHeight), _component.MaxHeight); // apply if (ChangeExplicitSize) { _component.Width = _newBounds.Width; _component.Height = _newBounds.Height; } else { _component.SetActualSize(_newBounds.Width, _newBounds.Height); } _component.Move(_newBounds.X, _newBounds.Y); /** * When resizing by the top/left edge, the visual jitter can be observed in component's right-aligned children * so to avoid this jitter, we should validate now * */ if (_resizeMode == ResizeMode.Left || _resizeMode == ResizeMode.Top || _resizeMode == ResizeMode.TopLeft) { //_component.ValidateNow(); } }
/** * */ override internal Rectangle GetElementBoundsBelowScrollRect(Rectangle scrollRect) { var bounds = new Rectangle(); // Find the row that spans or is below the scrollRect bottom edge int row = (int) Math.Floor((double) ((scrollRect.Bottom + 1 + _verticalGap) / (_rowHeight + _verticalGap))); bounds.Top = TopEdge(row); bounds.Bottom = BottomEdge(row); return bounds; }
internal virtual Rectangle GetElementBoundsBelowScrollRect(Rectangle scrollRect) // TEMP internal (protected) { return new Rectangle { Top = scrollRect.Bottom, Bottom = scrollRect.Bottom + 1 }; }
internal virtual Rectangle GetElementBoundsRightOfScrollRect(Rectangle scrollRect) // TEMP internal (protected) { return new Rectangle {Left = scrollRect.Right , Right = scrollRect.Right + 1}; }
/** * */ internal void DeterminePosition(PopupPosition placement, float popUpWidth, float popUpHeight, /*matrix:Matrix, */Point registrationPoint, Rectangle bounds) { switch(placement) { case PopupPosition.Below: registrationPoint.X = 0; registrationPoint.Y = Height; break; case PopupPosition.Above: registrationPoint.X = 0; registrationPoint.Y = -popUpHeight; break; case PopupPosition.Left: registrationPoint.X = -popUpWidth; registrationPoint.Y = 0; break; case PopupPosition.Right: registrationPoint.X = Width; registrationPoint.Y = 0; break; case PopupPosition.Center: registrationPoint.X = (Width - popUpWidth) / 2; registrationPoint.Y = (Height - popUpHeight) / 2; break; case PopupPosition.TopLeft: // already 0,0 break; } //var popUpAsDisplayObject = _popup as DisplayObject; /*Point globalTl = (Point) registrationPoint.Clone(); //matrix.transformPoint(registrationPoint); registrationPoint.Y += popUpAsDisplayObject.Height; Point globalBl = (Point) registrationPoint.Clone(); //matrix.transformPoint(registrationPoint); registrationPoint.X += popUpAsDisplayObject.Width; Point globalBr = (Point) registrationPoint.Clone(); //matrix.transformPoint(registrationPoint); registrationPoint.Y -= popUpAsDisplayObject.Height; Point globalTr = (Point) registrationPoint.Clone(); //matrix.transformPoint(registrationPoint); registrationPoint.X -= popUpAsDisplayObject.Width; bounds.Left = Mathf.Min(globalTl.X, globalBl.X, globalBr.X, globalTr.X); bounds.Right = Mathf.Max(globalTl.X, globalBl.X, globalBr.X, globalTr.X); bounds.Top = Mathf.Min(globalTl.Y, globalBl.Y, globalBr.Y, globalTr.Y); bounds.Bottom = Mathf.Max(globalTl.Y, globalBl.Y, globalBr.Y, globalTr.Y);*/ var globalRegPoint = Parent.LocalToGlobal(registrationPoint); bounds.X = globalRegPoint.X; bounds.Y = globalRegPoint.Y; bounds.Width = popUpWidth; bounds.Height = popUpHeight; }