Is there a desire to discuss IA2/UIA interop on this call? Or should we leave that as an action item for the AIA? Is there anyone in this community active in the AIA? Some questions were raised as listed in item 4 of the December 02 agenda.

Assuming there is a desire for interop, we are still pending meetings between LF and Microsoft attorneys.

The spec should be final now and in sync with the current Firefox design. However, prior to a final review, we should wait until Firefox has completed all of the related work.

Removal of trailing text in boundary fetches.

The consensus is that word based fetches from IAText::textAt/Before/AfterOffset should be changed so that the app returns the same thing as when Ctrl left/right arrow is used. It was felt this is OK as long as the Ctrl left/right isn't overridden to do something other than navigate between words, such as navigating between cells in a spreadsheet.

The current text is simply: "Range is from start of one word to the start of another word." Please review the following as a possible change: "The range provided matches the range observed when the application processes the Ctrl + left arrow and Ctrl + right arrow key sequences. Typically this is from the start of one word to the start of the next, but various applications are inconsistent in the handling of the end of a line."

QI/QS

The documentation exists in two forms as follows. Please provide your input on which form is more appealing.

The following text in the first format has an error, "If the SID is IID_IAccessible and the IID is IID_IUnknown, IID_IDispatch, or IID_IAccessible, then return the IAccessible for the IAccessible object, otherwise return E_NOINTERFACE." The requested interface should be returned, not always IAccessible.

Should the QS of IAccessible only respond to an IID of IID_IAccessible2 or should it respond to any of the IA2 IIDs?

The text must make it clear that when you QI an object, the interface pointer that's returned needs to be for the same object.

If IEnumInvariant is implemented, is it implemented on the same object as the rest of the IA2 interfaces?

Will FF and Symphony respond without error based on this spec or will some bugs need to be written and a rollout plan put in place?

Should IDispatch be allowed as an additional optional interface on the IA2 object?

Eclipse

The implementation of IA2 in Eclipse 3.5 continues.

The Eclipse team is looking for a small C++ test case that implements any of the IA2 interfaces.

The uniqueID is an identifier for this object, is unique within the current window, and remains the same for the lifetime of the accessible object.

to:

The uniqueID is an identifier for this object, is unique within the current application, and remains the same for the lifetime of the accessible object.

and change the last paragraph from:

One means of implementing this would be to create a factory with a 32 bit number generator and a reuse pool. The number generator would emit numbers starting at 1. Each time an object's life cycle ended, its number would be saved into a resuse pool. The number generator would be used whenever the reuse pool was empty.

to these three paragraphs:

One means of implementing this would be to create a factory with a 32 bit number generator and a reuse pool. The number generator would emit numbers starting at 1. Each time an object's life cycle ended, its number would be saved into a reuse pool. The number generator would be used whenever the reuse pool was empty.

Another means is to use the pointer of the accessible.

Since some ATs need uniqueness within the machine, not just within the application, they use a combination of windowHandle and uniqueID.

Lightweight IA2 objects

The description of IAccessible2 says, "This interface must always be provided for objects that support some portion of the collection of the IAccessible2 interfaces." However, objects that support IARelation or IAHyperlink should be lightweight with no need to support IAccessible2 or QS to IAApplication. Are there any objections to this restriction?

IAAction, IAHyperlink

The following two paragraphs are part of the description for IAHyperlink:

An interesting use case is an image map where each area is associated with multiple actions, e.g. an image map of smart tags. In this case you would have to implement two levels of accessible hyperlinks. The first level hyperlinks would only implement anchor and anchorTarget. The anchors would all reference the image object. The anchorTargets would reference the second level accessible hyperlink objects. None of the IAccessibleAction methods would be implemented on the first level hyperlink objects. The second level hyperlink objects would implement the IAccessibleAction methods. Their anchors would also reference the image object and their anchorTargets would reference URLs or the objects that would be activated.

This use case demonstrates that in some cases there is no need for IAccessibleHyperlink to derive from IAccessibleAction. As a result it may be removed in a later version of the IDL and it is suggested that implementations should not rely on the inheritance.

This should be updated to take into consideration an offline comment from Jamie:

My argument was that hyperlink anchors and actions are different concepts. Treating them as the same infers that a hyperlink can only have one action per anchor. I was arguing that they should be treated differently; i.e. that IAHyperlink should not derive from IAAction and there should instead be IAHyperlink::nAnchors. So this would require an additional method, not just the removal of the derivation from IAHyperlink.

64 bits

At some point we'll have to look at what needs to be changed for IA2 to be correct in both 32 bit and 64 bit environments. The 32bit world is also known as ILP32 where ints, longs, and pointers are all 32 bits. The 64 bit world is called LP64 where the longs and pointers are 64 bits. IA2 specifies all the integers as longs but they probably should have been specified as ints. There is a paper on ILP32, LP64.

Types for IAValue

Should the VARIANT types for IAValue be limited to VT_I4 and VT_BSTR?

No progress on the following

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.

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?

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.)

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.

FAQ

Access to document revisions - from the ODF AccSC

This was reviewed by the AIA Interop group. The following issues were raised.

What is the solution for non-text attributes, e.g. tables, images, charts, cells, spreadsheets?

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:

Content changes

Inserting/deleting columns/rows

Inserting sheets

Moving cell ranges

Pending response from Niklas to some questions:

Is there a link to the spec that describes those changes?

What if a sheet is removed? Only insertion is mentioned.

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.

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.

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_INSERTION,
IA2_REVTYPE_DELETION,
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;
IARevisionText:
// 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 );
IARevisionSegment:
// 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 );