| //////////////////////////////////////////////////////////////////////////////// |
| // |
| // 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 flashx.textLayout.accessibility |
| { |
| import flash.accessibility.Accessibility; |
| import flash.accessibility.AccessibilityImplementation; |
| import flash.accessibility.AccessibilityProperties; |
| import flash.display.DisplayObject; |
| import flash.events.Event; |
| |
| import flashx.textLayout.edit.EditingMode; |
| import flashx.textLayout.edit.ISelectionManager; |
| import flashx.textLayout.elements.FlowElement; |
| import flashx.textLayout.elements.FlowLeafElement; |
| import flashx.textLayout.elements.GlobalSettings; |
| import flashx.textLayout.elements.ParagraphElement; |
| import flashx.textLayout.elements.TextFlow; |
| import flashx.textLayout.events.CompositionCompleteEvent; |
| import flashx.textLayout.tlf_internal; |
| |
| use namespace tlf_internal; |
| //TODO this is in text_edit... which violates MVC yet again... what to do? |
| //import flashx.textLayout.events.SelectionEvent; |
| |
| //TODO handle selectable text when FP implements the new selection API: |
| // http://frpbugapp.macromedia.com/bugapp/detail.asp?id=217540 |
| // To catch the selection changes reliably, listen for SelectionEvent, |
| // which is dispatched on the TextFlow whenever the selection changes. |
| |
| //TODO handle scrolling? might need to expose scrolling in here |
| |
| //TODO handle hyperlinks? I don't know if MSAA has a concept for this |
| // (what other text advanced features must be accessible? graphics?) |
| //TODO what if there is HTML in it? strip it, or read it? we don't have an |
| // htmlText property, do we? |
| |
| // TODO Do we want to read the contents of each sprite and stop, even if the |
| // text flows into other sprite, meaning we read text in taborder; or do we |
| // want to read the entire model and not worry about the presentation |
| // (simpler)? Not sure if I can get the contents of each sprite separately. |
| |
| // TODO TESTING: |
| // * Test that JAWS reads when setting the focus programmatically. |
| // * Tests for changing every part of the model programmatically -- role |
| // and state should update accordingly, visibility, and text contents. |
| // * Test that setting tabOrder reads as expected. What happens if you set |
| // tabOrder on multiple flowComposers? |
| |
| //TODO update this comment after integration |
| /** |
| * @private |
| * The TextAccImpl class adds accessibility for text components. |
| * This hooks into DisplayObjects when TextFlow.container is set. |
| */ |
| public class TextAccImpl extends AccessibilityImplementation |
| { |
| //TODO might want to put these constants in a new class if they are |
| // used anywhere else. |
| |
| /** Default state */ |
| protected static const STATE_SYSTEM_NORMAL:uint = 0x00000000; |
| |
| /** Read-only text */ |
| protected static const STATE_SYSTEM_READONLY:uint = 0x00000040; |
| |
| /** Inivisible text */ |
| //TODO unused, but supported state for text in MSAA |
| protected static const STATE_SYSTEM_INVISIBLE:uint = 0x00008000; |
| |
| /** Default role -- read-only, unselectable text. */ |
| protected static const ROLE_SYSTEM_STATICTEXT:uint = 0x29; |
| |
| /** Editable OR read-only, selectable text. */ |
| protected static const ROLE_SYSTEM_TEXT:uint = 0x2a; |
| |
| /* When the name changes (name is the text conent in STATICTEXT). */ |
| protected static const EVENT_OBJECT_NAMECHANGE:uint = 0x800c; |
| |
| /* When the value changes (value is the text content in TEXT). */ |
| protected static const EVENT_OBJECT_VALUECHANGE:uint = 0x800e; |
| |
| /** |
| * A reference to the DisplayObject that is hosting accessible text. |
| */ |
| //TODO for now this assumes only the first DO in a flow is accessible |
| // in the future each flow DO should host its own accimpl and read |
| // the text only for its own box. |
| // |
| // Or... perhaps we use getChildIDArray to manage all the text |
| // flows if they are linked below some master component (but I don't |
| // think this is the way it will happen). |
| protected var textContainer:DisplayObject; |
| |
| /** |
| * A reference to the TextFlow where our text originates. |
| */ |
| protected var textFlow:TextFlow; |
| |
| /** |
| * Constructor. |
| * |
| * @param textContainer The DisplayObject instance that this |
| * TextAccImpl instance is making accessible. |
| * @param textFlow The TextFlow that is hosting the textContainer. |
| */ |
| public function TextAccImpl(textCont:DisplayObject, textFlow:TextFlow) |
| { |
| super(); |
| |
| this.textContainer = textCont; |
| this.textFlow = textFlow; |
| |
| // stub is true when you are NOT providing an acc implementation |
| // reports to reader as graphic |
| stub = false; |
| |
| if (textCont.accessibilityProperties == null) |
| { |
| textCont.accessibilityProperties = |
| new AccessibilityProperties(); |
| } |
| |
| //TODO |
| // setup event listeners for text selection and model changes |
| //textFlow.addEventListener(SelectionEvent.SELECTION_CHANGE, |
| // eventHandler); |
| textFlow.addEventListener(CompositionCompleteEvent.COMPOSITION_COMPLETE, eventHandler); |
| } |
| |
| public function detachListeners():void |
| { |
| textFlow.removeEventListener(CompositionCompleteEvent.COMPOSITION_COMPLETE, eventHandler); |
| } |
| |
| /** |
| * Returns the system role for the text. |
| * |
| * @param childID uint. |
| * @return Role associated with the text. |
| */ |
| override public function get_accRole(childID:uint):uint |
| { |
| // trace("get_accRole()"); |
| |
| const iManager:ISelectionManager = textFlow.interactionManager; |
| if (iManager == null) |
| { |
| // non-selectable, non-editable text is STATICTEXT |
| return ROLE_SYSTEM_STATICTEXT |
| } |
| else // iManager is an IEditManager and/or ISelectionManager |
| { |
| // read-only selectable or editable selectable text are TEXT |
| return ROLE_SYSTEM_TEXT; |
| } |
| } |
| |
| /** |
| * Returns the state of the text. |
| * |
| * @param childID uint. |
| * @return Role associated with the text. |
| */ |
| override public function get_accState(childID:uint):uint |
| { |
| // trace("get_accState()"); |
| |
| const iManager:ISelectionManager = textFlow.interactionManager; |
| |
| //TODO handle STATE_SYSTEM_INVISIBLE for all cases below |
| // and add an event to detect changes--does Flash support this? |
| |
| //TODO handle STATE_SYSTEM_PROTECTED for all cases below |
| // if vellum gets a concept of password fields, then it needs to |
| // emit this value if the field is converted to a password; |
| // otherwise the Flex framework will need to be sure to emit |
| // this state in a text input component. |
| |
| // note: focus-related states are handled by the player |
| |
| if (iManager == null) |
| { |
| // non-selectable, non-editable text |
| return STATE_SYSTEM_READONLY; |
| } |
| // must check IEditManager before ISelectionManager (it can be both) |
| else if (iManager.editingMode == EditingMode.READ_WRITE) |
| { |
| // editable selectable text |
| return STATE_SYSTEM_NORMAL; |
| } |
| else // if (iManager instanceof ISelectionManager) |
| { |
| // read-only selectable text |
| return STATE_SYSTEM_READONLY; |
| } |
| } |
| |
| /** |
| * Returns the name of the text. |
| * |
| * @param childID uint. |
| * @return Name of the text. |
| */ |
| override public function get_accName(childID:uint):String |
| { |
| // trace("get_accName()"); |
| |
| switch (get_accRole(childID)) |
| { |
| case ROLE_SYSTEM_STATICTEXT: |
| { |
| //TODO this SHOULD come from TextConverter, but then there is a |
| // circular build dependency since importExport builds |
| // against model, and it probably violates mvc |
| //return TextConverter.export(textFlow, |
| // TextConverter.PLAIN_TEXT_FORMAT); |
| |
| //TODO this is probably expensive. is there a way to cache |
| // this and know when dirty? |
| //TODO look at the generation and determine when it's dirty |
| return exportToString(textFlow); |
| } |
| |
| case ROLE_SYSTEM_TEXT: |
| default: |
| return null; |
| } |
| } |
| |
| /** |
| * Returns the value of the text. |
| * |
| * @param childID uint. |
| * @return Name of the text. |
| */ |
| override public function get_accValue(childID:uint):String |
| { |
| // trace("get_accValue()"); |
| |
| switch (get_accRole(childID)) |
| { |
| case ROLE_SYSTEM_TEXT: |
| { |
| //TODO this SHOULD come from TextConverter, but then there is a |
| // circular build dependency since importExport builds |
| // against model, and it probably violates mvc |
| //return TextConverter.export(textFlow, |
| // TextConverter.PLAIN_TEXT_FORMAT); |
| |
| // TODO this is probably expensive. is there a way to cache |
| // this and know when dirty? |
| //TODO look at the generation and determine when it's dirty |
| return exportToString(textFlow); |
| } |
| |
| case ROLE_SYSTEM_STATICTEXT: |
| default: |
| return null; |
| } |
| } |
| |
| /** |
| * Handles COMPOSITION_COMPLETE and SELECTION_CHANGE events, |
| * updates the MSAA model. |
| */ |
| protected function eventHandler(event:Event):void |
| { |
| switch (event.type) |
| { |
| // This updates the entire accessibility DOM. |
| // get_accName is probably expensive here, it happens ONLY if |
| // JAWS is running, otherwise Accessibility.* calls are NOOP. |
| // |
| // Event does NOT fire when interactionManager changes; ideally |
| // we'd want to tell MSAA the role changed, but apparently roles |
| // are typically static and that's not a supported workflow. |
| // instead, Flash occasionally polls the displaylist, e.g. when |
| // you mouseover. calling updateProperties() doesn't necessarily |
| // trigger role updates (calls to get_acc*()). |
| case CompositionCompleteEvent.COMPOSITION_COMPLETE: |
| { |
| // TODO change childID from 0 if we use getChildIDArray |
| // otherwise delete this comment |
| try { |
| Accessibility.sendEvent(textContainer, 0, |
| EVENT_OBJECT_NAMECHANGE); |
| Accessibility.sendEvent(textContainer, 0, |
| EVENT_OBJECT_VALUECHANGE); |
| Accessibility.updateProperties(); |
| } catch (e_err:Error) { |
| // generic error occurred. |
| // this can happen in the SA player since there is no |
| // Accessibility implementation. |
| } |
| break; |
| } |
| |
| //TODO when we have the FP selection APIs |
| // case SelectionEvent.SELECTION_CHANGE: |
| // { |
| // // this is just stubbed code, I don't know what *needs* to |
| // // be done for SELECTION_CHANGE |
| // Accessibility.sendEvent(textContainer, 0, |
| // EVENT_OBJECT_TEXTSELECTIONCHANGED); |
| // Accessibility.updateProperties(); |
| // break; |
| // } |
| } |
| } |
| |
| /** |
| * TODO HACK, remove and refactor. |
| * |
| * This is copied from PlainTextExportFilter, which I would prefer to |
| * access through TextConverter.export(textFlow, |
| * TextConverter.PLAIN_TEXT_FORMAT); |
| * |
| * But, PTEF is in importExport, which builds against text_model, |
| * which is a circular dependency. |
| * |
| * Also, it seems to be adding a trailing newline, which is bad for |
| * accessibility unless it is really there. |
| * |
| * Might want to export and strip out hyphens. |
| * Move it to the model? |
| */ |
| private static function exportToString(source:TextFlow):String |
| { |
| var leaf:FlowLeafElement = source.getFirstLeaf(); |
| var rslt:String = ""; |
| var curString:String = ""; |
| var discretionaryHyphen:String = String.fromCharCode(0x00AD); |
| while (leaf) |
| { |
| var p:ParagraphElement = leaf.getParagraph(); |
| while (true) |
| { |
| curString = leaf.text; |
| |
| //split out discretionary hyphen and put string back together |
| var temparray:Array = curString.split(discretionaryHyphen); |
| curString = temparray.join(""); |
| |
| rslt += curString; |
| leaf = leaf.getNextLeaf(p); |
| if (!leaf) |
| { |
| // we want newlines between paragraphs but not at the end |
| rslt += "\n"; |
| break; |
| } |
| } |
| leaf = p.getLastLeaf().getNextLeaf(); |
| } |
| return rslt; |
| } |
| |
| /** |
| * The zero-based character index value of the first character in the current selection. |
| * Components which wish to support inline IME or Accessibility should call into this method. |
| * |
| * @return the index of the character at the anchor end of the selection, or <code>-1</code> if no text is selected. |
| * |
| * @playerversion Flash 10.0 |
| * @langversion 3.0 |
| */ |
| public function get selectionActiveIndex():int |
| { |
| var selMgr:ISelectionManager = textFlow.interactionManager; |
| var selIndex:int = -1; |
| if(selMgr && selMgr.editingMode != EditingMode.READ_ONLY) |
| { |
| selIndex = selMgr.activePosition; |
| } |
| |
| return selIndex; |
| } |
| |
| /** |
| * The zero-based character index value of the last character in the current selection. |
| * Components which wish to support inline IME or Accessibility should call into this method. |
| * |
| * @return the index of the character at the active end of the selection, or <code>-1</code> if no text is selected. |
| * |
| * @playerversion Flash 10.0 |
| * @langversion 3.0 |
| */ |
| public function get selectionAnchorIndex():int |
| { |
| var selMgr:ISelectionManager = textFlow.interactionManager; |
| var selIndex:int = -1; |
| if(selMgr && selMgr.editingMode != EditingMode.READ_ONLY) |
| { |
| selIndex = selMgr.anchorPosition; |
| } |
| |
| return selIndex; |
| } |
| |
| /** Enable search index for Ichabod |
| * Returns the entire text of the TextFlow, or null if search index is not enabled |
| * @see GlobalSettings.searchIndexEnabled |
| */ |
| public function get searchText():String |
| { |
| return GlobalSettings.enableSearch ? textFlow.getText() : null; |
| } |
| |
| } |
| } |
| |
