The Linux Foundation


From The Linux Foundation

Revision as of 15:44, 20 January 2009 by Ptbrunet (Talk | contribs)

(diff) ←Older revision | view current revision (diff) | Newer revision→ (diff)

Agenda for 2009/01/20

  1. Introductions if needed
  2. Approval of prior minutes - Corrections? Approval?
  3. LF: Open A11y news - Janina
    • Update on recent meetings between LF and Microsoft attorneys.
    • When will the LF board discuss the IA2 standard?
  4. LF/AIA interop
    • See questions raised as listed in item 4 of the December 02 agenda.
    • Pending meetings between LF and Microsoft attorneys.
  5. AccProbe inspect tool - Mike Squillace
    • Pending decision of AccProbe team as to whether or not AccProbe should be moved from Eclipse to LF. It would have to be relicensed from EPL.
  6. Firefox - Marco Zehe
  7. IA2 as a LF standard
    • Remaining work items:
      • Add attribution for trademarks. The following text was provided by Marc Braner of Microsoft.

        The names of actual companies and products mentioned herein may be the trademarks of their respective owners. In particular, Active Accessibility, Microsoft, MSDN, and Win32 are trademarks of the Microsoft group of companies in the U.S.A. and/or other countries.

      • Move 3/26/2007 1.0.1 IDL and 10/13/2008 1.0.2 IDLs into BZR.
      • Close out bugs that have been addressed.
    • While we are making a change I'd like to make the following change:
      1. Update the section on QI/QS as follows:
        Current Text

        Regarding switching between any of the IAccessible2 interfaces, ATs typically use QueryInterface. This is because it is typical for applications implementing IAccessible2 to implement all IAccessible2 interfaces on a single object. However it is possible that an application could use more than one object to implement the full set of IAccessible2 interfaces and as a result QueryService would have to be used. If your AT is using the IAccessible2 interfaces and you want to allow for access to the widest range of existing and future applications you should use QueryService rather than QueryInterface. If the interface being switched to is implemented on the same object there shouldn't be a noticeable difference in performance and if the interface is implemented on another object the application can transfer the request to the secondary object saving exception handling code in the AT.

        New Text

        Regarding switching between any of the IAccessible2 interfaces, applications implementing IAccessible2 should implement the IAccessible2 interfaces on a single object since ATs will be using QueryInterface to switch between the IAccessilbe2 interfaces. Implementing the IAccessible2 interfaces on separate objects would require the use of QueryService. There is one exception, IAccessibleApplication can be implemented on a separate object so its common code doesn't have to be included in each accessible object. ATs should use QueryService to access IAccessibleApplication.

      2. Update IAText::caretOffset as follows:
        Returns the position of the caret.

        Returns the 0-based offset of the caret within the text. If the text is implemented as a tree of text objects with embed characters in higher levels representing substrings of child text objects and the caret is in one of the child text objects, then the offset in the higher level text object would be at the embed character representing child text object that contains the caret.

        For example, if the string "one two three" is implemented as a two text objects, with a top level text object containing an embed character "one ? three" and a child text object containing "two" and if the caret is in the descendant object just before the 'o' in "two", then:

        • the caretOffset for the "one ? three" object would be 4, matching the embed character
        • the caretOffset for "two" would be 2, matching the "o"
        The caret position/offset is that of the character logically following it, e.g. to the right of it in a left to right language.
        • Also add the following note:

          S_FALSE (and an offset of -1) will not be returned if the caret is somewhere in the text object or one of its descendants.

  8. Text attributes spec
    • The following updates were applied to the text attributes spec:
      1. Changed text-position to have just these values: baseline, super, sub
      2. Added the following note to font-size:

        When the application's native attribute is not in pts the application accessibility code should convert to pt. The conversion doesn't have to be exact. The intent is to give the user a feel for the size of the text.

      3. Referred to CSS 2.1 instead of CSS2. Note that text-shadow still refers to CSS2. That's not in CSS 2.1 for some reason. It is in CSS3.
      4. Changed the spec for the language attribute from IETF RFC 3066 (now obsolete) to IETF RFC 4646 and RFC 4647.
      5. Made minor updates to the comments on text-line-through-style, text-line-through-type, text-underline-style, text-underline-type.
  9. IA2 in Qt
    • Mick and Jamie felt Qt should enable their Win support. Janina to follow up with her recent contact at Nokia and Mick and/or Jamie to see if they can submit a request for this to be added. A product called VirtualBox uses Qt.
  10. Flows from / Flows to
    • OOo Writer only provides FlowFrom/To when a paragraph is broken into two at a page boundary.
    • From Mick in an earlier via email: We need a way to ask the app where the caret would go if it were to fall off the end of a particular object. It's not just related to paragraphs, but to any object where the caret can move.</p>

      In the given situation of paragraph table paragraph, it depends on what the app does with the caret. if you are on the last position of the first paragraph and you press right arrow or down arrow, does the caret move to the first cell in the table? if so, then that should be the relation: first paragraph flows to first cell, first cell flows from first paragraph. The same as the last cell in the table flows to second paragraph, second paragraph flows from last cell in table. Also of course I would expect that the flows to/from relation exists on all the table cells.

      When I say table cell though, I really do mean the deepest object in that table cell that has the caret.

      So really, the question is: is the flowsTo/flowsFrom relation really to show where the caret moves? If so this is good, and this is what we would wish to happen. But if flowsTo/flowsFrom was created for a different purpose, then we perhaps should make some new relations specific to the caret.

      At the end of the day, screen readers such as NVDA need a way to ask any given object, for the next or previous object that would contain the caret, if it were to move there directly from this object.

    • OpenOffice implements the flows relation to represent the reading order between all objects, text and non-text.
  11. Deprecation of role EDITBAR?
    • In the spirit of simplification we've been asked to consider removing the edit bar role which is a text area in a tool bar. If for some reason an AT needed to know the text area is in a tool bar the parent could be queried. Are there any objections for this change in IA2 and ATK?
  12. Removal of trailing text in boundary fetches
  13. Service ID
    • See Mick's Note and also the related Mozilla bug 458871 starting at comment 9.
    • Should the service IDs start with SID instead of IID?
  14. Eclipse
    • IA2 is being implemented for Eclipse. This is based on work done in late 2006 and early 2007 by Barry Feigenbaum (now with Amazon) and Larry Weiss (now with Microsoft). That code was running on Eclipse 3.2. The recent work has been to get it running on 3.5 and update it to use the most recent IDL (from 3/26/07).
    • The Eclipse team is looking for a small C++ test case that implements any of the IA2 interfaces.
  15. Oleacc.idl
    • From Larry Weiss: I just checked my system, and oleacc.idl is present in the 6.1 release of the SDK. Otherwise known as the Windows SDK for Windows Server 2008 and .NET Framework 3.5.

No progress on the following

  1. Proxy DLL
    • Jamie sent Pete his RC file so it can be compared to the one attached to bug 110.
    • When the 1.0.2 files are added to BZR, Pete to include the files needed to build the proxy DLL.
    • The process for building the DLL needs to be updated to cover the use of Visual C Express Edition.
    • That wiki page probably needs other changes.
  2. Access to smart tags
    • Symphony uses IAHypertext/IAHyperlink for smart tags. This seems reasonable because smart tags are very similar to links. They represent actionable text. IAHyperlink can represent more than one action which is common for smart tags.
      • One requirement is for links and smart tags to be differentiated. This can be done with an object attribute on the accessible that represents the link object. Are there any issues with that approach?
  3. IA2 issues from Calvin Gaisford, opened on the behalf of AIA.
  4. IA2 object attributes specification.
    • The Symphony and FF3 object attributes will be reviewed. The common attributes will become part of the IA2 object attributes spec and the spec will reference the FF3 and Symphony specific specifications. (The Symphony object attributes are not documented on any Symphony web site, but they'll soon be documented on the IA2 site.)
    • Pete to add a "display" attribute with CSS2 values.
  5. Items raised by NVDA last year need to be put on the agenda for an upcoming Open A11y meeting
    • These are generic issues that need to be solved for both IA2 and ATK/AT-SPI dealing with objects contained in documents and tables
    • See items 4 and 5 in the October 2nd 2007 minutes for the history.
    • This was discussed during the January 22 Open a11y meeting.
    • These should be reopened and discussed with Willie and Li Yuan at a call convenient to the US, China, and Australia.
  6. Wikipedia
  7. Developer Guide - Best practices document. We should start an outline for a best practices document. For starters it should define the following:
    • What events should be fired for each role and in what order.
    • What object hierarchy should be used. There are two today, a flat hierarchy as used in Symphony and a deeper hierarchy as used in Firefox. These two should be documented and in order to cut down on the proliferation of designs, future applications should attempt to use one or the other.
  8. FAQ
  9. Access to document revisions - from the ODF AccSC
    • This was reviewed by the AIA Interop group. The following issues were raised.
      1. What is the solution for non-text attributes, e.g. tables, images, charts, cells, spreadsheets?
        • From Oliver-Rainer Wittmann at Sun: Currently, the OOo Writer does not support change tracking for tables, table rows, table cells and anchored objects (text frames, graphics, embedded objects and drawing objects).
        • From Niklas Nebel at Sun: Recorded changes in spreadsheets are somewhat different from text documents: The spreadsheet cell structure only contains the current state. Changes are not part of a cell's content, but separate. Possible changes are:
          1. Content changes
          2. Inserting/deleting columns/rows
          3. Inserting sheets
          4. Moving cell ranges
          • Pending response from Niklas to some questions:
            1. Is there a link to the spec that describes those changes?
            2. What if a sheet is removed? Only insertion is mentioned.
            3. What is a cell range and what does it mean to move it? An example / use case would probably be enough to describe this.
        • The current proposed set of a11y interfaces and methods won't work for a spreadsheet. It will take some time to work through this. Pending requirements from applications developers, the team has agreed to attempt to work toward a spec that will work with a wider range of applications.
        • Pending response from Malte regarding requirements from OOo.
        • From Larry Weiss: UIA doesn’t have direct support for revisions (as such). But it does support “find” of “next” element with specific properties. So for compatibility, IA2 (and ATK) should expose a revision as a property of an element. As I recall, the proposal you referenced didn’t support all of the revision scenarios available in Word: comment only revisions; revisions with one or more comments; style revisions (font, color, bullet style, etc.); adding/removing/changing a link (or image). I don’t know of a list of all possible revisions supported by Word.
      2. How are comment only revisions handled?
        • Malte Timmerman doesn't think this is a feature of OpenOffice.
      3. Probably need more kinds of format changes besides insertion, deletion, and format change.
        • Malte wasn't supportive of this.
      4. Is more granularity needed for format changes, i.e. is it enough to just say there was a format change or should the kind of format change be indicated?
        • Malte said that as far as he knows this was discussed and the decision was to keep it at the current level of granularity.
      5. getSegmentAtOffset (singular) needs to be getSegmentsAtOffset (plural) because unlike links there could be overlapping insertions and deletions.
        • From Oliver-Rainer Wittmann at Sun: In OOo Writer there are no overlapping revisions/change trackings. The OOo Writer breaks a certain change tracking into corresponding pieces, if the user creates overlapping revisions/change trackings. Thus, revisions/change trackings are properly nested in OOo Writer. But nevertheless, there can be several change trackings at a certain cursor position. Thus, the proposed change is reasonable.
    • Once these issues are resolved Li Yuan, the committer for ATK/AT-SPI will develop a patch.

enum IA2RevisionType {
  IA2_REVTYPE_FORMAT_CHANGE  // The revision is due to any change in formatting attributes. 

typedef struct {
    enum IA2RevisionType type;  
    BSTR time;  ///< ISO 8601 format:  YYYY-MM-DDThh:mm:ss (eg 1997-07-16T19:20:21)
    BSTR author;
    BSTR comments;
} IA2RevisionInformation;

// Note: an object that implements IARevisionText must also implement IAText
// returns the number of segments available for the
// block of text represented by the IARevisionText object.
// this number is 1 based
get_segmentCount( long* count );
// returns a specific segment based on the index passed in
// the index is 0 based.
// no two indexes should return the same segment.
// any index >= 0, and less than the segment count should return a valid segment
// any index outside those bounds should set HRESULT to S_FALSE and return NULL
get_segment( long index,  IARevisionSegment** seg );
// returns a segment whose boundaries encompass the offset provided
// if there are no segments that correspond to the given offset, an error is produced
// offsets correspond identically to those used by IAText and IAHyperlink
get_segmentAtOffset( long offset, IARevisionSegment** seg );

// returns the bounding offsets of the segment within the IARevisionText/IAText object.
// the end offset is one past the last character in the revision text
get_bounds( long* start, long* end );

// returns a struct containing date/time, author, and comments
get_attributes( IA2RevisionInformation *revision_info );
// returns a set of name value pairs describing additional application
// specific attributes in the format "name:value;name:value"
get_extraAttributes( BSTR* extraAttributes );

[Article] [Discussion] [View source] [History]