| //////////////////////////////////////////////////////////////////////////////// |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one or more |
| // contributor license agreements. See the NOTICE file distributed with |
| // this work for additional information regarding copyright ownership. |
| // The ASF licenses this file to You under the Apache License, Version 2.0 |
| // (the "License"); you may not use this file except in compliance with |
| // the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| package com.flexcapacitor.tools { |
| import com.flexcapacitor.controller.Radiate; |
| import com.flexcapacitor.events.DragDropEvent; |
| import com.flexcapacitor.events.RadiateEvent; |
| import com.flexcapacitor.managers.layoutClasses.LayoutDebugHelper; |
| import com.flexcapacitor.model.IDocument; |
| import com.flexcapacitor.utils.DisplayObjectUtils; |
| import com.flexcapacitor.utils.DragManagerUtil; |
| import com.flexcapacitor.utils.supportClasses.ComponentDescription; |
| import com.flexcapacitor.utils.supportClasses.ISelectionGroup; |
| import com.flexcapacitor.utils.supportClasses.TargetSelectionGroup; |
| |
| import flash.display.DisplayObject; |
| import flash.display.DisplayObjectContainer; |
| import flash.display.Loader; |
| import flash.display.Sprite; |
| import flash.display.Stage; |
| import flash.events.Event; |
| import flash.events.IOErrorEvent; |
| import flash.events.KeyboardEvent; |
| import flash.events.MouseEvent; |
| import flash.events.SecurityErrorEvent; |
| import flash.geom.Point; |
| import flash.geom.Rectangle; |
| import flash.ui.Keyboard; |
| |
| import mx.core.EventPriority; |
| import mx.core.FlexGlobals; |
| import mx.core.FlexSprite; |
| import mx.core.IFlexDisplayObject; |
| import mx.core.ILayoutElement; |
| import mx.core.IUIComponent; |
| import mx.core.IVisualElement; |
| import mx.core.IVisualElementContainer; |
| import mx.core.UIComponent; |
| import mx.events.FlexEvent; |
| import mx.events.PropertyChangeEvent; |
| import mx.managers.ISystemManager; |
| import mx.managers.PopUpManager; |
| import mx.managers.SystemManager; |
| import mx.managers.SystemManagerGlobals; |
| |
| import spark.components.DataGrid; |
| import spark.components.Image; |
| import spark.components.List; |
| import spark.components.Scroller; |
| import spark.components.TextArea; |
| import spark.components.VideoPlayer; |
| import spark.components.supportClasses.GroupBase; |
| import spark.components.supportClasses.ItemRenderer; |
| import spark.components.supportClasses.ListBase; |
| import spark.core.IGraphicElement; |
| import spark.skins.spark.ListDropIndicator; |
| |
| /** |
| Alex Harui Tue, 04 Mar 2008 21:03:35 -0800 |
| |
| For the record, so there is no more guessing: |
| |
| |
| 1) The Application or WindowedApplication is not the top-level |
| window and does not parent popup and thus events from popups do not |
| bubble through the application |
| |
| 2) SystemManager is the top-level window, and all events from all |
| display objects bubble through the SM unless their propagation has been |
| stopped |
| |
| 3) Capture phase listeners on the SystemManager should get all |
| events for all child display objects |
| |
| 4) If no display object has focus, but the player does have focus, |
| then the Stage dispatches keyboard events which will not be caught by a |
| listener on SystemManager |
| |
| 5) Capture phase listeners on the Stage will not catch events |
| dispatched from the Stage, only events dispatched by children of the |
| Stage and thus if no display object has focus, there is no place to hook |
| a capture-phase listener that will catch the keyboard events dispatched |
| from the stage. |
| |
| |
| |
| This is why Rick's suggestion of both a capture and non-capture phase |
| listener on stage is correct. |
| |
| Stage.addEventListener( KeyboardEvent.KEY_DOWN, handleKeyDn, true ); |
| |
| Stage.addEventListener( KeyboardEvent.KEY_DOWN, handleKeyDn, false ); |
| * */ |
| |
| /** |
| * Finds and selects the item or items under the pointer. |
| * |
| * To do: |
| * - select item |
| * - select group |
| * - draw selection area |
| * - show resize handles |
| * - show property inspector |
| * - show selection option |
| * |
| * THERE ARE SECTIONS IN THIS CLASS THAT NEED TO BE REFACTORED |
| * |
| * */ |
| public class Selection extends FlexSprite implements ITool { |
| |
| |
| public function Selection() { |
| |
| } |
| |
| [Embed(source="assets/icons/tools/Selection.png")] |
| private var _icon:Class; |
| |
| public function get icon():Class { |
| return _icon; |
| } |
| |
| /** |
| * Reference to the current or last target. |
| * */ |
| public var lastTarget:Object; |
| |
| /** |
| * Sets to focus for keyboard events. |
| * */ |
| public var setFocusOnSelect:Boolean = true; |
| |
| /** |
| * When an item is deleted or removed the selection is drawn just off stage |
| * Set to true to clear the selection in this case |
| * */ |
| public var hideSelectionWhenOffStage:Boolean = true; |
| |
| private var _showSelection:Boolean = true; |
| |
| /** |
| * Show selection around target. |
| * */ |
| public function get showSelection():Boolean { |
| return _showSelection; |
| } |
| |
| /** |
| * @private |
| */ |
| public function set showSelection(value:Boolean):void { |
| _showSelection = value; |
| |
| if (value) { |
| if (lastTarget) { |
| drawSelection(lastTarget, toolLayer); |
| } |
| } |
| else { |
| clearSelection(); |
| } |
| } |
| |
| |
| public var targetSelectionGroup:ItemRenderer; |
| public var mouseLocationLines:IFlexDisplayObject = new ListDropIndicator(); |
| private var _showSelectionLabel:Boolean = false; |
| |
| public function get showSelectionLabel():Boolean { |
| return _showSelectionLabel; |
| } |
| |
| public function set showSelectionLabel(value:Boolean):void { |
| if (_showSelectionLabel==value) return; |
| |
| _showSelectionLabel = value; |
| |
| updateSelectionAroundTarget(lastTarget); |
| } |
| |
| private var _selectionBorderColor:uint = 0x2da6e9; |
| |
| public function get selectionBorderColor():uint { |
| return _selectionBorderColor; |
| } |
| |
| public function set selectionBorderColor(value:uint):void { |
| if (_selectionBorderColor==value) return; |
| |
| _selectionBorderColor = value; |
| |
| updateSelectionAroundTarget(lastTarget); |
| } |
| |
| public var showSelectionLabelOnDocument:Boolean = false; |
| public var showSelectionFill:Boolean = false; |
| public var showSelectionFillOnDocument:Boolean = false; |
| public var lastTargetCandidate:Object; |
| public var enableDrag:Boolean = true; |
| public var toolLayer:IVisualElementContainer; |
| public var updateOnUpdateComplete:Boolean = false; |
| |
| /** |
| * X and Y coordinates of dragged object relative to the target application |
| * */ |
| [Bindable] |
| public var dragLocation:String; |
| |
| /** |
| * Enable this tool. |
| * */ |
| public function enable():void { |
| radiate = Radiate.getInstance(); |
| |
| if (radiate.selectedDocument) { |
| updateDocument(radiate.selectedDocument); |
| } |
| |
| // handle events last so that we get correct size |
| radiate.addEventListener(RadiateEvent.DOCUMENT_CHANGE, documentChangeHandler, false, EventPriority.DEFAULT_HANDLER, true); |
| radiate.addEventListener(RadiateEvent.TARGET_CHANGE, targetChangeHandler, false, EventPriority.DEFAULT_HANDLER, true); |
| radiate.addEventListener(RadiateEvent.PROPERTY_CHANGED, propertyChangeHandler, false, EventPriority.DEFAULT_HANDLER, true); |
| radiate.addEventListener(RadiateEvent.SCALE_CHANGE, scaleChangeHandler, false, EventPriority.DEFAULT_HANDLER, true); |
| radiate.addEventListener(RadiateEvent.DOCUMENT_SIZE_CHANGE, scaleChangeHandler, false, EventPriority.DEFAULT_HANDLER, true); |
| } |
| |
| /** |
| * Disable this tool. |
| * */ |
| public function disable():void { |
| |
| removeTargetEventListeners(); |
| |
| clearSelection(); |
| } |
| |
| |
| /** |
| * What a mess. Trying to listen for keyboard events. |
| * One thing we could do is set the focus to the stage when the document is |
| * first loaded or when the user selects a document by clicking on it's tab |
| * */ |
| public function updateDocument(document:IDocument):void { |
| var stage:Stage; |
| |
| // remove listeners |
| if (targetApplication && targetApplication!=document) { |
| Object(targetApplication).removeEventListener(FlexEvent.UPDATE_COMPLETE, updateCompleteHandler); |
| |
| if ("systemManager" in targetApplication) { |
| stage = Object(targetApplication).systemManager.stage; |
| Object(targetApplication).systemManager.removeEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler); |
| //Object(targetApplication).systemManager.removeEventListener(KeyboardEvent.KEY_UP, keyUpHandler); |
| //Object(targetApplication).systemManager.removeEventListener(KeyboardEvent.KEY_DOWN, keyDownHandler, true); |
| //Object(targetApplication).stage.removeEventListener(KeyboardEvent.KEY_DOWN, keyDownHandler, false); |
| stage.removeEventListener(KeyboardEvent.KEY_DOWN, keyDownHandler, true); |
| //Object(targetApplication).stage.removeEventListener(KeyboardEvent.KEY_UP, keyUpHandler, false); |
| stage.removeEventListener(KeyboardEvent.KEY_UP, keyUpHandler, true); |
| } |
| } |
| |
| this.document = document; |
| targetApplication = document ? document.instance : null; |
| |
| // add listeners |
| if (targetApplication) { |
| Object(targetApplication).addEventListener(FlexEvent.UPDATE_COMPLETE, updateCompleteHandler, false, 0, true); |
| |
| if ("systemManager" in targetApplication) { |
| var systemManager1:ISystemManager = Object(targetApplication).systemManager; |
| stage = systemManager1.stage; |
| var toppestSystemManager:ISystemManager = SystemManagerGlobals.topLevelSystemManagers[0]; |
| |
| var topLevelApplication:Object = FlexGlobals.topLevelApplication; |
| var topSystemManager:ISystemManager = ISystemManager(topLevelApplication.systemManager); |
| var marshallPlanSystemManager:Object = topSystemManager.getImplementation("mx.managers.IMarshallPlanSystemManager"); |
| |
| if (marshallPlanSystemManager && marshallPlanSystemManager.useSWFBridge()) { |
| var sandBoxRoot:Object = Sprite(topSystemManager.getSandboxRoot()); |
| } |
| |
| |
| systemManager1.addEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler, false, 0, true); |
| |
| // get keyboard events |
| /*systemManager1.addEventListener(KeyboardEvent.KEY_DOWN, keyDownHandlerCapture, true, 1001, true); |
| systemManager1.addEventListener(KeyboardEvent.KEY_DOWN, keyDownHandler, false, 1001, true); |
| topSystemManager.addEventListener(KeyboardEvent.KEY_DOWN, keyDownHandlerTopSystemManager, false, 1001, true); |
| topSystemManager.addEventListener(KeyboardEvent.KEY_DOWN, keyDownHandlerTopSystemManager, true, 1001, true); |
| */ |
| //targetApplication.addEventListener(KeyboardEvent.KEY_DOWN, keyDownHandlerTopSystemManager, false, 0, true); |
| //targetApplication.addEventListener(KeyboardEvent.KEY_DOWN, keyDownHandlerTopSystemManager, true, 0, true); |
| stage.addEventListener(KeyboardEvent.KEY_DOWN, keyDownHandlerStage, true, 0, true); |
| stage.addEventListener(KeyboardEvent.KEY_UP, keyUpHandler, true, 0, true); |
| //targetApplication.stage.addEventListener(KeyboardEvent.KEY_DOWN, keyDownHandlerTopSystemManager, false, 0, true); |
| //targetApplication.stage.addEventListener(KeyboardEvent.KEY_UP, keyUpHandler, false, 0, true); |
| //systemManager1.addEventListener(KeyboardEvent.KEY_UP, keyUpHandler, false, 0, true); |
| |
| /* |
| EventPriority.CURSOR_MANAGEMENT; //200 |
| EventPriority.BINDING;//100 |
| EventPriority.EFFECT;//-100 |
| EventPriority.DEFAULT;// 0 |
| EventPriority.DEFAULT_HANDLER;//-50 |
| */ |
| } |
| } |
| |
| |
| |
| if (radiate && radiate.toolLayer) { |
| toolLayer = radiate.toolLayer; |
| } |
| |
| if (radiate && radiate.canvasBackground) { |
| canvasBackground = radiate.canvasBackground; |
| } |
| |
| if (radiate && radiate.canvasBackground && radiate.canvasBackground.parent) { |
| if (canvasBackgroundParent) { |
| canvasBackgroundParent.removeEventListener(PropertyChangeEvent.PROPERTY_CHANGE, handleScrollChanges); |
| } |
| canvasBackgroundParent = radiate.canvasBackground.parent; |
| canvasBackgroundParent.addEventListener(PropertyChangeEvent.PROPERTY_CHANGE, handleScrollChanges, false, 1000, true); |
| } |
| |
| if (radiate && radiate.canvasScroller) { |
| if (canvasScroller) { |
| |
| } |
| canvasScroller = radiate.canvasScroller; |
| canvasScroller.addEventListener(PropertyChangeEvent.PROPERTY_CHANGE, handleScrollChanges, false, 1000, true); |
| } |
| } |
| |
| /** |
| * Remove event listeners. |
| * |
| * THIS NEEDS TO BE REFACTORED |
| * */ |
| public function removeTargetEventListeners():void { |
| |
| if (lastTarget && lastTarget is Image) { |
| lastTarget.removeEventListener(FlexEvent.READY, setSelectionLaterHandler); |
| lastTarget.removeEventListener(Event.COMPLETE, setSelectionLaterHandler); |
| lastTarget.removeEventListener(IOErrorEvent.IO_ERROR, setSelectionLaterHandler); |
| lastTarget.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, setSelectionLaterHandler); |
| } |
| |
| if (targetApplication) { |
| Object(targetApplication).removeEventListener(FlexEvent.UPDATE_COMPLETE, updateCompleteHandler); |
| } |
| |
| if (targetApplication && "systemManager" in targetApplication) { |
| Object(targetApplication).systemManager.removeEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler); |
| Object(targetApplication).systemManager.stage.removeEventListener(KeyboardEvent.KEY_UP, keyUpHandler); |
| Object(targetApplication).systemManager.stage.removeEventListener(KeyboardEvent.KEY_DOWN, keyDownHandler, false); |
| Object(targetApplication).systemManager.stage.removeEventListener(KeyboardEvent.KEY_DOWN, keyDownHandler, true); |
| } |
| |
| radiate.removeEventListener(RadiateEvent.DOCUMENT_CHANGE, documentChangeHandler); |
| radiate.removeEventListener(RadiateEvent.TARGET_CHANGE, targetChangeHandler); |
| radiate.removeEventListener(RadiateEvent.PROPERTY_CHANGED, propertyChangeHandler); |
| |
| if (dragManagerInstance) { |
| dragManagerInstance.removeEventListener(DragDropEvent.DRAG_DROP, handleDragDrop); |
| dragManagerInstance.removeEventListener(DragDropEvent.DRAG_OVER, handleDragOver); |
| } |
| |
| |
| if (radiate.canvasBackground) { |
| canvasBackgroundParent.removeEventListener(PropertyChangeEvent.PROPERTY_CHANGE, handleScrollChanges); |
| } |
| |
| if (radiate.canvasScroller) { |
| canvasScroller.removeEventListener(PropertyChangeEvent.PROPERTY_CHANGE, handleScrollChanges); |
| } |
| } |
| |
| /** |
| * |
| * */ |
| protected function propertyChangeHandler(event:RadiateEvent):void { |
| updateSelectionAroundTarget(event.selectedItem); |
| } |
| |
| /** |
| * |
| * */ |
| protected function scaleChangeHandler(event:RadiateEvent):void { |
| updateSelectionAroundTarget(event.selectedItem); |
| } |
| |
| /** |
| * |
| * */ |
| protected function targetChangeHandler(event:RadiateEvent):void { |
| updateSelectionAroundTarget(event.selectedItem); |
| } |
| |
| /** |
| * |
| * */ |
| protected function documentChangeHandler(event:RadiateEvent):void { |
| clearSelection(); |
| updateDocument(IDocument(event.selectedItem)); |
| } |
| |
| /** |
| * Handle scroll position changes |
| */ |
| private function handleScrollChanges(event:PropertyChangeEvent):void { |
| if (event.source == event.target && event.property == "verticalScrollPosition") { |
| //trace(e.property, "changed to", e.newValue); |
| //drawSelection(radiate.target); |
| //Radiate.log.info("Selection scroll change"); |
| } |
| if (event.source == event.target && event.property == "horizontalScrollPosition") { |
| //trace(e.property, "changed to", e.newValue); |
| //drawSelection(radiate.target); |
| //Radiate.log.info("Selection scroll change"); |
| } |
| } |
| |
| /** |
| * Update complete event for target |
| * */ |
| public function updateCompleteHandler(event:FlexEvent):void { |
| |
| // this can go into an infinite loop if tool layer is causing update events |
| if (updateOnUpdateComplete) { |
| updateSelectionAroundTarget(event.currentTarget); |
| } |
| } |
| |
| /** |
| * Updates selection around the target |
| * */ |
| public function updateSelectionAroundTarget(target:Object):void { |
| |
| if (lastTarget && lastTarget is Image) { |
| lastTarget.removeEventListener(FlexEvent.READY, setSelectionLaterHandler); |
| lastTarget.removeEventListener(Event.COMPLETE, setSelectionLaterHandler); |
| lastTarget.removeEventListener(IOErrorEvent.IO_ERROR, setSelectionLaterHandler); |
| lastTarget.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, setSelectionLaterHandler); |
| } |
| |
| lastTarget = target; |
| |
| if (target && target is Image) { |
| target.addEventListener(FlexEvent.READY, setSelectionLaterHandler, false, 0, true); |
| target.addEventListener(Event.COMPLETE, setSelectionLaterHandler, false, 0, true); |
| target.addEventListener(IOErrorEvent.IO_ERROR, setSelectionLaterHandler, false, 0, true); |
| target.addEventListener(SecurityErrorEvent.SECURITY_ERROR, setSelectionLaterHandler, false, 0, true); |
| } |
| |
| |
| if (showSelection && |
| (target is IVisualElement || target is IGraphicElement)) { |
| |
| if (hideSelectionWhenOffStage && "stage" in target && target.stage==null) { |
| clearSelection() |
| } |
| else { |
| drawSelection(target, toolLayer); |
| } |
| |
| |
| } |
| else { |
| clearSelection(); |
| } |
| |
| } |
| |
| /** |
| * The radiate instance. |
| * */ |
| public var radiate:Radiate; |
| |
| /** |
| * Drag helper utility. |
| * */ |
| private var dragManagerInstance:DragManagerUtil; |
| |
| /** |
| * The document |
| * */ |
| public var document:IDocument; |
| |
| /** |
| * The application |
| * */ |
| public var targetApplication:Object; |
| |
| /** |
| * The background |
| * */ |
| public var canvasBackground:Object; |
| |
| /** |
| * The background parent |
| * */ |
| public var canvasBackgroundParent:Object; |
| |
| /** |
| * The background parent scroller |
| * */ |
| public var canvasScroller:Scroller; |
| |
| /** |
| * Layout debug helper. Used to get the visible rectangle of the selected item |
| * */ |
| public var layoutDebugHelper:LayoutDebugHelper; |
| |
| /** |
| * Add listeners to target |
| * */ |
| protected function mouseDownHandler(event:MouseEvent):void { |
| var point:Point = new Point(event.stageX, event.stageY); |
| var targetsUnderPoint:Array = FlexGlobals.topLevelApplication.getObjectsUnderPoint(point); |
| var componentTree:ComponentDescription; |
| var description:ComponentDescription; |
| var target:Object = event.target; |
| var originalTarget:Object = event.target; |
| var items:Array = []; |
| var length:int; |
| |
| |
| |
| /*radiate = Radiate.getInstance(); |
| targetApplication = radiate.document;*/ |
| |
| // test url for remote image: |
| // http://www.google.com/intl/en_com/images/srpr/logo3w.png |
| // file:///Users/monkeypunch/Documents/Adobe%20Flash%20Builder%2045/Radii8/src/assets/images/eye.png |
| |
| // clicked outside of this container. is there a way to prevent hearing |
| // events from everywhere? stage sandboxroot? |
| if (!targetApplication || !Object(targetApplication).contains(target)) { |
| //trace("does not contain"); |
| return; |
| } |
| |
| // clicked on background area |
| if (target==canvasBackground || target==canvasBackgroundParent) { |
| radiate.setTarget(targetApplication, true); |
| return; |
| } |
| |
| |
| // check if target is loader |
| if (target is Loader) { |
| //Error: Request for resource at http://www.google.com/intl/en_com/images/srpr/logo3w.png by requestor from http://www.radii8.com/debug-build/RadiateExample.swf is denied due to lack of policy file permissions. |
| |
| //*** Security Sandbox Violation *** |
| // Connection to http://www.google.com/intl/en_com/images/srpr/logo3w.png halted - not permitted from http://www.radii8.com/debug-build/RadiateExample.swf |
| targetsUnderPoint.push(target); |
| } |
| |
| length = targetsUnderPoint.length; |
| targetsUnderPoint = targetsUnderPoint.reverse(); |
| |
| // loop through items under point until we find one on the *component* tree |
| componentTree = radiate.selectedDocument.componentDescription; |
| |
| componentTreeLoop: |
| for (var i:int;i<length;i++) { |
| target = targetsUnderPoint[i]; |
| |
| if (!targetApplication.contains(DisplayObject(target))) { |
| continue; |
| } |
| |
| description = DisplayObjectUtils.getComponentFromDisplayObject(DisplayObject(target), componentTree); |
| |
| if (description) { |
| target = description.instance; |
| break; |
| } |
| } |
| |
| |
| if (target && enableDrag) { |
| |
| //Radiate.log.info("Selection Mouse down"); |
| |
| // select target on mouse up or drag drop whichever comes first |
| target.addEventListener(MouseEvent.MOUSE_UP, mouseUpHandler, false, 0, true); |
| |
| if (target!=targetApplication) { |
| |
| // listen for drag |
| if (!dragManagerInstance) { |
| dragManagerInstance = new DragManagerUtil(); |
| } |
| |
| //target.visible = false; |
| dragManagerInstance.listenForDragBehavior(target as IUIComponent, document, event); |
| dragManagerInstance.addEventListener(DragDropEvent.DRAG_DROP, handleDragDrop, false, 0, true); |
| dragManagerInstance.addEventListener(DragDropEvent.DRAG_OVER, handleDragOver, false, 0, true); |
| } |
| } |
| else if (target && !enableDrag) { |
| // select target right away |
| if (radiate && radiate.target!=target) { |
| radiate.setTarget(target, true); |
| } |
| |
| // draw selection rectangle |
| if (showSelection) { |
| updateSelectionAroundTarget(target); |
| } |
| } |
| |
| } |
| |
| /** |
| * Handles drag over |
| * */ |
| protected function handleDragOver(event:DragDropEvent):void { |
| //Radiate.log.info("Selection Drag Drop"); |
| var target:Object = dragManagerInstance.draggedItem; |
| // trace("Drag over") |
| dragLocation = dragManagerInstance.dropTargetLocation; |
| |
| |
| } |
| |
| /** |
| * Handles mouse up event on the target |
| * */ |
| protected function handleDragDrop(event:DragDropEvent):void { |
| // select target |
| //radiate.target = event.draggedItem; |
| //Radiate.log.info("Selection Drag Drop"); |
| |
| var target:Object = dragManagerInstance.draggedItem; |
| |
| |
| |
| // clean up |
| if (target.hasEventListener(MouseEvent.MOUSE_UP)) { |
| //Radiate.log.info("3 has event listener"); |
| } |
| |
| target.removeEventListener(MouseEvent.MOUSE_UP, mouseUpHandler); |
| |
| if (target.hasEventListener(MouseEvent.MOUSE_UP)) { |
| //Radiate.log.info("4 has event listener"); |
| } |
| else { |
| //Radiate.log.info("listener removed"); |
| } |
| |
| //Radiate.log.info("End Selection Drag Drop"); |
| |
| // select target |
| if (radiate.target!=target) { |
| radiate.setTarget(target, true); |
| } |
| |
| if (showSelection) { |
| updateSelectionAroundTarget(target); |
| } |
| |
| // set focus to component to handle keyboard events |
| if (setFocusOnSelect && target is UIComponent){ |
| target.setFocus(); |
| } |
| |
| dragLocation = ""; |
| |
| dragManagerInstance.removeEventListener(DragDropEvent.DRAG_DROP, handleDragDrop); |
| dragManagerInstance.removeEventListener(DragDropEvent.DRAG_OVER, handleDragOver); |
| } |
| |
| /** |
| * Handle mouse up on the stage |
| * */ |
| protected function mouseUpHandler(event:MouseEvent):void { |
| var target:Object = event.currentTarget; |
| //Radiate.log.info("Selection Mouse up"); |
| |
| if (target is List) { |
| //target.dragEnabled = true; // restore drag and drop if it was enabled |
| } |
| |
| target.visible = true; |
| |
| // clean up |
| if (target.hasEventListener(MouseEvent.MOUSE_UP)) { |
| //Radiate.log.info("1 has event listener"); |
| } |
| |
| target.removeEventListener(MouseEvent.MOUSE_UP, mouseUpHandler); |
| |
| if (target.hasEventListener(MouseEvent.MOUSE_UP)) { |
| //Radiate.log.info("2 has event listener"); |
| } |
| else { |
| //Radiate.log.info("listener removed"); |
| } |
| |
| //Radiate.log.info("End Selection Mouse Up"); |
| |
| // select target |
| if (radiate.target!=target) { |
| radiate.setTarget(target, true); |
| } |
| |
| // draw selection rectangle |
| if (showSelection) { |
| updateSelectionAroundTarget(target); |
| } |
| |
| // draw selection rectangle |
| if (setFocusOnSelect && target is UIComponent) { |
| target.setFocus(); |
| } |
| } |
| |
| /** |
| * Prevent system manager from taking our events. |
| * This seems to be the only handler that is working of the three. |
| * */ |
| private function keyDownHandlerStage(event:KeyboardEvent):void |
| { |
| //Radiate.log.info("Key down: " + event.keyCode); |
| switch (event.keyCode) |
| { |
| case Keyboard.UP: |
| case Keyboard.DOWN: |
| case Keyboard.PAGE_UP: |
| case Keyboard.PAGE_DOWN: |
| case Keyboard.HOME: |
| case Keyboard.END: |
| case Keyboard.LEFT: |
| case Keyboard.RIGHT: |
| case Keyboard.ENTER: |
| case Keyboard.DELETE: |
| { |
| |
| // we want to prevent document scrollers from reacting on keyboard events |
| // so we stop the propagation |
| if (targetApplication && DisplayObjectContainer(targetApplication).contains(event.target as DisplayObject)) { |
| event.stopImmediatePropagation(); |
| } |
| //Radiate.log.info("Canceling key down"); |
| } |
| case Keyboard.Z: |
| { |
| if ((targetApplication as DisplayObjectContainer).contains(event.target as DisplayObject)) { |
| if (event.keyCode==Keyboard.Z && event.ctrlKey && !event.shiftKey) { |
| Radiate.undo(true); |
| } |
| else if (event.keyCode==Keyboard.Z && event.ctrlKey && event.shiftKey) { |
| |
| Radiate.redo(true); |
| } |
| } |
| } |
| case Keyboard.C: |
| { |
| if ((targetApplication as DisplayObjectContainer).contains(event.target as DisplayObject)) { |
| if (event.keyCode==Keyboard.C) { |
| radiate.copyItem(radiate.target); |
| } |
| } |
| } |
| case Keyboard.V: |
| { |
| if ((targetApplication as DisplayObjectContainer).contains(event.target as DisplayObject)) { |
| if (event.keyCode==Keyboard.V) { |
| Radiate.log.info("Paste not implemented"); |
| //radiate.pasteItem(radiate.target); |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * ?????? NOT USED ?????? |
| * Prevent system manager from taking our events |
| * */ |
| private function keyDownHandler(event:KeyboardEvent):void |
| { |
| |
| // ?????? NOT USED ?????? |
| switch (event.keyCode) |
| { |
| case Keyboard.UP: |
| case Keyboard.DOWN: |
| case Keyboard.PAGE_UP: |
| case Keyboard.PAGE_DOWN: |
| case Keyboard.HOME: |
| case Keyboard.END: |
| case Keyboard.LEFT: |
| case Keyboard.RIGHT: |
| case Keyboard.ENTER: |
| case Keyboard.DELETE: |
| { |
| // ?????? NOT USED ?????? |
| if (targetApplication && DisplayObjectContainer(targetApplication).contains(event.target as DisplayObject)) { |
| event.stopImmediatePropagation(); |
| } |
| //event.stopImmediatePropagation(); |
| //Radiate.log.info("Canceling key down"); |
| } |
| } |
| } |
| |
| /** |
| * ????? NOT USED ???? |
| * Prevent system manager from taking our events |
| * */ |
| private function keyDownHandlerCapture(event:KeyboardEvent):void |
| { |
| |
| // ?????? NOT USED ?????? |
| switch (event.keyCode) |
| { |
| case Keyboard.UP: |
| case Keyboard.DOWN: |
| case Keyboard.PAGE_UP: |
| case Keyboard.PAGE_DOWN: |
| case Keyboard.HOME: |
| case Keyboard.END: |
| case Keyboard.LEFT: |
| case Keyboard.RIGHT: |
| case Keyboard.ENTER: |
| case Keyboard.DELETE: |
| { |
| |
| // ?????? NOT USED ?????? |
| if (targetApplication && DisplayObjectContainer(targetApplication).contains(event.target as DisplayObject)) { |
| event.stopImmediatePropagation(); |
| } |
| //event.stopImmediatePropagation(); |
| //Radiate.log.info("Canceling key down"); |
| } |
| } |
| } |
| |
| /** |
| * Handle keyboard position changes |
| * */ |
| protected function keyUpHandler(event:KeyboardEvent):void { |
| var changes:Array = []; |
| var constant:int = event.shiftKey ? 10 : 1; |
| var index:int; |
| var applicable:Boolean; |
| |
| // check that the target is in the target application |
| if (targetApplication && |
| (targetApplication.contains(event.currentTarget) || |
| targetApplication.contains(event.target))) { |
| applicable = true; |
| } |
| else { |
| return; |
| } |
| //Radiate.log.info("Selection key up"); |
| if (radiate && radiate.targets.length>0) { |
| applicable = true; |
| } |
| |
| if (event.keyCode==Keyboard.LEFT) { |
| |
| for (;index<radiate.targets.length;index++) { |
| changes.push(radiate.targets[index].x-constant); |
| } |
| |
| Radiate.moveElement(radiate.targets, radiate.targets[0].parent, ["x"], null, changes); |
| } |
| else if (event.keyCode==Keyboard.RIGHT) { |
| for (;index<radiate.targets.length;index++) { |
| changes.push(radiate.targets[index].x+constant); |
| } |
| |
| Radiate.moveElement(radiate.targets, radiate.targets[0].parent, ["x"], null, changes); |
| } |
| else if (event.keyCode==Keyboard.UP) { |
| for (;index<radiate.targets.length;index++) { |
| changes.push(radiate.targets[index].y-constant); |
| } |
| |
| Radiate.moveElement(radiate.targets, radiate.targets[0].parent, ["y"], null, changes); |
| } |
| else if (event.keyCode==Keyboard.DOWN) { |
| for (;index<radiate.targets.length;index++) { |
| changes.push(radiate.targets[index].y+constant); |
| } |
| |
| Radiate.moveElement(radiate.targets, radiate.targets[0].parent, ["y"], null, changes); |
| } |
| else if (event.keyCode==Keyboard.BACKSPACE || event.keyCode==Keyboard.DELETE) { |
| |
| Radiate.removeElement(radiate.targets); |
| } |
| else if (event.keyCode==Keyboard.Z && event.ctrlKey && !event.shiftKey) { |
| Radiate.undo(true); |
| } |
| else if (event.keyCode==Keyboard.Z && event.ctrlKey && event.shiftKey) { |
| |
| Radiate.redo(true); |
| } |
| |
| if (applicable) { |
| event.stopImmediatePropagation(); |
| event.stopPropagation(); |
| event.preventDefault(); |
| } |
| } |
| |
| /** |
| * Show selection box on target change |
| * */ |
| public var showSelectionRectangle:Boolean = true; |
| |
| /** |
| * Clears the outline around a target display object |
| * */ |
| public function clearSelection():void { |
| |
| if (targetSelectionGroup) { |
| targetSelectionGroup.visible = false; |
| } |
| } |
| |
| /** |
| * Draws outline around target display object. |
| * Trying to add support to add different types of selection rectangles. |
| * */ |
| public function drawSelection(target:Object, selection:Object = null):void { |
| var rectangle:Rectangle; |
| var selectionGroup:ISelectionGroup; |
| |
| // creates an instance of the bounding box that will be shown around the drop target |
| if (!targetSelectionGroup) { |
| targetSelectionGroup = new TargetSelectionGroup(); |
| } |
| |
| if (targetSelectionGroup) { |
| //targetSelectionGroup.mouseEnabled = false; |
| //targetSelectionGroup.mouseChildren = false; |
| selectionGroup = targetSelectionGroup as ISelectionGroup; |
| |
| if (selectionGroup) { |
| selectionGroup.showSelectionFill = showSelectionFill; |
| selectionGroup.showSelectionFillOnDocument = showSelectionFillOnDocument; |
| selectionGroup.showSelectionLabel = showSelectionLabel; |
| selectionGroup.showSelectionLabelOnDocument = showSelectionLabelOnDocument; |
| selectionGroup.selectionBorderColor = selectionBorderColor; |
| |
| } |
| } |
| |
| // get bounds |
| if (!target) { |
| |
| // set values to zero |
| if (!rectangle) { |
| rectangle = new Rectangle(); |
| } |
| |
| // hide selection group |
| if (targetSelectionGroup.visible) { |
| targetSelectionGroup.visible = false; |
| } |
| } |
| else { |
| // add to tools layer |
| if (selection && selection is IVisualElementContainer) { |
| IVisualElementContainer(selection).addElement(targetSelectionGroup); |
| targetSelectionGroup.validateNow(); |
| } |
| |
| // get and set selection rectangle |
| sizeSelectionGroup(target, selection as DisplayObject); |
| |
| |
| // validate |
| if (selection && selection is IVisualElementContainer) { |
| //IVisualElementContainer(selection).addElement(targetSelectionGroup); |
| targetSelectionGroup.validateNow(); |
| targetSelectionGroup.includeInLayout = false; |
| } |
| |
| // draw the selection rectangle only if it's changed |
| else if (lastTargetCandidate!=target) { |
| var topLevelApplication:Object = FlexGlobals.topLevelApplication; |
| // if selection is offset then check if using system manager sandbox root or top level root |
| var systemManager:ISystemManager = ISystemManager(topLevelApplication.systemManager); |
| |
| // no types so no dependencies |
| var marshallPlanSystemManager:Object = systemManager.getImplementation("mx.managers.IMarshallPlanSystemManager"); |
| var targetCoordinateSpace:DisplayObject; |
| |
| if (marshallPlanSystemManager && marshallPlanSystemManager.useSWFBridge()) { |
| targetCoordinateSpace = Sprite(systemManager.getSandboxRoot()); |
| } |
| else { |
| targetCoordinateSpace = Sprite(topLevelApplication); |
| } |
| |
| /* |
| var documentSpace:DisplayObject = Radiate.instance.document as DisplayObject; |
| |
| if (documentSpace) { |
| targetCoordinateSpace = documentSpace; |
| }*/ |
| |
| // Error occurs when targetCoordinateSpace is the document (loaded application) |
| // Error: removeChild() is not available in this class. |
| // Instead, use removeElement() or modify the skin, if you have one. |
| // at spark.components::Group/removeChild()[E:\dev\4.y\frameworks\projects\spark\src\spark\components\Group.as:2136] |
| // |
| // Solution: |
| // |
| // probably use toplevelapplication |
| |
| // show selection / bounding box |
| PopUpManager.addPopUp(targetSelectionGroup, targetCoordinateSpace); |
| targetSelectionGroup.validateNow(); |
| } |
| } |
| } |
| |
| /** |
| * Sets the selection rectangle to the size of the target. |
| * */ |
| public function sizeSelectionGroup(target:Object, targetCoordinateSpace:DisplayObject = null, localTargetSpace:Boolean = true):void { |
| var rectangle:Rectangle; |
| var showContentSize:Boolean = false; |
| var isEmbeddedCoordinateSpace:Boolean; |
| var isTargetInvalid:Boolean; |
| |
| if (!layoutDebugHelper) { |
| layoutDebugHelper = new LayoutDebugHelper(); |
| } |
| |
| // get content width and height |
| if (target is GroupBase) { |
| if (!targetCoordinateSpace) targetCoordinateSpace = target.parent; |
| //rectangle = GroupBase(target).getBounds(target.parent); |
| rectangle = GroupBase(target).getBounds(targetCoordinateSpace); |
| |
| // size and position fill |
| targetSelectionGroup.width = showContentSize ? GroupBase(target).contentWidth : rectangle.size.x -1; |
| targetSelectionGroup.height = showContentSize ? GroupBase(target).contentHeight : rectangle.size.y -1; |
| |
| if (!localTargetSpace) { |
| rectangle = GroupBase(target).getVisibleRect(target.parent); |
| } |
| |
| targetSelectionGroup.x = rectangle.x; |
| targetSelectionGroup.y = rectangle.y; |
| //trace("target is groupbase"); |
| } |
| else if (target is Image) { |
| |
| if (targetCoordinateSpace && |
| "systemManager" in targetCoordinateSpace && |
| Object(targetCoordinateSpace).systemManager!=target.systemManager) { |
| isEmbeddedCoordinateSpace = true; |
| } |
| |
| if (!targetCoordinateSpace ) targetCoordinateSpace = target.parent; |
| |
| |
| // if target is IMAGE it can be sized to 6711034.2 width or height at times!!! 6710932.2 |
| // possibly because it is not ready. there is a flag _ready that is false |
| // also sourceWidth and sourceHeight are NaN at first |
| |
| /*trace("targetCoordinateSpace="+Object(targetCoordinateSpace).id); |
| trace("targetCoordinateSpace owner="+Object(targetCoordinateSpace).owner.id); |
| trace("x=" + target.x); |
| trace("y=" + target.y); |
| trace("w=" + target.width); |
| trace("h=" + target.height);*/ |
| //if (!localTargetSpace) { |
| /* rectangle = UIComponent(target).getVisibleRect(); |
| rectangle = UIComponent(target).getVisibleRect(targetCoordinateSpace); |
| rectangle = UIComponent(target).getVisibleRect(target.parent); |
| rectangle = UIComponent(target).getVisibleRect(targetApplication.parent); |
| rectangle = UIComponent(target).getVisibleRect(Object(targetCoordinateSpace).owner); |
| rectangle = UIComponent(target).getVisibleRect(targetCoordinateSpace.parent); |
| */ |
| target.validateNow(); |
| |
| rectangle = UIComponent(target).getBounds(targetCoordinateSpace); |
| |
| if (rectangle.width==0 || |
| rectangle.height==0 || |
| rectangle.x>100000 || |
| rectangle.y>100000) { |
| |
| //Radiate.log.info("Image not returning correct bounds"); |
| /* |
| target.addEventListener(FlexEvent.READY, setSelectionLaterHandler, false, 0, true); |
| target.addEventListener(Event.COMPLETE, setSelectionLaterHandler, false, 0, true); |
| target.addEventListener(IOErrorEvent.IO_ERROR, setSelectionLaterHandler, false, 0, true); |
| target.addEventListener(SecurityErrorEvent.SECURITY_ERROR, setSelectionLaterHandler, false, 0, true); |
| */ |
| //target.imageDisplay.addEventListener(FlexEvent.READY, setSelectionLaterHandler, false, 0, true); |
| //target.imageDisplay.addEventListener(Event.COMPLETE, setSelectionLaterHandler, false, 0, true); |
| |
| // size and position fill |
| //targetSelectionGroup.width = 0;//rectangle.width;//UIComponent(target).getLayoutBoundsWidth(); |
| //targetSelectionGroup.height = 0;//rectangle.height; // UIComponent(target).getLayoutBoundsHeight(); |
| //targetSelectionGroup.x = 0;//rectangle.x; |
| //targetSelectionGroup.y = 0;//rectangle.y; |
| isTargetInvalid = true; |
| } |
| else { |
| |
| /*rectangle = UIComponent(target).getBounds(target.parent); |
| rectangle = UIComponent(target).getBounds(target.owner); |
| rectangle = UIComponent(target).getBounds(targetCoordinateSpace.parent); |
| rectangle = UIComponent(target).getBounds(null);*/ |
| //} |
| //else { |
| |
| /*rectangle = UIComponent(target).getBounds(targetCoordinateSpace); |
| rectangle = UIComponent(target).getBounds(target.parent); |
| rectangle = UIComponent(target).getBounds(targetApplication as DisplayObject); |
| rectangle = UIComponent(target).getBounds(targetApplication.parent); |
| var s:Number = UIComponent(target).getLayoutBoundsWidth(); |
| s= UIComponent(target).getLayoutBoundsHeight(); |
| s= UIComponent(target).getLayoutBoundsX(); |
| s= UIComponent(target).getLayoutBoundsY();*/ |
| //} |
| |
| // size and position fill |
| targetSelectionGroup.width = rectangle.width -1;//UIComponent(target).getLayoutBoundsWidth(); |
| targetSelectionGroup.height = rectangle.height-1; // UIComponent(target).getLayoutBoundsHeight(); |
| //rectangle = UIComponent(target).getVisibleRect(target.parent); // get correct x and y |
| targetSelectionGroup.x = rectangle.x; |
| targetSelectionGroup.y = rectangle.y; |
| } |
| |
| } |
| // get target bounds |
| else if (target is UIComponent) { |
| var targetRectangle:Rectangle = layoutDebugHelper.getRectangleBounds(target, toolLayer); |
| layoutDebugHelper.addElement(target as ILayoutElement); |
| // systemManager = SystemManagerGlobals.topLevelSystemManagers[0]; |
| |
| if (!targetCoordinateSpace) targetCoordinateSpace = target.parent; |
| |
| if (!localTargetSpace) { |
| rectangle = UIComponent(target).getVisibleRect(targetCoordinateSpace); |
| } |
| else { |
| // if target is IMAGE it can be sized to 6711034.2 width or height at times!!! 6710932.2 |
| rectangle = UIComponent(target).getBounds(targetCoordinateSpace); |
| } |
| |
| // this is working the best so far - possibly use this instead of other code |
| if (target is ListBase || target is TextArea || target is DataGrid || target is VideoPlayer) { |
| // size and position fill |
| targetSelectionGroup.width = targetRectangle.width; |
| targetSelectionGroup.height = targetRectangle.height; |
| //rectangle = UIComponent(target).getVisibleRect(target.parent); // get correct x and y |
| targetSelectionGroup.x = targetRectangle.x; |
| targetSelectionGroup.y = targetRectangle.y; |
| } |
| else { |
| // size and position fill |
| targetSelectionGroup.width = rectangle.width -1; |
| targetSelectionGroup.height = rectangle.height -1; |
| //rectangle = UIComponent(target).getVisibleRect(target.parent); // get correct x and y |
| targetSelectionGroup.x = rectangle.x; |
| targetSelectionGroup.y = rectangle.y; |
| } |
| //trace("target is uicomponent"); |
| } |
| // get target bounds |
| else if (target is IGraphicElement) { |
| if (!targetCoordinateSpace) targetCoordinateSpace = target.parent; |
| |
| /*if (!localTargetSpace) { |
| rectangle = IGraphicElement(target).getLayoutBoundsHeight(); |
| } |
| else { |
| rectangle = IGraphicElement(target).getBounds(targetCoordinateSpace); |
| }*/ |
| |
| // size and position fill |
| targetSelectionGroup.width = IGraphicElement(target).getLayoutBoundsWidth(); |
| targetSelectionGroup.height = IGraphicElement(target).getLayoutBoundsHeight(); |
| //rectangle = UIComponent(target).getVisibleRect(target.parent); // get correct x and y |
| targetSelectionGroup.x = IGraphicElement(target).getLayoutBoundsX(); |
| targetSelectionGroup.y = IGraphicElement(target).getLayoutBoundsY(); |
| //trace("target is uicomponent"); |
| } |
| |
| else { |
| if (!localTargetSpace) { |
| rectangle = DisplayObject(target).getBounds(targetCoordinateSpace); |
| } |
| else { |
| rectangle = DisplayObject(target).getBounds(targetCoordinateSpace); |
| } |
| |
| // size and position fill |
| targetSelectionGroup.width = rectangle.width-1; |
| targetSelectionGroup.height = rectangle.height-1; |
| targetSelectionGroup.x = rectangle.x; |
| targetSelectionGroup.y = rectangle.y; |
| //trace("target is not uicomponent"); |
| } |
| |
| // we set to the target so we can display target name and size in label above selection |
| targetSelectionGroup.data = target; |
| |
| |
| // unhide target selection group |
| if (isTargetInvalid) { |
| targetSelectionGroup.visible = false; |
| } |
| |
| else if (!targetSelectionGroup.visible) { |
| targetSelectionGroup.visible = true; |
| } |
| } |
| |
| /** |
| * Sets the selection rectangle to the size of the target. |
| * */ |
| public function sizeSelectionGroup2(target:Object, targetSpace:DisplayObject = null, localTargetSpace:Boolean = true):void { |
| var toolRectangle:Rectangle; |
| var showContentSize:Boolean = false; |
| var isEmbeddedCoordinateSpace:Boolean; |
| var isTargetInvalid:Boolean; |
| var toolLayer:DisplayObject = targetSpace; |
| var targetCoordinateSpace:DisplayObject = targetSpace; |
| var globalRectangle:Rectangle; |
| var visibleRectangle:Rectangle; |
| var rectangle:Rectangle; |
| |
| // get content width and height |
| if (target is GroupBase) { |
| |
| var topLevelApplication:Object = FlexGlobals.topLevelApplication; |
| // if selection is offset then check if using system manager sandbox root or top level root |
| var systemManager:ISystemManager = ISystemManager(topLevelApplication.systemManager); |
| |
| // no types so no dependencies |
| var marshallPlanSystemManager:Object = systemManager.getImplementation("mx.managers.IMarshallPlanSystemManager"); |
| |
| if (marshallPlanSystemManager && marshallPlanSystemManager.useSWFBridge()) { |
| targetCoordinateSpace = Sprite(systemManager.getSandboxRoot()); |
| } |
| else { |
| targetCoordinateSpace = Sprite(topLevelApplication); |
| } |
| |
| |
| if (!targetSpace) { |
| targetSpace = target.parent; |
| } |
| |
| globalRectangle = GroupBase(target).getBounds(targetCoordinateSpace); |
| toolRectangle = GroupBase(target).getBounds(toolLayer); |
| |
| /*trace("toollayer.x="+targetSpace.x); |
| trace("toollayer.y="+targetSpace.y);*/ |
| /* |
| var newPoint:Point = DisplayObject(target).globalToLocal(toolRectangle.topLeft); |
| var newPoint2:Point = DisplayObject(target).localToGlobal(toolRectangle.topLeft); |
| var newPoint:Point = DisplayObject(target.parent).globalToLocal(toolRectangle.topLeft); |
| var newPoint2:Point = DisplayObject(target.parent).localToGlobal(toolRectangle.topLeft); |
| var newPoint:Point = DisplayObject(targetSpace).globalToLocal(toolRectangle.topLeft); |
| var newPoint2:Point = DisplayObject(targetSpace).localToGlobal(toolRectangle.topLeft); |
| var newPoint:Point = DisplayObject(targetSpace).globalToLocal(new Point()); |
| var newPoint2:Point = DisplayObject(targetSpace).localToGlobal(new Point()); |
| */ |
| //rectangle = GroupBase(target).getBounds(target.parent); |
| |
| if (true) { |
| visibleRectangle = GroupBase(target).getVisibleRect(toolLayer); |
| } |
| |
| var targetWidth:Number; |
| var targetHeight:Number; |
| |
| if (toolRectangle.x<0) { |
| targetWidth = toolRectangle.width+toolRectangle.x; |
| } |
| else { |
| targetWidth = toolRectangle.width-1; |
| } |
| |
| if (toolRectangle.y<0) { |
| targetHeight = toolRectangle.height+toolRectangle.y; |
| } |
| else { |
| targetHeight = toolRectangle.height-1; |
| } |
| |
| // size and position fill |
| targetSelectionGroup.width = showContentSize ? GroupBase(target).contentWidth : toolRectangle.width; |
| targetSelectionGroup.height = showContentSize ? GroupBase(target).contentHeight : toolRectangle.height; |
| targetSelectionGroup.width = showContentSize ? GroupBase(target).contentWidth : targetWidth; |
| targetSelectionGroup.height = showContentSize ? GroupBase(target).contentHeight : targetHeight; |
| |
| if (!localTargetSpace) { |
| visibleRectangle = GroupBase(target).getVisibleRect(toolLayer); |
| } |
| |
| targetSelectionGroup.x = toolRectangle.x<0? -1:toolRectangle.x; |
| targetSelectionGroup.y = toolRectangle.y<0? -1:toolRectangle.y; |
| //targetSelectionGroup.x = -1;//toolRectangle.x; |
| //targetSelectionGroup.y = -1;//toolRectangle.y; |
| //trace("target is groupbase"); |
| } |
| else if (target is Image) { |
| |
| if (targetCoordinateSpace && "systemManager" in targetCoordinateSpace |
| && Object(targetCoordinateSpace).systemManager!=target.systemManager) { |
| isEmbeddedCoordinateSpace = true; |
| } |
| |
| if (!targetCoordinateSpace ) targetCoordinateSpace = target.parent; |
| |
| |
| // if target is IMAGE it can be sized to 6711034.2 width or height at times!!! 6710932.2 |
| // possibly because it is not ready. there is a flag _ready that is false |
| // also sourceWidth and sourceHeight are NaN at first |
| |
| trace("targetCoordinateSpace="+Object(targetCoordinateSpace).id); |
| trace("targetCoordinateSpace owner="+Object(targetCoordinateSpace).owner.id); |
| trace("x=" + target.x); |
| trace("y=" + target.y); |
| trace("w=" + target.width); |
| trace("h=" + target.height); |
| //if (!localTargetSpace) { |
| /* rectangle = UIComponent(target).getVisibleRect(); |
| rectangle = UIComponent(target).getVisibleRect(targetCoordinateSpace); |
| rectangle = UIComponent(target).getVisibleRect(target.parent); |
| rectangle = UIComponent(target).getVisibleRect(targetApplication.parent); |
| rectangle = UIComponent(target).getVisibleRect(Object(targetCoordinateSpace).owner); |
| rectangle = UIComponent(target).getVisibleRect(targetCoordinateSpace.parent); |
| */ |
| target.validateNow(); |
| |
| rectangle = UIComponent(target).getBounds(targetCoordinateSpace); |
| |
| if (rectangle.width==0 || rectangle.height==0 |
| || rectangle.x>100000 || rectangle.y>100000) { |
| |
| //Radiate.log.info("Image not returning correct bounds"); |
| /* |
| target.addEventListener(FlexEvent.READY, setSelectionLaterHandler, false, 0, true); |
| target.addEventListener(Event.COMPLETE, setSelectionLaterHandler, false, 0, true); |
| target.addEventListener(IOErrorEvent.IO_ERROR, setSelectionLaterHandler, false, 0, true); |
| target.addEventListener(SecurityErrorEvent.SECURITY_ERROR, setSelectionLaterHandler, false, 0, true); |
| */ |
| //target.imageDisplay.addEventListener(FlexEvent.READY, setSelectionLaterHandler, false, 0, true); |
| //target.imageDisplay.addEventListener(Event.COMPLETE, setSelectionLaterHandler, false, 0, true); |
| |
| // size and position fill |
| //targetSelectionGroup.width = 0;//rectangle.width;//UIComponent(target).getLayoutBoundsWidth(); |
| //targetSelectionGroup.height = 0;//rectangle.height; // UIComponent(target).getLayoutBoundsHeight(); |
| //targetSelectionGroup.x = 0;//rectangle.x; |
| //targetSelectionGroup.y = 0;//rectangle.y; |
| isTargetInvalid = true; |
| } |
| else { |
| |
| /*rectangle = UIComponent(target).getBounds(target.parent); |
| rectangle = UIComponent(target).getBounds(target.owner); |
| rectangle = UIComponent(target).getBounds(targetCoordinateSpace.parent); |
| rectangle = UIComponent(target).getBounds(null);*/ |
| //} |
| //else { |
| |
| /*rectangle = UIComponent(target).getBounds(targetCoordinateSpace); |
| rectangle = UIComponent(target).getBounds(target.parent); |
| rectangle = UIComponent(target).getBounds(targetApplication as DisplayObject); |
| rectangle = UIComponent(target).getBounds(targetApplication.parent); |
| var s:Number = UIComponent(target).getLayoutBoundsWidth(); |
| s= UIComponent(target).getLayoutBoundsHeight(); |
| s= UIComponent(target).getLayoutBoundsX(); |
| s= UIComponent(target).getLayoutBoundsY();*/ |
| //} |
| |
| // size and position fill |
| targetSelectionGroup.width = rectangle.width;//UIComponent(target).getLayoutBoundsWidth(); |
| targetSelectionGroup.height = rectangle.height; // UIComponent(target).getLayoutBoundsHeight(); |
| //rectangle = UIComponent(target).getVisibleRect(target.parent); // get correct x and y |
| targetSelectionGroup.x = rectangle.x; |
| targetSelectionGroup.y = rectangle.y; |
| } |
| |
| } |
| // get target bounds |
| else if (target is UIComponent) { |
| if (!targetCoordinateSpace) { |
| targetCoordinateSpace = target.parent; |
| } |
| |
| if (!localTargetSpace) { |
| rectangle = UIComponent(target).getVisibleRect(targetCoordinateSpace); |
| } |
| else { |
| // if target is IMAGE it can be sized to 6711034.2 width or height at times!!! 6710932.2 |
| rectangle = UIComponent(target).getBounds(targetCoordinateSpace); |
| } |
| |
| // size and position fill |
| targetSelectionGroup.width = rectangle.width; |
| targetSelectionGroup.height = rectangle.height; |
| //rectangle = UIComponent(target).getVisibleRect(target.parent); // get correct x and y |
| targetSelectionGroup.x = rectangle.x; |
| targetSelectionGroup.y = rectangle.y; |
| //trace("target is uicomponent"); |
| } |
| // get target bounds |
| else if (target is IGraphicElement) { |
| if (!targetCoordinateSpace) targetCoordinateSpace = target.parent; |
| |
| /*if (!localTargetSpace) { |
| rectangle = IGraphicElement(target).getLayoutBoundsHeight(); |
| } |
| else { |
| rectangle = IGraphicElement(target).getBounds(targetCoordinateSpace); |
| }*/ |
| |
| // size and position fill |
| targetSelectionGroup.width = IGraphicElement(target).getLayoutBoundsWidth(); |
| targetSelectionGroup.height = IGraphicElement(target).getLayoutBoundsHeight(); |
| //rectangle = UIComponent(target).getVisibleRect(target.parent); // get correct x and y |
| targetSelectionGroup.x = IGraphicElement(target).getLayoutBoundsX(); |
| targetSelectionGroup.y = IGraphicElement(target).getLayoutBoundsY(); |
| //trace("target is uicomponent"); |
| } |
| |
| else { |
| if (!localTargetSpace) { |
| rectangle = DisplayObject(target).getBounds(targetCoordinateSpace); |
| } |
| else { |
| rectangle = DisplayObject(target).getBounds(targetCoordinateSpace); |
| } |
| |
| // size and position fill |
| targetSelectionGroup.width = rectangle.width; |
| targetSelectionGroup.height = rectangle.height; |
| targetSelectionGroup.x = rectangle.x; |
| targetSelectionGroup.y = rectangle.y; |
| //trace("target is not uicomponent"); |
| } |
| |
| // we set to the target so we can display target name and size in label above selection |
| targetSelectionGroup.data = target; |
| |
| |
| // unhide target selection group |
| if (isTargetInvalid) { |
| targetSelectionGroup.visible = false; |
| } |
| |
| else if (!targetSelectionGroup.visible) { |
| targetSelectionGroup.visible = true; |
| } |
| } |
| |
| /** |
| * When waiting for images to display we need to update the selection after the image loads |
| * */ |
| public function setSelectionLaterHandler(event:Event):void { |
| var targets:Array = radiate.targets; |
| //trace("Event:"+event.type); |
| // we are referencing the |
| if (targets.indexOf(lastTarget)!=-1 && event.type==Event.COMPLETE) { |
| //radiate.target.validateNow(); |
| updateSelectionAroundTarget(radiate.target); |
| } |
| |
| |
| /*if (event.type==FlexEvent.READY) { |
| Radiate.log.info("Removing Ready listener for " + event.currentTarget); |
| event.currentTarget.removeEventListener(FlexEvent.READY, setSelectionLaterHandler); |
| } |
| else if (event.type==Event.COMPLETE) { |
| Radiate.log.info("Removing Complete listener for " + event.currentTarget); |
| event.currentTarget.removeEventListener(Event.COMPLETE, setSelectionLaterHandler); |
| }*/ |
| } |
| } |
| } |
| |
