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> /// Centers the popup after it is created /// </summary> /// <param name="popup">The popup to center</param> /// <param name="keepCenter">Should the popup manager take care of centering the popup while it's instantiated</param> public void CenterPopUp(DisplayObject popup, bool keepCenter) { if (popup is IInvalidating) ((IInvalidating)popup).ValidateNow(); #if DEBUG if (DebugMode) { Debug.Log("CenterPopUp"); } #endif //popup.SetBounds(popup.Bounds.CenterInside(popup.Owner.Bounds)); if (_descriptors.ContainsKey(popup)) { var descriptor = _descriptors[popup]; if (keepCenter != descriptor.KeepCenter) descriptor.KeepCenter = keepCenter; //Debug.Log("Stage.Bounds: " + ((Component)popup).Stage.Bounds); //Debug.Log("popup.Bounds: " + popup.Bounds); var imc = popup as InvalidationManagerClient; if (null != imc) { var bounds = popup.Bounds.CenterInside(null != descriptor.Owner ? descriptor.Owner.Bounds : descriptor.Stage.Bounds); imc.Move(Mathf.Round(bounds.X), Mathf.Round(bounds.Y)); } } else { throw new Exception("No popup to center"); } }
///<summary> /// Invalidates the transform, meaning it has to be validated somehow<br/> /// This method has to be implemented by subclass<br/> /// The subclass might choose will it update immediatelly or later ///</summary> protected abstract void InvalidateChild(DisplayObject child);
internal void DoShowOverlay(DisplayObject target) { if (null == target) return; DisplayListMember dlm = target as DisplayListMember; // do not analyze anything from this stage if (null != dlm && !GuiInspector.IsInspectable(dlm)) return; if (null != _overlay) { _overlay.Visible = true; _overlay.Redraw(target.Transform.GlobalBounds, Bounds, NamingUtil.DisplayListMemberToString((DisplayListMember)target)); } //InspectorDetailsWindow.Instance.Inform(); }
internal void Select(DisplayObject target) { var dlm = target as DisplayListMember; // do not analyze anything from this stage if (null != dlm && !DesignerOverlay.IsInspectable(dlm)) return; var go = GuiLookup.GetGameObject((Component) target); if (null != go) { _selectionOverlay.Visible = true; var bounds = target.Transform.GlobalBounds; /** * 1. Expand around component * */ bounds = bounds.Expand(PlayModeOverlaySelectionBorderStyle.BorderWidth); /** * 2. Constrain with stage bounds * */ bounds.ConstrainWithin(Rectangle.FromSize(SystemManager.Instance.ScreenSize)); _selectionOverlay.Redraw(bounds, Bounds, GuiLookup.PathToString(go.transform, " -> ")); _selectionOverlay.ValidateNow(); } }
protected virtual bool IsOurFocus(DisplayObject target) { return target == this; }
/** * * Capture any mouse down event and listen for a mouse up event */ private void MouseDownHandler(Event e) { //var sm = SystemEventDispatcher.Instance; var dispatcher = MouseEventDispatcher.Instance; dispatcher.AddEventListener(MouseEvent.MOUSE_UP, SystemMouseUpSomewhereHandler, EventPhase.CaptureAndTarget); _mouseDownTarget = (DisplayObject) e.Target; }
/// <summary> /// Returns true if popup is displayed /// </summary> /// <param name="popup">A popup to remove</param> public bool HasPopup(DisplayObject popup) { #if DEBUG if (DebugMode) { Debug.Log("HasPopup"); } #endif return _descriptors.ContainsKey(popup); }
protected virtual bool IsOurFocus(DisplayObject target) { return(target == this); }
///<summary> /// When InvalidationManagerClientTransform is invalidated, we are not updating immediatelly,<br/> /// but going throught the invalidation instead<br/> /// The ValidateTransform (on target) will be called later and our ValidateChild will be called from there ///</summary> protected override void InvalidateChild(DisplayObject child) { //_imc.InvalidateTransform(); child.Transform.Invalidate(); }
private void ShowOverlay(DisplayObject target) { if (null == _stage) // could be null on application recompile return; _stage.DoShowOverlay(target); }
///<summary> /// When DisplayObjectTransform is invalidated, we are updating immediatelly<br/> /// There's no invalidation available for DisplayObjects ///</summary> protected override void InvalidateChild(DisplayObject child) { ValidateChild(child); }
///<summary> /// When InvalidationManagerClientTransform is invalidated, we are not updating immediatelly,<br/> /// but going throught the invalidation instead<br/> /// The ValidateTransform (on target) will be called later and our ValidateChild will be called from there ///</summary> protected override void InvalidateChild(DisplayObject child) { //_imc.InvalidateTransform(); child.Transform.Invalidate(); }
public void CenterPopUp(DisplayObject popup) { CenterPopUp(popup, false); }
public PopupDescriptor(DisplayObject owner) { Owner = owner; }
internal void MouseWheelOutsideHandler(DisplayObject popup, Point point) { #if DEBUG if (DebugMode) { Debug.Log("MouseDownOutsideHandler: " + popup); } #endif // dispatch from here MouseEvent e = new MouseEvent(MouseEvent.MOUSE_WHEEL_OUTSIDE) { GlobalPosition = point, Target = popup }; DispatchEvent(e); if (e.Canceled) return; // dispatch from popup e = new MouseEvent(MouseEvent.MOUSE_WHEEL_OUTSIDE) { GlobalPosition = point }; popup.DispatchEvent(e); if (e.Canceled) return; // check auto remove if (_descriptors.ContainsKey(popup) && _descriptors[popup].RemoveOnMouseWheelOutside) { RemovePopup(popup); return; } }
public PopupDescriptor(DisplayObject owner, DisplayListMember overlay) { Owner = owner; Overlay = overlay; }
/// <summary> /// Removes a popup from popup stage /// </summary> /// <param name="popup">A popup to remove</param> public void RemovePopup(DisplayObject popup) { #if TRIAL /* HACK CHECK */ Acme acme = (Acme) Framework.GetComponent<Acme>(true); if (null == acme || !acme.gameObject.activeInHierarchy/*active*/ || !acme.enabled) return; #endif #if DEBUG if (DebugMode) { Debug.Log("RemovePopup"); } #endif if (!_descriptors.ContainsKey(popup)) return; var descriptor = _descriptors[popup]; //if (popup.HasFocus) // FocusManager.Instance.Blur(); if (HasEventListener(CLOSING)) { Event e = new Event(CLOSING, popup, false, true); // cancelable DispatchEvent(e); if (e.Canceled) return; } if (IsDefaultPrevented(CLOSING)) return; var stage = descriptor.Stage; //Debug.Log(string.Format(@"Removing {0} from {1}", descriptor.PopupRoot, stage)); // removing children //descriptor.PopupRoot.Parent.RemoveChild(descriptor.PopupRoot); stage.RemoveChild(descriptor.PopupRoot); //Debug.Log("Descriptors remove"); _descriptors.Remove(popup); //FocusManager.Instance.Blur(); // TEMP disabled 2.1.2012. _popups.Remove(popup); if (descriptor.FocusPreviousOnHide) { if (_popups.Count > 0) // we have more opened popups { DisplayObject lastPopup = _popups[_popups.Count - 1]; //Debug.Log("_popups.Count: " + _popups.Count); if (lastPopup is InteractiveComponent) { ((InteractiveComponent)lastPopup).SetFocus(); /*lastPopup.Defer(delegate { ((InteractiveComponent)lastPopup).SetFocus(); }, 1);*/ //FocusManager.Instance.SetFocus((InteractiveComponent)lastPopup); } // TEMP disabled on 2.1.2012. because the overlay popup constantly // appears and dissapears and takes focus // and raises "ArgumentException: You can only call GUI functions from inside OnGUI." // should enable back when overlay will be in it's top stage, non run by popup manager } else // this was the only popup { if (popup is Dialog) { Dialog dlg = (Dialog)popup; if (null != dlg.Owner) { // if owner is defined, focus the owner InteractiveComponent ic = dlg.Owner as InteractiveComponent; /*if (null != ic) ic.SetFocus();*/ if (null != ic) { //((InteractiveComponent)lastPopup).SetFocus(); /*ic.Defer(delegate { //ic.SetFocus(); FocusManager.Instance.SetFocus(ic); }, 1);*/ //FocusManager.Instance.SetFocus(ic); ic.SetFocus(); } } //else // FocusManager.Instance.Blur(); // else blur everything // commented 20130331 - because after closing th eallert, the SetFocus te TextField (via the callback) didn't work } } } // disconnect if (_descriptors.Count == 0) { SystemManager.Instance.ResizeSignal.Disconnect(ResizeSlot); SystemManager.Instance.MouseDownSignal.Disconnect(MouseDownSlot); SystemManager.Instance.MouseWheelSignal.Disconnect(MouseWheelSlot); stage.RemoveEventListener(MouseEvent.MOUSE_DOWN, MouseDownHandler); } //Debug.Log("_descriptors.Count: " + _descriptors.Count); //_stage.ValidateNow(); if (HasEventListener(CLOSE)) DispatchEvent(new Event(CLOSE, popup)); if (descriptor.Popup != descriptor.PopupRoot) { // this is a modal popup // the removed effect won't play on popup, because PopupRoot is being removed, not the popup // we have to handle this case and play the effect here Component component = popup as Component; if (null != component && component.HasStyle("removedEffect")) { ITweenFactory removeEffect = (ITweenFactory)component.GetStyle("removedEffect"); removeEffect.Play(popup); } } }
public PopupDescriptor(DisplayObject owner, DisplayListMember overlay, DisplayListMember popupRoot) { Owner = owner; Overlay = overlay; PopupRoot = popupRoot; }
private void SystemMouseUpSomewhereHandler(Event e) { //Debug.Log("SystemMouseUpSomewhereHandler"); //var sm = SystemEventDispatcher.Instance; var dispatcher = MouseEventDispatcher.Instance; dispatcher.RemoveEventListener(MouseEvent.MOUSE_UP, SystemMouseUpSomewhereHandler, EventPhase.CaptureAndTarget); //Debug.Log("e.Target: " + e.Target); var dlm = (DisplayListMember)e.Target; // If we got a mouse down followed by a mouse up on a different target in the skin, // we want to dispatch a click event. if (_mouseDownTarget != e.Target && e is MouseEvent && Contains(dlm)) { MouseEvent mEvent = e as MouseEvent; // Convert the mouse coordinates from the target to the TrackBase Point mousePoint = new Point(mEvent.LocalPosition.X, mEvent.LocalPosition.Y); mousePoint = GlobalToLocal(dlm.LocalToGlobal(mousePoint)); var me2 = new MouseEvent(MouseEvent.CLICK, mEvent.Bubbles, mEvent.Cancelable) { LocalPosition = new Point(mousePoint.X, mousePoint.Y), RelatedObject = null, Control = mEvent.Control, Shift = mEvent.Shift, Alt = mEvent.Alt, ButtonDown = mEvent.ButtonDown, CurrentEvent = mEvent.CurrentEvent }; DispatchEvent(me2); } _mouseDownTarget = null; }
/** * * Helper method for the mouseMove and mouseUp handlers to see if * the mouse is over a "valid" region. This is used to help determine * when the dropdown should be closed. */ private bool IsTargetOverDropDownOrOpenButton(DisplayObject target) { if (null != target) { // check if the target is the openButton or contained within the openButton if (OpenButton.Contains(target as DisplayListMember)) return true; if (HitAreaAdditions != null) { foreach (DisplayObject displayObject in HitAreaAdditions) { if (displayObject == target || ((displayObject is DisplayObjectContainer) && ((DisplayObjectContainer)displayObject).Contains(target as DisplayListMember))) return true; } } // check if the target is the dropdown or contained within the dropdown var down = DropDown as DisplayObjectContainer; if (down != null) { if (down.Contains((DisplayListMember) target)) return true; } else { if (target == DropDown) return true; } } return false; }
/** * Initiates a drag and drop operation. * * Param: dragInitiator IUIComponent that specifies the component initiating * the drag. * * Param: dragSource DragSource object that contains the data * being dragged. * * Param: mouseEvent The MouseEvent that contains the mouse information * for the start of the drag. * * Param: dragImage The image to drag. This argument is optional. * If omitted, a standard drag rectangle is used during the drag and * drop operation. If you specify an image, you must explicitly set a * height and width of the image or else it will not appear. * * Param: xOffset Number that specifies the x offset, in pixels, for the * <code>dragImage</code>. This argument is optional. If omitted, the drag proxy * is shown at the upper-left corner of the drag initiator. The offset is expressed * in pixels from the left edge of the drag proxy to the left edge of the drag * initiator, and is usually a negative number. * * Param: yOffset Number that specifies the y offset, in pixels, for the * <code>dragImage</code>. This argument is optional. If omitted, the drag proxy * is shown at the upper-left corner of the drag initiator. The offset is expressed * in pixels from the top edge of the drag proxy to the top edge of the drag * initiator, and is usually a negative number. * * Param: imageAlpha Number that specifies the alpha value used for the * drag image. This argument is optional. If omitted, the default alpha * value is 0.5. A value of 0.0 indicates that the image is transparent; * a value of 1.0 indicates it is fully opaque. * * Param: allowMove Indicates if a drop target is allowed to move the dragged data. * */ /// <summary> /// Starts a drag and drop operation /// </summary> /// <param name="dragInitiator"></param> /// <param name="dragSource"></param> /// <param name="mouseEvent"></param> /// <param name="dragImage"></param> /// <param name="xOffset"></param> /// <param name="yOffset"></param> /// <param name="imageAlpha"></param> /// <param name="allowMove"></param> /// <param name="options"></param> public static void DoDrag(Component dragInitiator, DragSource dragSource, MouseEvent mouseEvent, Component dragImage, float xOffset, float yOffset, float imageAlpha, bool allowMove, params DragOption[] options) { #if DEBUG if (DebugMode) Debug.Log("DragDropManager.DoDrag: " + dragInitiator); #endif _dragInitiator = dragInitiator; _dragSource = dragSource; _mouseEvent = mouseEvent; _dragImage = dragImage; _imageAlpha = imageAlpha; _allowMove = allowMove; ApplyOptions(options); /** * 20130307 * Found some glitches regarding the starting the new drag operation while the previous one hasn't been finished yet * Since I was dealing with a single proxy instance since, some of the old (custom) proxies were stale, e.g. never removed when the tween finished * Now I added the line to a tween callback which destroys the animation target * */ _proxy = dragImage ?? new DragProxy(); DragProxy.Proxify(_proxy); _xOffset = xOffset; _yOffset = yOffset; DragDropStage.Instance.AddChild(_proxy); // TODO: cleanup after the drag operaion var dragInitiatorGlobalBounds = dragInitiator.Parent.LocalToGlobal(dragInitiator.Position); _proxy.X = dragInitiatorGlobalBounds.X; _proxy.Y = dragInitiatorGlobalBounds.Y; //_proxy.Bounds = (Rectangle)dragInitiator.Transform.GlobalBounds.Clone(); _proxy.Visible = _proxyShouldBeVisible; _proxy.Alpha = imageAlpha; Offset = dragInitiatorGlobalBounds.Subtract(mouseEvent.GlobalPosition); if (_feedbackShouldBeVisible) ChangeCursorTo(CursorType.RejectDrop); /** * Subscribe to drag and mouse up events on system manager * */ SystemEventDispatcher.Instance.AddEventListener(MouseEvent.MOUSE_DRAG, OnMouseDrag); SystemEventDispatcher.Instance.AddEventListener(MouseEvent.MOUSE_UP, OnMouseUp); //DragEvent dragStartEvent = BuildEvent(DragEvent.DRAG_START); //_dragInitiator.DispatchEvent(dragStartEvent); }
protected override bool IsOurFocus(DisplayObject target) { return target == TextDisplay; }