// 24 december 2014 // notes: // - TODO figure out what to do about header // - a row extends as far right as the right edge of the last cell in the row; anything to the right of that is treated as table space (just like with mouse selection) // - this has the added effect that hit-testing can only ever return either the table or a cell, never a row // - cells have no children; checkbox cells are themselves the accessible object // - TODO if we ever add combobox columns, this will need to change somehow // - only Table and Cell can have focus; only Row can have selection // - TODO allow selecting a cell? // TODOs: // - make sure E_POINTER and RPC_E_DISCONNECTED are correct returns for IAccessible // - return last error on newTableAcc() in all accessible functions // uncomment this to debug table linked list management //#define TABLE_DEBUG_LINKEDLIST // TODO get rid of this typedef struct tableAccWhat tableAccWhat; struct tableAccWhat { LONG role; intptr_t row; intptr_t column; }; struct tableAcc { const IAccessibleVtbl *vtbl; ULONG refcount; struct table *t; IAccessible *std; tableAccWhat what; // the list of currently active accessibility objects is a doubly linked list struct tableAcc *prev; struct tableAcc *next; }; #ifdef TABLE_DEBUG_LINKEDLIST void list(struct table *t) { struct tableAcc *ta; printf("\n"); if (t->firstAcc == NULL) { printf("\tempty\n"); return; } printf("\t-> "); for (ta = t->firstAcc; ta != NULL; ta = ta->next) printf("%p ", ta); printf("\n\t<- "); for (ta = t->firstAcc; ta->next != NULL; ta = ta->next) ; for (; ta != NULL; ta = ta->prev) printf("%p ", ta); printf("\n"); } #endif // called after each allocation static struct tableAcc *newTableAcc(struct table *t, LONG role, intptr_t row, intptr_t column); // common validation for accessibility functions that take varChild // also normalizes what as if varChild == CHILDID_SELF static HRESULT normalizeWhat(struct tableAcc *ta, VARIANT varChild, tableAccWhat *what) { LONG cid; if (varChild.vt != VT_I4) return E_INVALIDARG; cid = varChild.lVal; if (cid == CHILDID_SELF) return S_OK; cid--; if (cid < 0) return E_INVALIDARG; switch (what->role) { case ROLE_SYSTEM_TABLE: // TODO +1? if (cid >= ta->t->count) return E_INVALIDARG; what->role = ROLE_SYSTEM_ROW; what->row = (intptr_t) cid; what->column = -1; break; case ROLE_SYSTEM_ROW: case ROLE_SYSTEM_CELL: // TODO // TODO also figure out what to do if the current row/cell become invalid (rows being removed, etc.) break; } return S_OK; } #define TA ((struct tableAcc *) this) static HRESULT STDMETHODCALLTYPE tableAccQueryInterface(IAccessible *this, REFIID riid, void **ppvObject) { if (ppvObject == NULL) return E_POINTER; if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDispatch) || IsEqualIID(riid, &IID_IAccessible)) { IAccessible_AddRef(this); *ppvObject = (void *) this; return S_OK; } *ppvObject = NULL; return E_NOINTERFACE; } // TODO use InterlockedIncrement()/InterlockedDecrement() for these? static ULONG STDMETHODCALLTYPE tableAccAddRef(IAccessible *this) { TA->refcount++; // TODO correct? return TA->refcount; } static ULONG STDMETHODCALLTYPE tableAccRelease(IAccessible *this) { TA->refcount--; if (TA->refcount == 0) { struct tableAcc *prev, *next; #ifdef TABLE_DEBUG_LINKEDLIST if (TA->t != NULL) { printf("before delete:"); list(TA->t); } #endif if (TA->t != NULL && TA->t->firstAcc == TA) TA->t->firstAcc = TA->next; prev = TA->prev; next = TA->next; if (prev != NULL) prev->next = next; if (next != NULL) next->prev = prev; #ifdef TABLE_DEBUG_LINKEDLIST if (TA->t != NULL) { printf("after delete:"); list(TA->t); } #endif if (TA->std != NULL) IAccessible_Release(TA->std); tableFree(TA, "error freeing Table accessibility object"); return 0; } return TA->refcount; } // IDispatch // TODO make sure relegating these to the standard accessibility object is harmless static HRESULT STDMETHODCALLTYPE tableAccGetTypeInfoCount(IAccessible *this, UINT *pctinfo) { if (TA->t == NULL || TA->std == NULL) { // TODO set values on error return RPC_E_DISCONNECTED; } return IAccessible_GetTypeInfoCount(TA->std, pctinfo); } static HRESULT STDMETHODCALLTYPE tableAccGetTypeInfo(IAccessible *this, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo) { if (TA->t == NULL || TA->std == NULL) { // TODO set values on error return RPC_E_DISCONNECTED; } return IAccessible_GetTypeInfo(TA->std, iTInfo, lcid, ppTInfo); } static HRESULT STDMETHODCALLTYPE tableAccGetIDsOfNames(IAccessible *this, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId) { if (TA->t == NULL || TA->std == NULL) { // TODO set values on error return RPC_E_DISCONNECTED; } return IAccessible_GetIDsOfNames(TA->std, riid, rgszNames, cNames, lcid, rgDispId); } static HRESULT STDMETHODCALLTYPE tableAccInvoke(IAccessible *this, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr) { if (TA->t == NULL || TA->std == NULL) { // TODO set values on error return RPC_E_DISCONNECTED; } return IAccessible_Invoke(TA->std, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); } // IAccessible static HRESULT STDMETHODCALLTYPE tableAccget_accParent(IAccessible *this, IDispatch **ppdispParent) { if (TA->t == NULL || TA->std == NULL) { // TODO set values on error return RPC_E_DISCONNECTED; } return IAccessible_get_accParent(TA->std, ppdispParent); } static HRESULT STDMETHODCALLTYPE tableAccget_accChildCount(IAccessible *this, long *pcountChildren) { if (pcountChildren == NULL) return E_POINTER; // TODO set pcountChildren to zero? if (TA->t == NULL || TA->std == NULL) return RPC_E_DISCONNECTED; switch (TA->what.role) { case ROLE_SYSTEM_TABLE: // TODO header row *pcountChildren = (long) (TA->t->count); return S_OK; case ROLE_SYSTEM_ROW: *pcountChildren = (long) (TA->t->nColumns); return S_OK; case ROLE_SYSTEM_CELL: *pcountChildren = 0; return S_OK; } // TODO actually do this right // TODO un-GetLastError() this panic("impossible blah blah blah TODO write this"); return E_FAIL; } // TODO [EDGE CASE/NOT DOCUMENTED/CHECK SAMPLE] what happens if CHILDID_SELF is passed? // TODO [EDGE CASE/NOT DOCUMENTED/CHECK SAMPLE] what SHOULD happen if an out of bounds ID is passed? static HRESULT STDMETHODCALLTYPE tableAccget_accChild(IAccessible *this, VARIANT varChild, IDispatch **ppdispChild) { LONG cid; if (ppdispChild == NULL) return E_POINTER; *ppdispChild = NULL; if (TA->t == NULL || TA->std == NULL) return RPC_E_DISCONNECTED; if (varChild.vt != VT_I4) return E_INVALIDARG; cid = varChild.lVal; if (cid < 0) // TODO really? return E_INVALIDARG; if (cid == CHILDID_SELF) return E_FAIL; // TODO cid--; switch (TA->what.role) { case ROLE_SYSTEM_TABLE: // TODO table header if (TA->t->count == 0) return S_FALSE; if (cid > TA->t->count - 1) // TODO really? return E_INVALIDARG; *ppdispChild = (IDispatch *) newTableAcc(TA->t, ROLE_SYSTEM_ROW, cid, -1); return S_OK; case ROLE_SYSTEM_ROW: // TODO verify that row is still valid if (TA->t->nColumns == 0) return S_FALSE; if (cid > TA->t->nColumns - 1) // TODO really? return E_INVALIDARG; *ppdispChild = (IDispatch *) newTableAcc(TA->t, ROLE_SYSTEM_CELL, TA->what.row, cid); case ROLE_SYSTEM_CELL: // TODO verify that row/column are still valid? return S_FALSE; } // TODO actually do this right // TODO un-GetLastError() this panic("impossible blah blah blah TODO write this"); return E_FAIL; } static HRESULT STDMETHODCALLTYPE tableAccget_accName(IAccessible *this, VARIANT varChild, BSTR *pszName) { printf("get_accName() t %p std %p\n", TA->t, TA->std); if (TA->t == NULL || TA->std == NULL) { printf("returning RPC_E_DISCONNECTED\n"); // TODO set values on error return RPC_E_DISCONNECTED; } printf("running main function\n"); //TODO if (pszName == NULL) return E_POINTER; *pszName = SysAllocString(L"accessible table"); return S_OK; return IAccessible_get_accName(TA->std, varChild, pszName); } static HRESULT STDMETHODCALLTYPE tableAccget_accValue(IAccessible *this, VARIANT varChild, BSTR *pszValue) { if (TA->t == NULL || TA->std == NULL) { // TODO set values on error return RPC_E_DISCONNECTED; } return IAccessible_get_accValue(TA->std, varChild, pszValue); } static HRESULT STDMETHODCALLTYPE tableAccget_accDescription(IAccessible *this, VARIANT varChild, BSTR *pszDescription) { HRESULT hr; tableAccWhat what; if (pszDescription == NULL) return E_POINTER; *pszDescription = NULL; if (TA->t == NULL || TA->std == NULL) return RPC_E_DISCONNECTED; what = TA->what; hr = normalizeWhat(TA, varChild, &what); if (hr != S_OK) return hr; // don't support descriptions anyway; do return the above errors just to be safe return DISP_E_MEMBERNOTFOUND; } static HRESULT STDMETHODCALLTYPE tableAccget_accRole(IAccessible *this, VARIANT varChild, VARIANT *pvarRole) { if (TA->t == NULL || TA->std == NULL) { // TODO set values on error return RPC_E_DISCONNECTED; } //TODO if (pvarRole == NULL) return E_POINTER; pvarRole->vt = VT_I4; pvarRole->lVal = TA->what.role; return S_OK; return IAccessible_get_accRole(TA->std, varChild, pvarRole); } static HRESULT STDMETHODCALLTYPE tableAccget_accState(IAccessible *this, VARIANT varChild, VARIANT *pvarState) { if (TA->t == NULL || TA->std == NULL) { // TODO set values on error return RPC_E_DISCONNECTED; } return IAccessible_get_accState(TA->std, varChild, pvarState); } static HRESULT STDMETHODCALLTYPE tableAccget_accHelp(IAccessible *this, VARIANT varChild, BSTR *pszHelp) { HRESULT hr; tableAccWhat what; if (pszHelp == NULL) return E_POINTER; *pszHelp = NULL; if (TA->t == NULL || TA->std == NULL) return RPC_E_DISCONNECTED; what = TA->what; hr = normalizeWhat(TA, varChild, &what); if (hr != S_OK) return hr; // don't support help anyway; do return the above errors just to be safe return DISP_E_MEMBERNOTFOUND; } // TODO Inspect.exe seems to ignore the DISP_E_MEMBERNOTFOUND and just tells us the help topic is the empty string; make sure this works right static HRESULT STDMETHODCALLTYPE tableAccget_accHelpTopic(IAccessible *this, BSTR *pszHelpFile, VARIANT varChild, long *pidTopic) { HRESULT hr; tableAccWhat what; if (pszHelpFile == NULL || pidTopic == NULL) return E_POINTER; // TODO set pszHelpFile and pidTopic to zero? if (TA->t == NULL || TA->std == NULL) return RPC_E_DISCONNECTED; what = TA->what; hr = normalizeWhat(TA, varChild, &what); if (hr != S_OK) return hr; // don't support Windows Help (the super-old .hlp help files) topics anyway; do return the above errors just to be safe // TODO [EDGE CASE??] or should we defer back to the standard accessible object? get_accHelp() was explicitly documented as not being supported by the standard/common controls, but this one isn't... return DISP_E_MEMBERNOTFOUND; } static HRESULT STDMETHODCALLTYPE tableAccget_accKeyboardShortcut(IAccessible *this, VARIANT varChild, BSTR *pszKeyboardShortcut) { if (TA->t == NULL || TA->std == NULL) { // TODO set values on error return RPC_E_DISCONNECTED; } return IAccessible_get_accKeyboardShortcut(TA->std, varChild, pszKeyboardShortcut); } // TODO TEST THIS // TODO [EDGE CASE??] no parents? static HRESULT STDMETHODCALLTYPE tableAccget_accFocus(IAccessible *this, VARIANT *pvarChild) { HRESULT hr; if (pvarChild == NULL) return E_POINTER; // TODO set pvarChild to empty? if (TA->t == NULL || TA->std == NULL) return RPC_E_DISCONNECTED; // TODO verify that TA is still pointing to a valid row/column // first see if the control has the focus // this is why a standard accessible object is needed on all accessible objects hr = IAccessible_get_accFocus(TA->std, pvarChild); // check the pvarChild type instead of hr // https://msdn.microsoft.com/en-us/library/windows/desktop/dd318479%28v=vs.85%29.aspx does this // TODO [EDGE CASE] figure out why if (pvarChild->vt != VT_I4) return hr; switch (TA->what.role) { case ROLE_SYSTEM_TABLE: if (TA->t->selectedRow != -1 && TA->t->selectedColumn != -1) goto selectedCell; goto self; case ROLE_SYSTEM_ROW: if (TA->t->selectedRow != TA->what.row) goto nothing; goto selectedCell; case ROLE_SYSTEM_CELL: if (TA->t->selectedRow != TA->what.row) goto nothing; if (TA->t->selectedColumn != TA->what.column) goto nothing; goto self; } // TODO actually do this right // TODO un-GetLastError() this panic("impossible blah blah blah TODO write this"); return E_FAIL; nothing: pvarChild->vt = VT_EMPTY; // TODO really this one? return S_FALSE; self: pvarChild->vt = VT_I4; pvarChild->lVal = CHILDID_SELF; return S_OK; selectedCell: pvarChild->vt = VT_I4; pvarChild->pdispVal = (IDispatch *) newTableAcc(TA->t, ROLE_SYSTEM_CELL, TA->what.row, TA->what.column); return S_OK; } static HRESULT STDMETHODCALLTYPE tableAccget_accSelection(IAccessible *this, VARIANT *pvarChildren) { if (TA->t == NULL || TA->std == NULL) { // TODO set values on error return RPC_E_DISCONNECTED; } return IAccessible_get_accSelection(TA->std, pvarChildren); } static HRESULT STDMETHODCALLTYPE tableAccget_accDefaultAction(IAccessible *this, VARIANT varChild, BSTR *pszDefaultAction) { HRESULT hr; tableAccWhat what; if (pszDefaultAction == NULL) return E_POINTER; *pszDefaultAction = NULL; if (TA->t == NULL || TA->std == NULL) return RPC_E_DISCONNECTED; what = TA->what; hr = normalizeWhat(TA, varChild, &what); if (hr != S_OK) return hr; if (what.role == ROLE_SYSTEM_CELL) ; // TODO implement this for checkbox cells? return DISP_E_MEMBERNOTFOUND; } // TODO should this method result in an event? // TODO [EDGE CASE] how do we deselect? in the table or in the row? wouldn't this go against multiple selection? // TODO require cell rows to be selected before focusing? static HRESULT STDMETHODCALLTYPE tableAccaccSelect(IAccessible *this, long flagsSelect, VARIANT varChild) { HRESULT hr; tableAccWhat what; if (TA->t == NULL || TA->std == NULL) return RPC_E_DISCONNECTED; what = TA->what; hr = normalizeWhat(TA, varChild, &what); if (hr != S_OK) return hr; if (what.role == ROLE_SYSTEM_TABLE) // defer to the standard accessible object return IAccessible_accSelect(TA->std, flagsSelect, varChild); // reject flags that are only applicable to multiple selection if ((flagsSelect & (SELFLAG_EXTENDSELECTION | SELFLAG_ADDSELECTION | SELFLAG_REMOVESELECTION)) != 0) return E_INVALIDARG; // and do nothing if a no-op if (flagsSelect == SELFLAG_NONE) return S_FALSE; // TODO cast ~ expressions to the correct type switch (what.role) { case ROLE_SYSTEM_ROW: // reject any other flag if ((flagsSelect & (~SELFLAG_TAKESELECTION)) != 0) return E_INVALIDARG; if ((flagsSelect & SELFLAG_TAKESELECTION) != 0) { if (TA->t->nColumns == 0) // can't select return S_FALSE; // if no column selected, select first (congruent to behavior of certain keyboard events) // TODO handle GetLastError() if (TA->t->selectedColumn == -1) doselect(TA->t, what.row, TA->t->selectedColumn); else doselect(TA->t, what.row, 0); return S_OK; } return S_FALSE; case ROLE_SYSTEM_CELL: // reject any other flag if ((flagsSelect & (~SELFLAG_TAKEFOCUS)) != 0) return E_INVALIDARG; if ((flagsSelect & SELFLAG_TAKEFOCUS) != 0) { doselect(TA->t, what.row, what.column); return S_OK; } return S_FALSE; } // TODO actually do this right // TODO un-GetLastError() this panic("impossible blah blah blah TODO write this"); return E_FAIL; } static HRESULT STDMETHODCALLTYPE tableAccaccLocation(IAccessible *this, long *pxLeft, long *pyTop, long *pcxWidth, long *pcyHeight, VARIANT varChild) { HRESULT hr; tableAccWhat what; RECT r; POINT pt; struct rowcol rc; if (pxLeft == NULL || pyTop == NULL || pcxWidth == NULL || pcyHeight == NULL) return E_POINTER; // TODO set the out parameters to zero? if (TA->t == NULL || TA->std == NULL) return RPC_E_DISCONNECTED; what = TA->what; hr = normalizeWhat(TA, varChild, &what); if (hr != S_OK) return hr; switch (what.role) { case ROLE_SYSTEM_TABLE: return IAccessible_accLocation(TA->std, pxLeft, pyTop, pcxWidth, pcyHeight, varChild); case ROLE_SYSTEM_ROW: // TODO actually write this return E_FAIL; case ROLE_SYSTEM_CELL: rc.row = what.row; rc.column = what.column; if (!rowColumnToClientRect(TA->t, rc, &r)) { // TODO [EDGE CASE] what do we do here? // TODO we have to return something indicating that the object is off-screen } // TODO [EDGE CASE] intersect with client rect? break; } pt.x = r.left; pt.y = r.top; if (ClientToScreen(TA->t->hwnd, &pt) == 0) return HRESULT_FROM_WIN32(GetLastError()); *pxLeft = pt.x; *pyTop = pt.y; *pcxWidth = r.right - r.left; *pcyHeight = r.bottom - r.top; return S_OK; } static HRESULT STDMETHODCALLTYPE tableAccaccNavigate(IAccessible *this, long navDir, VARIANT varStart, VARIANT *pvarEndUpAt) { HRESULT hr; tableAccWhat what; intptr_t row = -1; intptr_t column = -1; if (pvarEndUpAt == NULL) return E_POINTER; // TODO set pvarEndUpAt to an invalid value? if (TA->t == NULL || TA->std == NULL) return RPC_E_DISCONNECTED; what = TA->what; hr = normalizeWhat(TA, varStart, &what); if (hr != S_OK) return hr; switch (what.role) { case ROLE_SYSTEM_TABLE: switch (navDir) { case NAVDIR_FIRSTCHILD: // TODO header row if (TA->t->count == 0) goto nowhere; row = 0; goto specificRow; case NAVDIR_LASTCHILD: // TODO header row if (TA->t->count == 0) goto nowhere; row = TA->t->count - 1; goto specificRow; } // otherwise, defer to the standard accessible object return IAccessible_accNavigate(TA->std, navDir, varStart, pvarEndUpAt); case ROLE_SYSTEM_ROW: row = what.row; switch (navDir) { case NAVDIR_UP: case NAVDIR_PREVIOUS: if (row == 0) // can't go up goto nowhere; row--; // row should still be valid because normalizeWhat() returns an error if the current row is no longer valid, and if that's valid, the row above it should also be valid goto specificRow; case NAVDIR_DOWN: case NAVDIR_NEXT: if (row == TA->t->count - 1) // can't go down goto nowhere; row++; // row should still be valid by the above conjecture goto specificRow; case NAVDIR_LEFT: case NAVDIR_RIGHT: goto nowhere; // TODO this doesn't actually exist yet https://msdn.microsoft.com/en-us/library/ms971325 talks about it // case NAVDIR_PARENT: // goto tableItself; case NAVDIR_FIRSTCHILD: if (TA->t->nColumns == 0) goto nowhere; column = 0; goto specificCell; case NAVDIR_LASTCHILD: if (TA->t->nColumns == 0) goto nowhere; column = TA->t->nColumns - 1; goto specificCell; } // TODO differentiate between unsupported navigation directions and invalid navigation directions goto nowhere; case ROLE_SYSTEM_CELL: row = what.row; column = what.column; switch (navDir) { case NAVDIR_UP: if (row == 0) // can't go up goto nowhere; row--; goto specificCell; case NAVDIR_DOWN: if (row == TA->t->count - 1) // can't go down goto nowhere; row++; goto specificCell; case NAVDIR_LEFT: case NAVDIR_PREVIOUS: if (column == 0) // can't go left goto nowhere; column--; goto specificCell; case NAVDIR_RIGHT: case NAVDIR_NEXT: if (column == TA->t->nColumns - 1) // can't go right goto nowhere; column++; goto specificCell; // TODO this doesn't actually exist yet https://msdn.microsoft.com/en-us/library/ms971325 talks about it // case NAVDIR_PARENT: // goto specificRow; case NAVDIR_FIRSTCHILD: case NAVDIR_LASTCHILD: goto nowhere; } // TODO differentiate between unsupported navigation directions and invalid navigation directions goto nowhere; } // TODO actually do this right // TODO un-GetLastError() this panic("impossible blah blah blah TODO write this"); return E_FAIL; nowhere: pvarEndUpAt->vt = VT_EMPTY; return S_FALSE; tableItself: pvarEndUpAt->vt = VT_DISPATCH; pvarEndUpAt->pdispVal = (IDispatch *) newTableAcc(TA->t, ROLE_SYSTEM_TABLE, -1, -1); return S_OK; specificRow: pvarEndUpAt->vt = VT_DISPATCH; pvarEndUpAt->pdispVal = (IDispatch *) newTableAcc(TA->t, ROLE_SYSTEM_ROW, row, -1); return S_OK; specificCell: pvarEndUpAt->vt = VT_DISPATCH; pvarEndUpAt->pdispVal = (IDispatch *) newTableAcc(TA->t, ROLE_SYSTEM_CELL, row, column); return S_OK; } // TODO [EDGE CASE??] should this ever return parents? static HRESULT STDMETHODCALLTYPE tableAccaccHitTest(IAccessible *this, long xLeft, long yTop, VARIANT *pvarChild) { POINT pt; struct rowcol rc; RECT r; if (pvarChild == NULL) return E_POINTER; // TODO set pvarChild to an invalid value? if (TA->t == NULL || TA->std == NULL) return RPC_E_DISCONNECTED; pt.x = xLeft; pt.y = yTop; if (ScreenToClient(TA->t->hwnd, &pt) == 0) return HRESULT_FROM_WIN32(GetLastError()); // first see if the point is even IN the table if (GetClientRect(TA->t->hwnd, &r) == 0) return HRESULT_FROM_WIN32(GetLastError()); r.top += TA->t->headerHeight; if (PtInRect(&r, pt) == 0) goto outside; // now see if we're in a cell or in the table // TODO also handle GetLastError() here rc = clientCoordToRowColumn(TA->t, pt); switch (TA->what.role) { case ROLE_SYSTEM_TABLE: // either the table or the cell if (rc.row == -1 || rc.column == -1) goto self; goto specificCell; case ROLE_SYSTEM_ROW: // a specific cell, but only if in the same row // TODO actually do we really need these spurious rc.column ==/!= -1 checks? if (rc.row == TA->what.row) { if (rc.column == -1) // TODO de-GetLastError() this panic("impossible situation TODO write this"); goto specificCell; } goto outside; case ROLE_SYSTEM_CELL: if (rc.row == TA->what.row && rc.column == TA->what.column) goto self; goto outside; } // TODO actually do this right // TODO un-GetLastError() this panic("impossible blah blah blah TODO write this"); return E_FAIL; outside: pvarChild->vt = VT_EMPTY; return S_FALSE; self: pvarChild->vt = VT_I4; pvarChild->lVal = CHILDID_SELF; return S_OK; specificCell: pvarChild->vt = VT_DISPATCH; // TODO GetLastError() here too pvarChild->pdispVal = (IDispatch *) newTableAcc(TA->t, ROLE_SYSTEM_CELL, rc.row, rc.column); return S_OK; } static HRESULT STDMETHODCALLTYPE tableAccaccDoDefaultAction(IAccessible *this, VARIANT varChild) { HRESULT hr; tableAccWhat what; if (TA->t == NULL || TA->std == NULL) return RPC_E_DISCONNECTED; what = TA->what; hr = normalizeWhat(TA, varChild, &what); if (hr != S_OK) return hr; if (what.role == ROLE_SYSTEM_CELL) ; // TODO implement this for checkbox cells? return DISP_E_MEMBERNOTFOUND; } static HRESULT STDMETHODCALLTYPE tableAccput_accName(IAccessible *this, VARIANT varChild, BSTR szName) { if (TA->t == NULL || TA->std == NULL) { // TODO set values on error return RPC_E_DISCONNECTED; } return IAccessible_put_accName(TA->std, varChild, szName); } static HRESULT STDMETHODCALLTYPE tableAccput_accValue(IAccessible *this, VARIANT varChild, BSTR szValue) { if (TA->t == NULL || TA->std == NULL) { // TODO set values on error return RPC_E_DISCONNECTED; } return IAccessible_put_accValue(TA->std, varChild, szValue); } static const IAccessibleVtbl tableAccVtbl = { .QueryInterface = tableAccQueryInterface, .AddRef = tableAccAddRef, .Release = tableAccRelease, .GetTypeInfoCount = tableAccGetTypeInfoCount, .GetTypeInfo = tableAccGetTypeInfo, .GetIDsOfNames = tableAccGetIDsOfNames, .Invoke = tableAccInvoke, .get_accParent = tableAccget_accParent, .get_accChildCount = tableAccget_accChildCount, .get_accChild = tableAccget_accChild, .get_accName = tableAccget_accName, .get_accValue = tableAccget_accValue, .get_accDescription = tableAccget_accDescription, .get_accRole = tableAccget_accRole, .get_accState = tableAccget_accState, .get_accHelp = tableAccget_accHelp, .get_accHelpTopic = tableAccget_accHelpTopic, .get_accKeyboardShortcut = tableAccget_accKeyboardShortcut, .get_accFocus = tableAccget_accFocus, .get_accSelection = tableAccget_accSelection, .get_accDefaultAction = tableAccget_accDefaultAction, .accSelect = tableAccaccSelect, .accLocation = tableAccaccLocation, .accNavigate = tableAccaccNavigate, .accHitTest = tableAccaccHitTest, .accDoDefaultAction = tableAccaccDoDefaultAction, .put_accName = tableAccput_accName, .put_accValue = tableAccput_accValue, }; static struct tableAcc *newTableAcc(struct table *t, LONG role, intptr_t row, intptr_t column) { struct tableAcc *ta; HRESULT hr; IAccessible *std; ta = (struct tableAcc *) tableAlloc(sizeof (struct tableAcc), "error creating Table accessibility object"); ta->vtbl = &tableAccVtbl; ta->refcount = 1; ta->t = t; // TODO adjust last argument hr = CreateStdAccessibleObject(t->hwnd, OBJID_CLIENT, &IID_IAccessible, (void **) (&std)); if (hr != S_OK) // TODO panichresult panic("error creating standard accessible object for Table"); ta->std = std; ta->what.role = role; ta->what.row = row; ta->what.column = column; #ifdef TABLE_DEBUG_LINKEDLIST printf("before add:"); list(t); #endif ta->next = t->firstAcc; if (t->firstAcc != NULL) t->firstAcc->prev = ta; t->firstAcc = ta; #ifdef TABLE_DEBUG_LINKEDLIST printf("after add:"); list(t); #endif return ta; } static void invalidateTableAccs(struct table *t) { struct tableAcc *ta; for (ta = t->firstAcc; ta != NULL; ta = ta->next) { ta->t = NULL; IAccessible_Release(ta->std); ta->std = NULL; } t->firstAcc = NULL; } HANDLER(accessibilityHandler) { struct tableAcc *ta; if (uMsg != WM_GETOBJECT) return FALSE; // OBJID_CLIENT evaluates to an expression of type LONG // the documentation for WM_GETOBJECT says to cast "it" to a DWORD before comparing // https://msdn.microsoft.com/en-us/library/windows/desktop/dd373624%28v=vs.85%29.aspx casts them both to DWORDs; let's do that // its two siblings only cast lParam, resulting in an erroneous DWORD to LONG comparison // The Old New Thing book does not cast anything // Microsoft's MSAA sample casts lParam to LONG instead! // (As you can probably tell, the biggest problem with MSAA is that its documentation is ambiguous and/or self-contradictory...) if (((DWORD) lParam) != ((DWORD) OBJID_CLIENT)) return FALSE; ta = newTableAcc(t, ROLE_SYSTEM_TABLE, -1, -1); *lResult = LresultFromObject(&IID_IAccessible, wParam, (LPUNKNOWN) (ta)); // TODO check *lResult // TODO adjust pointer IAccessible_Release((IAccessible *) ta); return TRUE; }