static void test_AccessibleObjectFromWindow(void)
{
IUnknown *unk;
HRESULT hr;
HWND hwnd;
hr = AccessibleObjectFromWindow(NULL, OBJID_CURSOR, &IID_IUnknown, NULL);
ok(hr == E_INVALIDARG, "got %x\n", hr);
hr = AccessibleObjectFromWindow(NULL, OBJID_CURSOR, &IID_IUnknown, (void**)&unk);
todo_wine ok(hr == S_OK, "got %x\n", hr);
if(hr == S_OK) IUnknown_Release(unk);
hwnd = CreateWindowA("oleacc_test", "test", WS_OVERLAPPEDWINDOW,
0, 0, 0, 0, NULL, NULL, NULL, NULL);
ok(hwnd != NULL, "CreateWindow failed\n");
hr = AccessibleObjectFromWindow(hwnd, OBJID_CURSOR, &IID_IUnknown, (void**)&unk);
ok(hr == E_UNEXPECTED, "got %x\n", hr);
ok(Object_ref == 1, "Object_ref = %d\n", Object_ref);
hr = AccessibleObjectFromWindow(hwnd, OBJID_CLIENT, &IID_IUnknown, (void**)&unk);
ok(hr == S_OK, "got %x\n", hr);
ok(Object_ref == 2, "Object_ref = %d\n", Object_ref);
IUnknown_Release(unk);
DestroyWindow(hwnd);
}
SEXP
R_connect_hWnd(SEXP className, SEXP excel_hWnd, SEXP raiseError)
{
IUnknown *unknown = NULL;
HRESULT hr;
SEXP ans = R_NilValue;
CLSID classId;
LONG_PTR l_hwnd;
HWND temp_hwdn;
if(R_getCLSIDFromString(className, &classId) == S_OK) {
l_hwnd = (LONG_PTR)INTEGER(excel_hWnd)[0];
temp_hwdn = (HWND)l_hwnd;
hr = AccessibleObjectFromWindow(temp_hwdn, OBJID_NATIVEOM, classId, (void**)&unknown);
if(hr == S_OK) {
void *ptr;
hr = unknown->QueryInterface(IID_IDispatch, &ptr);
ans = R_createRCOMUnknownObject((void *) ptr, "COMIDispatch");
} else {
if(LOGICAL(raiseError)[0]) {
/* From COMError.cpp - COMError */
TCHAR buf[512];
GetScodeString(hr, buf, sizeof(buf)/sizeof(buf[0]));
PROTECT(ans = mkString(buf));
SET_CLASS(ans, mkString("COMErrorString"));
UNPROTECT(1);
return(ans);
} else
return(R_NilValue);
}
} else {
PROBLEM "Couldn't get clsid from the string"
WARN;
}
return(ans);
}
//****************************************************************************
HRESULT CBCGPToolBoxEx::accHitTest(long xLeft, long yTop, VARIANT *pvarChild)
{
if (!pvarChild)
{
return E_INVALIDARG;
}
CPoint pt(xLeft, yTop);
CWnd* pWnd = CWnd::WindowFromPoint(pt);
if (pWnd == this)
{
pvarChild->lVal = CHILDID_SELF;
pvarChild->vt = VT_I4;
return S_OK;
}
pvarChild->pdispVal = NULL;
pvarChild->vt = VT_DISPATCH;
AccessibleObjectFromWindow(pWnd->GetSafeHwnd(), (DWORD)OBJID_CLIENT, IID_IAccessible, (void**)&pvarChild->pdispVal);
if (pvarChild->pdispVal != NULL)
{
return S_OK;
}
return S_FALSE;
}
//****************************************************************************
HRESULT CBCGPToolBoxEx::get_accChild(VARIANT varChild, IDispatch** ppdispChild)
{
if (ppdispChild == NULL)
{
return E_INVALIDARG;
}
if ((varChild.vt == VT_I4) && (varChild.lVal >= 1))
{
int nPage = varChild.lVal - 1;
CBCGPToolBoxPage* pPage = GetPage(nPage);
if (pPage->GetSafeHwnd() != NULL)
{
*ppdispChild = NULL;
AccessibleObjectFromWindow(pPage->GetSafeHwnd(), (DWORD)OBJID_CLIENT, IID_IAccessible, (void**)ppdispChild);
if (*ppdispChild != NULL)
{
return S_OK;
}
}
}
return S_FALSE;
}
static HRESULT WINAPI Client_accHitTest(IAccessible *iface,
LONG xLeft, LONG yTop, VARIANT *pvarID)
{
Client *This = impl_from_Client(iface);
HWND child;
POINT pt;
TRACE("(%p)->(%d %d %p)\n", This, xLeft, yTop, pvarID);
V_VT(pvarID) = VT_I4;
V_I4(pvarID) = 0;
pt.x = xLeft;
pt.y = yTop;
if(!IsWindowVisible(This->hwnd) || !ScreenToClient(This->hwnd, &pt))
return S_OK;
child = ChildWindowFromPointEx(This->hwnd, pt, CWP_SKIPINVISIBLE);
if(!child || child==This->hwnd)
return S_OK;
V_VT(pvarID) = VT_DISPATCH;
return AccessibleObjectFromWindow(child, OBJID_WINDOW,
&IID_IDispatch, (void**)&V_DISPATCH(pvarID));
}
static HRESULT WINAPI Client_get_accParent(IAccessible *iface, IDispatch **ppdispParent)
{
Client *This = impl_from_Client(iface);
TRACE("(%p)->(%p)\n", This, ppdispParent);
return AccessibleObjectFromWindow(This->hwnd, OBJID_WINDOW,
&IID_IDispatch, (void**)ppdispParent);
}
HRESULT AccessibleObject::FromWindow(HWND hwnd, DWORD object_id) {
if (hwnd == nullptr)
return E_INVALIDARG;
Release();
return AccessibleObjectFromWindow(hwnd, object_id, IID_IAccessible,
(void**)&acc_);
}
//-----------------------------------------------------------------------------
// CheckURLProc()
//-----------------------------------------------------------------------------
// ISSUE#XX : nouvelle fonction d'énumération des childs en remplacement
// du GetDlgItem qui ne trouvait pas le bouton "NOuveau mot de passe"
// de la fenêtre de login de SAP
//-----------------------------------------------------------------------------
static int CALLBACK CheckURLProc(HWND w, LPARAM lp)
{
int iAction;
iAction=((T_CHECK_URL*)lp)->iAction;
int rc=TRUE;
char szCtrlURL[128+1];
HRESULT hr;
IAccessible *pAccessible=NULL;
BSTR bstrName=NULL;
TRACE((TRACE_DEBUG,_F_,"GetDlgCtrlID=%d",GetDlgCtrlID(w)));
// champ trouvé ou non recherché car * (ISSUE#271), il faut vérifier son libellé
if (GetDlgCtrlID(w)==((T_CHECK_URL*)lp)->iCtrlURL ||
((T_CHECK_URL*)lp)->iCtrlURL==-9999)
{
TRACE((TRACE_DEBUG,_F_,"Champ %d trouve, on verifie son libelle",((T_CHECK_URL*)lp)->iCtrlURL));
GetWindowText(w,szCtrlURL,sizeof(szCtrlURL));
TRACE((TRACE_DEBUG,_F_,"GetWindowText(0x%08lx)=%s",w,szCtrlURL));
if (*szCtrlURL==0) // pas de libellé trouvé, peut-être qu'on est dans un cas type SAP...
{
TRACE((TRACE_DEBUG,_F_,"Libelle vide, recherche via API accessibilite"));
hr=AccessibleObjectFromWindow(w,(DWORD)OBJID_CLIENT,IID_IAccessible,(void**)&pAccessible);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"AccessibleObjectFromWindow(IID_IAccessible)=0x%08lx",hr)); goto end; }
VARIANT vtMe;
vtMe.vt=VT_I4;
vtMe.lVal=CHILDID_SELF;
hr=pAccessible->get_accName(vtMe,&bstrName);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"pAccessible->get_accName()=0x%08lx",hr)); goto end; }
TRACE((TRACE_DEBUG,_F_,"Libelle=%S",bstrName));
wsprintf(szCtrlURL,"%S",bstrName); // waouh le beau risque de buffer overflow :-)
}
if (*szCtrlURL!=0) // // libellé trouvé, on vérifie que c'est le bon
{
if (swStringMatch(szCtrlURL,((T_CHECK_URL*)lp)->pszURL))
{
TRACE((TRACE_INFO,_F_,"Trouve le champ !"));
((T_CHECK_URL*)lp)->bFound=TRUE;
}
}
// ISSUE#271 : si *, on ne vérifie
if (((T_CHECK_URL*)lp)->iCtrlURL==-9999)
{
if (((T_CHECK_URL*)lp)->bFound)
rc=FALSE; // si trouvé, on arrête l'énumération
else
rc=TRUE; // libellé pas trouvé, on continue
}
else
rc=FALSE;// libellé correct ou pas, on arrête l'énum car on a trouvé un champ avec le bon ID donc inutile d'espérer en trouver un autre
}
end:
if (bstrName!=NULL) SysFreeString(bstrName);
if (pAccessible!=NULL) pAccessible->Release();
return rc;
}
//*********************************************************************************
HRESULT CBCGPToolBoxPage::get_accParent(IDispatch **ppdispParent)
{
if (ppdispParent == NULL)
{
return E_INVALIDARG;
}
*ppdispParent = NULL;
if (m_pToolBoxEx->GetSafeHwnd() != NULL)
{
return AccessibleObjectFromWindow(m_pToolBoxEx->GetSafeHwnd(), (DWORD)OBJID_WINDOW, IID_IAccessible, (void**)ppdispParent);
}
if (m_pToolBox->GetSafeHwnd() != NULL)
{
return AccessibleObjectFromWindow(m_pToolBox->GetSafeHwnd(), (DWORD)OBJID_WINDOW, IID_IAccessible, (void**)ppdispParent);
}
return S_FALSE;
}
static HRESULT WINAPI Client_EnumVARIANT_Next(IEnumVARIANT *iface,
ULONG celt, VARIANT *rgVar, ULONG *pCeltFetched)
{
Client *This = impl_from_Client_EnumVARIANT(iface);
HWND cur = This->enum_pos, next;
ULONG fetched = 0;
HRESULT hr;
TRACE("(%p)->(%u %p %p)\n", This, celt, rgVar, pCeltFetched);
if(!celt) {
if(pCeltFetched)
*pCeltFetched = 0;
return S_OK;
}
if(!This->enum_pos)
next = GetWindow(This->hwnd, GW_CHILD);
else
next = GetWindow(This->enum_pos, GW_HWNDNEXT);
while(next) {
cur = next;
V_VT(rgVar+fetched) = VT_DISPATCH;
hr = AccessibleObjectFromWindow(cur, OBJID_WINDOW,
&IID_IDispatch, (void**)&V_DISPATCH(rgVar+fetched));
if(FAILED(hr)) {
V_VT(rgVar+fetched) = VT_EMPTY;
while(fetched > 0) {
VariantClear(rgVar+fetched-1);
fetched--;
}
if(pCeltFetched)
*pCeltFetched = 0;
return hr;
}
fetched++;
if(fetched == celt)
break;
next = GetWindow(cur, GW_HWNDNEXT);
}
This->enum_pos = cur;
if(pCeltFetched)
*pCeltFetched = fetched;
return celt == fetched ? S_OK : S_FALSE;
}
//-----------------------------------------------------------------------------
// GetW7PopupIAccessible()
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
IAccessible *GetW7PopupIAccessible(HWND w)
{
TRACE((TRACE_ENTER,_F_, "w=0x%08lx",w));
HRESULT hr;
IAccessible *pAccessible=NULL;
gwW7PopupChild=NULL;
EnumChildWindows(w,W7PopupEnumChildProc,0);
if (gwW7PopupChild==NULL) goto end;
TRACE((TRACE_DEBUG,_F_,"w=0x%08lx gwW7PopupChild=0x%08lx",w,gwW7PopupChild));
// récupère pointeur IAccessible
hr=AccessibleObjectFromWindow(gwW7PopupChild,(DWORD)OBJID_CLIENT,IID_IAccessible,(void**)&pAccessible);
if (FAILED(hr))
{
TRACE((TRACE_ERROR,_F_,"AccessibleObjectFromWindow()=0x%08lx",hr));
goto end;
}
end:
TRACE((TRACE_LEAVE,_F_, "pAccessible=0x%08lx",pAccessible));
return pAccessible;
}
void ThreadProc( void* param )
{
CoInitialize(NULL);
thread_id_accget_ = GetCurrentThreadId();
MSG msg;
PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
while(GetMessage(&msg, NULL, 0, 0))
{
TCHAR buf[256];
CComPtr<IAccessible> acc;
if (S_OK == AccessibleObjectFromWindow((HWND)msg.lParam, OBJID_WINDOW, IID_IAccessible, (void**)&acc))
{
VARIANT id;
id.vt = VT_I4;
id.lVal = 0;
GetObjectValue(acc, &id, buf, ARRAYSIZE(buf));
OutputDebugString(TEXT("WinRun Text : "));
OutputDebugString(buf);
}
}
CoUninitialize();
}
// ----------------------------------------------------------------------------------
// SSOWebAccessible()
// ----------------------------------------------------------------------------------
// SSO commun aux navigateurs implémentant l'interface IAccessible
// Utilise forcément la méthode de configuration simplifiée
// ----------------------------------------------------------------------------------
// [out] 0=OK, -1=pas réussi (champs non trouvés ou autre erreur)
// ----------------------------------------------------------------------------------
int SSOWebAccessible(HWND w,int iAction,int iBrowser)
{
TRACE((TRACE_ENTER,_F_, "w=0x%08lx iAction=%d iBrowser=%d",w,iAction,iBrowser));
int rc=-1;
IAccessible *pAccessible=NULL;
IAccessible *pTopAccessible=NULL;
IDispatch *pIDispatch=NULL;
int i;
T_SUIVI_ACCESSIBLE tSuivi,*ptSuivi;
HRESULT hr;
long lCount;
VARIANT vtChild,vtState;
int iId1Index;
int iId2Index;
int iId3Index;
int iId4Index;
IAccessible *pNiveau0=NULL,*pChildNiveau1=NULL, *pChildNiveau2=NULL;
int iNbTry;
// ISSUE#39 : important, initialisation pour que le pointer iAccessible soit à NULL sinon le release provoque plantage !
ZeroMemory(&tSuivi,sizeof(T_SUIVI_ACCESSIBLE));
// BROWSER_MAXTHON: strcpy_s(tSuivi.szClassName,sizeof(tSuivi.szClassName),"Afx:400000:2008:10011:0:0");
tSuivi.w=NULL;
if (iBrowser==BROWSER_IE)
{
// enum des fils à la recherche de la fenêtre de rendu Web
// ISSUE#70 0.95 essaie aussi avec contenu flash (à faire en 1er)
// pour tester le flash : http://itmj.homelinux.org:9090/workspace/Main.html?ap=1
strcpy_s(tSuivi.szClassName,sizeof(tSuivi.szClassName),"MacromediaFlashPlayerActiveX");
EnumChildWindows(w,WebEnumChildProc,(LPARAM)&tSuivi);
if (tSuivi.w!=NULL) { TRACE((TRACE_INFO,_F_,"MacromediaFlashPlayerActiveX. Visible = %d",IsWindowVisible(tSuivi.w))); }
if (tSuivi.w==NULL || ((tSuivi.w!=NULL) && (!IsWindowVisible(tSuivi.w)))) // pas trouvé de flash ou trouvé flash mais non visible
{
strcpy_s(tSuivi.szClassName,sizeof(tSuivi.szClassName),"Internet Explorer_Server");
EnumChildWindows(w,WebEnumChildProc,(LPARAM)&tSuivi);
if (tSuivi.w!=NULL) { TRACE((TRACE_INFO,_F_,"Internet Explorer_Server = %d",IsWindowVisible(tSuivi.w))); }
}
if (tSuivi.w==NULL) { TRACE((TRACE_ERROR,_F_,"EnumChildWindows() => pas trouve la fenetre de contenu")); goto end; }
// Obtient un IAccessible
hr=AccessibleObjectFromWindow(tSuivi.w,(DWORD)OBJID_CLIENT,IID_IAccessible,(void**)&pAccessible);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"AccessibleObjectFromWindow(IID_IAccessible)=0x%08lx",hr)); goto end; }
}
else if (iBrowser==BROWSER_CHROME)
{
// enum des fils à la recherche de la fenêtre de rendu Web
strcpy_s(tSuivi.szClassName,sizeof(tSuivi.szClassName),"Chrome_RenderWidgetHostHWND");
// ISSUE #98 . 0.99 : pour chrome 33 ou 34+, l'énumération refonctionne (cf ISSUE#95 plus bas) mais la fenêtre
// qu'on récupère ne fonctionne pas. Elle a un vtRole.lVal=0x0000000a au lieu de vtRole.lVal=0x0000000f, et 0 childs !
// La version 34 de Chrome se reconnait grace à la fenêtre de classe static qui est remontée juste avant celle
// qu'on cherche, du coup si je trouve fenêtre static, je rebranche sur la recherche sans énumération
// 11/01-15:53:58:470 DEBUG WebEnumChildProc Fenetre classe=Static w=0x00030618
// 11/01-15:53:58:470 DEBUG WebEnumChildProc Fenetre classe=Chrome_RenderWidgetHostHWND w=0x00080120
strcpy_s(tSuivi.szExclude,sizeof(tSuivi.szExclude),"Static");
EnumChildWindows(w,WebEnumChildProc,(LPARAM)&tSuivi);
if (tSuivi.w==NULL)
{
// ISSUE#95 / 0.98 : pour Chome 31 ou 32+, impossible de rechercher la fenêtre fille, on est obligé de passer par IAccessible :
// La fenêtre principale a 1 child de niveau 1, il faut prendre le 1er.
// Le child de niveau 1 a 2 childs, il faut prendre le 2eme.
// Le child de niveau 2 a 4 childs, il faut prendre le 2eme --> c'est la fenêtre de contenu web !
hr=AccessibleObjectFromWindow(w,(DWORD)OBJID_CLIENT,IID_IAccessible,(void**)&pNiveau0);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"AccessibleObjectFromWindow(IID_IAccessible)=0x%08lx",hr)); goto end; }
// La fenêtre principale a 1 child de niveau 1, il faut prendre le 1er.
vtChild.vt=VT_I4;
vtChild.lVal=1;
hr=pNiveau0->get_accChild(vtChild,&pIDispatch);
TRACE((TRACE_DEBUG,_F_,"pAccessible->get_accChild(%ld)=0x%08lx",vtChild.lVal,hr));
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"get_accChild(%ld)=0x%08lx",vtChild.lVal,hr)); goto end; }
hr=pIDispatch->QueryInterface(IID_IAccessible, (void**) &pChildNiveau1);
TRACE((TRACE_DEBUG,_F_,"QueryInterface(IID_IAccessible)=0x%08lx",hr));
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"QueryInterface(IID_IAccessible)=0x%08lx",hr)); goto end; }
pIDispatch->Release(); pIDispatch=NULL;
// Le child de niveau 1 a 2 childs, il faut prendre le 2eme.
vtChild.vt=VT_I4;
vtChild.lVal=2;
hr=pChildNiveau1->get_accChild(vtChild,&pIDispatch);
TRACE((TRACE_DEBUG,_F_,"pChildNiveau1->get_accChild(%ld)=0x%08lx",vtChild.lVal,hr));
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"get_accChild(%ld)=0x%08lx",vtChild.lVal,hr)); goto end; }
hr=pIDispatch->QueryInterface(IID_IAccessible, (void**) &pChildNiveau2);
TRACE((TRACE_DEBUG,_F_,"QueryInterface(IID_IAccessible)=0x%08lx",hr));
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"QueryInterface(IID_IAccessible)=0x%08lx",hr)); goto end; }
pIDispatch->Release(); pIDispatch=NULL;
// Le child de niveau 2 a 4 childs, il faut prendre le 2eme.
vtChild.vt=VT_I4;
vtChild.lVal=2;
hr=pChildNiveau2->get_accChild(vtChild,&pIDispatch);
TRACE((TRACE_DEBUG,_F_,"pChildNiveau2->get_accChild(%ld)=0x%08lx",vtChild.lVal,hr));
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"get_accChild(%ld)=0x%08lx",vtChild.lVal,hr)); goto end; }
hr=pIDispatch->QueryInterface(IID_IAccessible, (void**) &pAccessible);
TRACE((TRACE_DEBUG,_F_,"QueryInterface(IID_IAccessible)=0x%08lx",hr));
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"QueryInterface(IID_IAccessible)=0x%08lx",hr)); goto end; }
pIDispatch->Release(); pIDispatch=NULL;
}
else
{
// Obtient un IAccessible
hr=AccessibleObjectFromWindow(tSuivi.w,(DWORD)OBJID_CLIENT,IID_IAccessible,(void**)&pAccessible);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"AccessibleObjectFromWindow(IID_IAccessible)=0x%08lx",hr)); goto end; }
}
VARIANT vtMe,vtRole;
vtMe.vt=VT_I4;
vtMe.lVal=CHILDID_SELF;
hr=pAccessible->get_accRole(vtMe,&vtRole);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"get_accRole()=0x%08lx",hr)); goto end; }
TRACE((TRACE_DEBUG,_F_,"get_accRole() vtRole.lVal=0x%08lx",vtRole.lVal));
}
else if (iBrowser==BROWSER_FIREFOX3 || iBrowser==BROWSER_FIREFOX4)
{
// accNavigate permet de trouver la fenêtre de rendu web
hr=AccessibleObjectFromWindow(w,(DWORD)OBJID_CLIENT,IID_IAccessible,(void**)&pTopAccessible);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"AccessibleObjectFromWindow(IID_IAccessible)=0x%08lx",hr)); goto end; }
VARIANT vtStart,vtResult;
vtStart.vt=VT_I4;
vtStart.lVal=CHILDID_SELF;
hr=pTopAccessible->accNavigate(0x1009,vtStart,&vtResult); // NAVRELATION_EMBEDS = 0x1009
pTopAccessible->Release();pTopAccessible=NULL;
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"accNavigate(NAVRELATION_EMBEDS)=0x%08lx",hr)); goto end; }
TRACE((TRACE_DEBUG,_F_,"accNavigate(NAVRELATION_EMBEDS) vtEnd=%ld",vtResult.lVal));
if (vtResult.vt!=VT_DISPATCH) { TRACE((TRACE_ERROR,_F_,"accNavigate(NAVRELATION_EMBEDS) is not VT_DISPATCH")); goto end; }
pIDispatch=(IDispatch*)vtResult.lVal;
if (pIDispatch==NULL) { TRACE((TRACE_ERROR,_F_,"accNavigate(NAVRELATION_EMBEDS) pIDispatch=NULL")); goto end; }
hr=pIDispatch->QueryInterface(IID_IAccessible, (void**)&pAccessible);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"QueryInterface(IID_IAccessible)=0x%08lx",hr)); goto end; }
}
// à ce stade, on a un pAccessible pour travailler, quel que soit le navigateur
vtChild.vt=VT_I4;
vtChild.lVal=CHILDID_SELF;
VariantInit(&vtState);
hr=pAccessible->get_accState(vtChild,&vtState);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"get_accState()=0x%08lx",hr)); goto end; }
TRACE((TRACE_DEBUG,_F_,"get_accState(DOCUMENT PRINCIPAL) vtState.lVal=0x%08lx",vtState.lVal));
// ISSUE#163 : plutôt que d'attendre 1 fois 5 secondes, on attend 5 fois 100ms et ensuite on continue,
// ça ne semble pas être bloquant surtout que Chrome et IE ont l'air de se mettre BUSY dès qu'ils n'ont pas le focus...
iNbTry=1;
while ((vtState.lVal & STATE_SYSTEM_BUSY) && iNbTry < 6)
{
TRACE((TRACE_DEBUG,_F_,"STATE_SYSTEM_BUSY -- wait 100ms before retry #%d (max 5)",iNbTry));
Sleep(100);
VariantInit(&vtState);
hr=pAccessible->get_accState(vtChild,&vtState);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"get_accState()=0x%08lx",hr)); }
TRACE((TRACE_DEBUG,_F_,"get_accState(DOCUMENT PRINCIPAL) vtState.lVal=0x%08lx",vtState.lVal));
iNbTry++;
}
lCount=0;
hr=pAccessible->get_accChildCount(&lCount);
TRACE((TRACE_DEBUG,_F_,"get_accChildCount() hr=0x%08lx lCount=%ld",hr,lCount));
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"get_accChildCount() hr=0x%08lx",hr)); goto end; }
if (iBrowser==BROWSER_CHROME) // lCount=0 arrive parfois quelque fois après ouverture d'un nouvel onglet
{
iNbTry=0;
while (lCount==0 && iNbTry<10) // ajouté en 0.93B1 : 10 essais supplémentaires au lieu d'un seul
{
Sleep(150);
pAccessible->Release();
pAccessible=NULL;
// Obtient un IAccessible
hr=AccessibleObjectFromWindow(tSuivi.w,(DWORD)OBJID_CLIENT,IID_IAccessible,(void**)&pAccessible);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"AccessibleObjectFromWindow(IID_IAccessible)=0x%08lx",hr)); goto end; }
hr=pAccessible->get_accChildCount(&lCount);
TRACE((TRACE_DEBUG,_F_,"get_accChildCount() hr=0x%08lx lCount=%ld",hr,lCount));
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"get_accChildCount() hr=0x%08lx",hr)); goto end; }
iNbTry++;
}
if (lCount==0) // ça n'a toujours pas marché, on abandonne...
{
TRACE((TRACE_ERROR,_F_,"get_accChildCount() hr=0x%08lx",hr)); goto end;
}
}
ZeroMemory(&tSuivi,sizeof(T_SUIVI_ACCESSIBLE)); // déplacé plus haut, mais laissé ici aussi dans le doute ça coute pas cher.
tSuivi.w=w;
tSuivi.iAction=iAction;
tSuivi.iErreur=0;
tSuivi.iLevel=0;
tSuivi.iPwdIndex=-1;
tSuivi.iNbPwdFound=0;
tSuivi.iBrowser=iBrowser; // ISSUE#279
#ifdef TRACES_ACTIVEES
DoWebAccessible("",w,pAccessible,&tSuivi);
#else
DoWebAccessible(w,pAccessible,&tSuivi);
#endif
TRACE((TRACE_INFO,_F_,"tSuivi.iErreur=%d",tSuivi.iErreur));
if (tSuivi.iErreur==0)
{
ptSuivi=&tSuivi;
vtChild.vt=VT_I4;
vtChild.lVal=CHILDID_SELF;
// 0.93B1 / ISSUE#40 : avant de démarrer les saisies, il faut vérifier qu'on a trouvé tous les champs attendus
// En effet, comme on ne cherche plus les champs par leurs noms, on peut provoquer des mises au premier plan intempestives
// de la fenêtre du navigateur si le titre et l'URL ne permettent pas de reconnaitre la page de login de manière certaine
TRACE((TRACE_INFO,_F_,"Page analysee, verification (lCount=%d ptSuivi->iTextFieldIndex=%d)",lCount,ptSuivi->iTextFieldIndex));
// 0.99B3 / ISSUE#103 : En mode configration simplifiée, la position du champ identifiant est considérée comme absolue
// si le champ de mot de passe est configuré à 0
// if (*gptActions[ptSuivi->iAction].szPwdName!=0 && ptSuivi->iPwdIndex==-1)
if (*gptActions[ptSuivi->iAction].szPwdName!=0 && atoi(gptActions[ptSuivi->iAction].szPwdName)!=0 && ptSuivi->iPwdIndex==-1)
{
TRACE((TRACE_ERROR,_F_,"Un champ mot de passe etait attendu mais n'a pas ete trouve => le SSO ne sera pas execute"));
goto end;
}
iId1Index=GetAbsolutePos(gptActions[ptSuivi->iAction].szId1Name,gptActions[ptSuivi->iAction].szPwdName,ptSuivi->iPwdIndex,ptSuivi);
iId2Index=GetAbsolutePos(gptActions[ptSuivi->iAction].szId2Name,gptActions[ptSuivi->iAction].szPwdName,ptSuivi->iPwdIndex,ptSuivi);
iId3Index=GetAbsolutePos(gptActions[ptSuivi->iAction].szId3Name,gptActions[ptSuivi->iAction].szPwdName,ptSuivi->iPwdIndex,ptSuivi);
iId4Index=GetAbsolutePos(gptActions[ptSuivi->iAction].szId4Name,gptActions[ptSuivi->iAction].szPwdName,ptSuivi->iPwdIndex,ptSuivi);
if (iId1Index==-1 || iId2Index==-1 || iId3Index==-1 || iId4Index==-1)
{
TRACE((TRACE_ERROR,_F_,"Au moins un des champs n'a pas ete trouve => le SSO ne sera pas execute"));
goto end;
}
// Vérification OK, on peut mettre la fenêtre au premier plan et démarrer les saisies
TRACE((TRACE_INFO,_F_,"Verifications OK, demarrage des saisies (lCount=%d ptSuivi->iTextFieldIndex=%d)",lCount,ptSuivi->iTextFieldIndex));
SetForegroundWindow(ptSuivi->w);
// ISSUE#266 : Bidouille contournement incident ouvert sur chromium : 533830
if (iBrowser==BROWSER_CHROME && gpAccessibleChromeURL!=NULL)
{
VARIANT vtSelf;
VARIANT vtURLBarState;
vtSelf.vt=VT_I4;
vtSelf.lVal=CHILDID_SELF;
hr=gpAccessibleChromeURL->get_accState(vtSelf,&vtURLBarState);
TRACE((TRACE_DEBUG,_F_,"get_accState() vtURLBarState.lVal=0x%08lx",vtURLBarState.lVal));
if (vtURLBarState.lVal & STATE_SYSTEM_FOCUSED)
{
TRACE((TRACE_INFO,_F_,"BIDOUILLE BARRE URL CHROME !")); // on tabule jusqu'à mettre le focus sur champ id1 ou pwd
KBSimEx(w,"[TAB]","","","","","");
int iAntiLoop=0;
VARIANT vtIdOrPwdState;
vtIdOrPwdState.lVal=0;
while ((!(vtIdOrPwdState.lVal & STATE_SYSTEM_FOCUSED)) && iAntiLoop <10)
{
KBSimEx(w,"[TAB]","","","","","");
Sleep(10);
if (iId1Index>=0)
{
hr=ptSuivi->pTextFields[iId1Index]->accSelect(SELFLAG_TAKEFOCUS,vtChild);
TRACE((TRACE_DEBUG,_F_,"accSelect(id1)=0x%08lx",hr));
hr=ptSuivi->pTextFields[iId1Index]->get_accState(vtSelf,&vtIdOrPwdState);
TRACE((TRACE_DEBUG,_F_,"get_accState(id1)=0x%08lx vtId1State.lVal=0x%08lx",hr,vtIdOrPwdState.lVal));
}
else if (ptSuivi->iPwdIndex!=-1)
{
hr=ptSuivi->pTextFields[ptSuivi->iPwdIndex]->accSelect(SELFLAG_TAKEFOCUS,vtChild);
TRACE((TRACE_DEBUG,_F_,"accSelect(pwd)=0x%08lx",hr));
hr=ptSuivi->pTextFields[ptSuivi->iPwdIndex]->get_accState(vtSelf,&vtIdOrPwdState);
TRACE((TRACE_DEBUG,_F_,"get_accState(pwd)=0x%08lx vtId1State.lVal=0x%08lx",hr,vtIdOrPwdState.lVal));
}
else // tant pis, cas à peu près impossible, on sort
{
break;
}
iAntiLoop++;
}
}
}
// fin bidouille chrome
if (iId1Index>=0) PutAccValue(ptSuivi->w,ptSuivi->pTextFields[iId1Index],vtChild,gptActions[ptSuivi->iAction].szId1Value);
if (iId2Index>=0) PutAccValue(ptSuivi->w,ptSuivi->pTextFields[iId2Index],vtChild,gptActions[ptSuivi->iAction].szId2Value);
if (iId3Index>=0) PutAccValue(ptSuivi->w,ptSuivi->pTextFields[iId3Index],vtChild,gptActions[ptSuivi->iAction].szId3Value);
if (iId4Index>=0) PutAccValue(ptSuivi->w,ptSuivi->pTextFields[iId4Index],vtChild,gptActions[ptSuivi->iAction].szId4Value);
// Mdp
if (ptSuivi->iPwdIndex!=-1)
{
// CODE A GARDER POUR BUGS OUVERTS CHEZ CHROME #75908 et #75911
/*
int iAntiLoop=0;
hr=ptSuivi->pTextFields[ptSuivi->iPwdIndex]->accSelect(SELFLAG_TAKEFOCUS,vtChild);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"accSelect(SELFLAG_TAKEFOCUS)=0x%08lx",hr)); }
TRACE((TRACE_DEBUG,_F_,"accSelect(SELFLAG_TAKEFOCUS)=0x%08lx",hr));
VARIANT vtSelf;
VARIANT vtState;
vtSelf.vt=VT_I4;
vtSelf.lVal=CHILDID_SELF;
hr=ptSuivi->pTextFields[ptSuivi->iPwdIndex]->get_accState(vtSelf,&vtState);
TRACE((TRACE_DEBUG,_F_,"get_accState() vtState.lVal=0x%08lx",vtState.lVal));
while (iAntiLoop <50)
//while ((!(vtState.lVal & STATE_SYSTEM_FOCUSED)) && iAntiLoop <10)
{
Sleep(100);
KBSimEx(w,"[TAB]","","","","","");
Sleep(100);
hr=ptSuivi->pTextFields[ptSuivi->iPwdIndex]->get_accState(vtSelf,&vtState);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"get_accState(CHILDID_SELF)=0x%08lx",hr)); }
TRACE((TRACE_DEBUG,_F_,"get_accState() vtState.lVal=0x%08lx",vtState.lVal));
iAntiLoop++;
}
*/
Sleep(100); // ISSUE#163 (et autres problèmes, notamment identifiant saisi tronqué avec le reste dans le mot de passe)
hr=ptSuivi->pTextFields[ptSuivi->iPwdIndex]->accSelect(SELFLAG_TAKEFOCUS,vtChild);
if (FAILED(hr)) // ISSUE#251 : en cas d'erreur du accSelect (vu UNE fois), on fait TAB à l'aveugle, ça évite de taper le mdp dans le champ id
{
TRACE((TRACE_ERROR,_F_,"accSelect(SELFLAG_TAKEFOCUS)=0x%08lx",hr));
// remarque : nombre de tab à faire = fonction de la position relative du champ id par rapport au champ mdp
Sleep(100);
for (i=0; i<abs(atoi(gptActions[ptSuivi->iAction].szId1Name));i++) { KBSimEx(w,"[TAB]","","","","",""); }
Sleep(100);
}
if ((*gptActions[ptSuivi->iAction].szPwdEncryptedValue!=0))
{
//char *pszPassword=swCryptDecryptString(gptActions[ptSuivi->iAction].szPwdEncryptedValue,ghKey1);
char *pszPassword=GetDecryptedPwd(gptActions[ptSuivi->iAction].szPwdEncryptedValue);
if (pszPassword!=NULL)
{
// 1.09B2 : essaie de faire put_accValue avant de se rabattre sur la simulation de frappe
BSTR bstrValue=GetBSTRFromSZ(pszPassword);
hr=S_OK;
if (bstrValue!=NULL)
{
hr=ptSuivi->pTextFields[ptSuivi->iPwdIndex]->put_accValue(vtChild,bstrValue);
TRACE((TRACE_INFO,_F_,"pAccessible->put_accValue() : hr=0x%08lx",hr));
}
if (bstrValue==NULL || FAILED(hr))
{
KBSim(ptSuivi->w,TRUE,100,pszPassword,TRUE);
}
if (bstrValue!=NULL)
{
SecureZeroMemory(bstrValue,SysStringByteLen(bstrValue));
SysFreeString(bstrValue); bstrValue=NULL;
}
SecureZeroMemory(pszPassword,strlen(pszPassword));
free(pszPassword);
}
}
}
// Validation si demandée
if (*gptActions[ptSuivi->iAction].szValidateName!=0)
{
Sleep(100);
// ISSUE#101
// KBSimEx(NULL,gptActions[ptSuivi->iAction].szValidateName,"","","","","");
// ISSUE#101 suite : on autorise aussi le mot de passe sinon c'est naze...
char szDecryptedPassword[LEN_PWD+1];
// char *pszPassword=swCryptDecryptString(gptActions[ptSuivi->iAction].szPwdEncryptedValue,ghKey1);
char *pszPassword=GetDecryptedPwd(gptActions[ptSuivi->iAction].szPwdEncryptedValue);
if (pszPassword!=NULL)
{
strcpy_s(szDecryptedPassword,sizeof(szDecryptedPassword),pszPassword);
SecureZeroMemory(pszPassword,strlen(pszPassword));
free(pszPassword);
}
else
{
*szDecryptedPassword=0;
}
KBSimEx(NULL,gptActions[ptSuivi->iAction].szValidateName,
gptActions[iAction].szId1Value,
gptActions[iAction].szId2Value,
gptActions[iAction].szId3Value,
gptActions[iAction].szId4Value,szDecryptedPassword);
SecureZeroMemory(szDecryptedPassword,sizeof(szDecryptedPassword));
}
guiNbWEBSSO++;
}
rc=0;
end:
for (i=0;i<MAX_TEXT_FIELDS;i++) if (tSuivi.pTextFields[i]!=NULL) tSuivi.pTextFields[i]->Release();
if (pAccessible!=NULL) pAccessible->Release();
if (pTopAccessible!=NULL) pTopAccessible->Release();
if (pIDispatch!=NULL) pIDispatch->Release();
if (pNiveau0!=NULL) pNiveau0->Release();
if (pChildNiveau1!=NULL) pChildNiveau1->Release();
if (pChildNiveau2!=NULL) pChildNiveau2->Release();
if (gpAccessibleChromeURL!=NULL) { gpAccessibleChromeURL->Release(); gpAccessibleChromeURL=NULL; }
TRACE((TRACE_LEAVE,_F_, "rc=%d",rc));
return rc;
}
static LRESULT CALLBACK WindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData )
{
if (uMsg==WM_WINDOWPOSCHANGING)
{
WINDOWPOS *pos=(WINDOWPOS*)lParam;
if (pos->flags&SWP_SHOWWINDOW)
{
wchar_t title[256];
GetWindowText(hWnd,title,_countof(title));
if (_wcsicmp(title,g_TitleMove)==0 || _wcsicmp(title,g_TitleCopy)==0)
{
// file UI
if (GetSettingBool(L"ReplaceFileUI"))
{
CString log;
bool bLog=GetSettingInt(L"LogLevel")>0;
CComPtr<IAccessible> pAcc;
HRESULT h=AccessibleObjectFromWindow(hWnd,OBJID_WINDOW,IID_IAccessible,(void**)&pAcc);
if (SUCCEEDED(h) && pAcc)
{
CClassicCopyFile copy;
if (copy.Run(hWnd,pAcc,bLog?&log:NULL))
{
pos->x=pos->y=-20000;
pos->flags&=~(SWP_SHOWWINDOW|SWP_NOMOVE);
}
}
else if (bLog)
LogPrint(&log,L"AccessibleObjectFromWindow: error=0x%X, hWnd=0x%X",h,(DWORD)hWnd);
if (bLog)
{
wchar_t fname[_MAX_PATH]=L"%LOCALAPPDATA%\\ExplorerLog.txt";
DoEnvironmentSubst(fname,_countof(fname));
if (!log.IsEmpty())
{
FILE *f;
if (_wfopen_s(&f,fname,L"wb")==0)
{
fwprintf(f,L"\xFEFF");
OSVERSIONINFOEX ver={sizeof(ver)};
GetVersionEx((OSVERSIONINFO*)&ver);
fwprintf(f,L"version = %d.%d.%d - %d.%d\r\n\r\n",ver.dwMajorVersion,ver.dwMinorVersion,ver.dwBuildNumber,ver.wServicePackMajor,ver.wServicePackMinor);
wchar_t languages[100]={0};
ULONG size=4; // up to 4 languages
ULONG len=_countof(languages);
GetThreadPreferredUILanguages(MUI_LANGUAGE_NAME,&size,languages,&len);
for (const wchar_t *lang=languages;*lang;lang+=wcslen(lang)+1)
fwprintf(f,L"language = %s\r\n",lang);
fwprintf(f,L"\r\n");
fwprintf(f,L"g_ButtonMove = '%s'\r\n",g_ButtonMove);
fwprintf(f,L"g_ButtonDontMove = '%s'\r\n",g_ButtonDontMove);
fwprintf(f,L"g_ButtonCopy = '%s'\r\n",g_ButtonCopy);
fwprintf(f,L"g_ButtonDontCopy = '%s'\r\n",g_ButtonDontCopy);
fwprintf(f,L"g_ButtonCancel = '%s'\r\n",g_ButtonCancel);
fwprintf(f,L"\r\n");
fwrite((const wchar_t*)log,log.GetLength(),2,f);
fclose(f);
}
}
else
DeleteFile(fname);
}
}
}
else if (_wcsicmp(title,g_TitleFolder)==0)
{
// folder UI
if (GetSettingBool(L"ReplaceFolderUI"))
{
CClassicCopyFolder copy;
if (copy.Run(hWnd))
{
pos->x=pos->y=-20000;
pos->flags&=~(SWP_SHOWWINDOW|SWP_NOMOVE);
}
}
}
else
{
// look for progress bar
if (GetSettingBool(L"EnableMore"))
{
HWND progress=FindChildWindow(hWnd,PROGRESS_CLASS);
if (progress)
{
bool bDef;
int delay=GetSettingInt(L"MoreProgressDelay",bDef);
if (bDef)
{
delay=0;
if (GetWinVersion()>=WIN_VER_WIN7)
{
BOOL comp;
if (SUCCEEDED(DwmIsCompositionEnabled(&comp)) && comp)
delay=500;
}
}
SetTimer(hWnd,'CLEX',delay,NULL);
return DefSubclassProc(hWnd,uMsg,wParam,lParam);
}
}
}
LRESULT res=DefSubclassProc(hWnd,uMsg,wParam,lParam);
RemoveWindowSubclass(hWnd,WindowProc,uIdSubclass);
return res;
}
}
if (uMsg==WM_TIMER && wParam=='CLEX')
{
KillTimer(hWnd,wParam);
CComPtr<IAccessible> pAcc;
HRESULT h=AccessibleObjectFromWindow(hWnd,OBJID_WINDOW,IID_IAccessible,(void**)&pAcc);
if (SUCCEEDED(h) && pAcc)
{
CComPtr<IAccessible> pMore=FindMoreButton(pAcc);
if (pMore) pMore->accDoDefaultAction(CComVariant(CHILDID_SELF));
}
LRESULT res=DefSubclassProc(hWnd,uMsg,wParam,lParam);
RemoveWindowSubclass(hWnd,WindowProc,uIdSubclass);
return res;
}
return DefSubclassProc(hWnd,uMsg,wParam,lParam);
}
void MyFrame::OnQuery(wxCommandEvent& WXUNUSED(event))
{
m_textCtrl->Clear();
IAccessible* accessibleFrame = NULL;
if (S_OK != AccessibleObjectFromWindow((HWND) GetHWND(), OBJID_CLIENT,
IID_IAccessible, (void**) & accessibleFrame))
{
Log(wxT("Could not get object."));
return;
}
if (accessibleFrame)
{
//Log(wxT("Got an IAccessible for the frame."));
LogObject(0, accessibleFrame);
Log(wxT("Checking children using AccessibleChildren()..."));
// Now check the AccessibleChildren function works OK
long childCount = 0;
if (S_OK != accessibleFrame->get_accChildCount(& childCount))
{
Log(wxT("Could not get number of children."));
accessibleFrame->Release();
return;
}
else if (childCount == 0)
{
Log(wxT("No children."));
accessibleFrame->Release();
return;
}
long obtained = 0;
VARIANT *var = new VARIANT[childCount];
int i;
for (i = 0; i < childCount; i++)
{
VariantInit(& (var[i]));
var[i].vt = VT_DISPATCH;
}
if (S_OK == AccessibleChildren(accessibleFrame, 0, childCount, var, &obtained))
{
for (i = 0; i < childCount; i++)
{
IAccessible* childAccessible = NULL;
if (var[i].pdispVal)
{
if (var[i].pdispVal->QueryInterface(IID_IAccessible, (LPVOID*) & childAccessible) == S_OK)
{
var[i].pdispVal->Release();
wxString name, role;
GetInfo(childAccessible, 0, name, role);
wxString str;
str.Printf(wxT("Found child %s/%s"), name.c_str(), role.c_str());
Log(str);
childAccessible->Release();
}
else
{
var[i].pdispVal->Release();
}
}
}
}
else
{
Log(wxT("AccessibleChildren failed."));
}
delete[] var;
accessibleFrame->Release();
}
}