1098 lines
29 KiB
C++
1098 lines
29 KiB
C++
// Copyright (c) 1996-1999 Microsoft Corporation
|
|
|
|
// --------------------------------------------------------------------------
|
|
//
|
|
// WINDOW.CPP
|
|
//
|
|
// Window class.
|
|
//
|
|
// --------------------------------------------------------------------------
|
|
|
|
#include "oleacc_p.h"
|
|
#include "default.h"
|
|
#include "classmap.h"
|
|
#include "ctors.h"
|
|
#include "client.h"
|
|
#include "window.h"
|
|
|
|
#pragma warning( disable : 4005 ) // macro redefinition
|
|
#define COMPILE_MULTIMON_STUBS
|
|
#include "multimon.h"
|
|
#pragma warning( default : 4005 )
|
|
|
|
|
|
#define MaskBit(n) (1 << (n))
|
|
|
|
#define IndexFromNavDir(navdir) (navdir - NAVDIR_UP)
|
|
|
|
// Remember, these are negative!
|
|
#define OBJID_WINDOW_FIRST OBJID_SIZEGRIP
|
|
#define OBJID_WINDOW_LAST OBJID_SYSMENU
|
|
|
|
typedef struct tagNAVIGATE
|
|
{
|
|
long NavPeer[4];
|
|
} NAVIGATE;
|
|
|
|
#ifndef CCHILDREN_FRAME
|
|
#define CCHILDREN_FRAME 7
|
|
#endif
|
|
|
|
// Order is Up, Down, Left, Right
|
|
NAVIGATE rgFrameNavigate[CCHILDREN_FRAME] =
|
|
{
|
|
// System menu
|
|
{
|
|
0, IndexFromObjid(OBJID_MENU), 0, IndexFromObjid(OBJID_TITLEBAR)
|
|
},
|
|
|
|
// Title bar
|
|
{
|
|
0, IndexFromObjid(OBJID_MENU), IndexFromObjid(OBJID_SYSMENU), 0
|
|
},
|
|
|
|
// Menu bar
|
|
{
|
|
IndexFromObjid(OBJID_TITLEBAR), IndexFromObjid(OBJID_CLIENT), 0, 0
|
|
},
|
|
|
|
// Client
|
|
{
|
|
IndexFromObjid(OBJID_MENU), IndexFromObjid(OBJID_HSCROLL), 0, IndexFromObjid(OBJID_VSCROLL)
|
|
},
|
|
|
|
// Vertical scrollbar
|
|
{
|
|
IndexFromObjid(OBJID_MENU), IndexFromObjid(OBJID_SIZEGRIP), IndexFromObjid(OBJID_CLIENT), 0
|
|
},
|
|
|
|
// Horizontal scrollbar
|
|
{
|
|
IndexFromObjid(OBJID_CLIENT), 0, 0, IndexFromObjid(OBJID_SIZEGRIP)
|
|
},
|
|
|
|
// Size grip
|
|
{
|
|
IndexFromObjid(OBJID_VSCROLL), 0, IndexFromObjid(OBJID_HSCROLL), 0
|
|
}
|
|
};
|
|
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
//
|
|
// CreateWindowObject()
|
|
//
|
|
// External function for CreateDefault...
|
|
//
|
|
// --------------------------------------------------------------------------
|
|
HRESULT CreateWindowObject(HWND hwnd, long idObject, REFIID riid, void** ppvWindow)
|
|
{
|
|
UNUSED(idObject);
|
|
|
|
InitPv(ppvWindow);
|
|
|
|
if (!IsWindow(hwnd))
|
|
return(E_FAIL);
|
|
|
|
// Look for (and create) a suitable proxy/handler if one
|
|
// exists. Use CreateWindowThing as default if none found.
|
|
// (TRUE => use window, as opposed to client, classes)
|
|
return FindAndCreateWindowClass( hwnd, TRUE, CLASS_WindowObject,
|
|
OBJID_WINDOW, 0, riid, ppvWindow );
|
|
}
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
//
|
|
// CreateWindowThing()
|
|
//
|
|
// Private function that uses atom type to decide what class of window
|
|
// this is. If there is a private create function, uses that one. Else
|
|
// uses generic window frame handler.
|
|
//
|
|
// --------------------------------------------------------------------------
|
|
HRESULT CreateWindowThing(HWND hwnd, long idChildCur, REFIID riid, void** ppvWindow)
|
|
{
|
|
CWindow * pwindow;
|
|
HRESULT hr;
|
|
|
|
InitPv(ppvWindow);
|
|
|
|
pwindow = new CWindow();
|
|
if (!pwindow)
|
|
return(E_OUTOFMEMORY);
|
|
|
|
// Can't be in the constructor--derived classes can't call the init
|
|
// code if so.
|
|
pwindow->Initialize(hwnd, idChildCur);
|
|
|
|
hr = pwindow->QueryInterface(riid, ppvWindow);
|
|
if (!SUCCEEDED(hr))
|
|
delete pwindow;
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
//
|
|
// CWindow::Initialize()
|
|
//
|
|
// --------------------------------------------------------------------------
|
|
void CWindow::Initialize(HWND hwnd, LONG iChild)
|
|
{
|
|
m_hwnd = hwnd;
|
|
m_cChildren = CCHILDREN_FRAME;
|
|
m_idChildCur = iChild;
|
|
}
|
|
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
//
|
|
// CWindow::ValidateChild()
|
|
//
|
|
// The window children are the OBJID_s of the elements that compose the
|
|
// frame. These are NEGATIVE values. Hence we override the validation.
|
|
//
|
|
// --------------------------------------------------------------------------
|
|
BOOL CWindow::ValidateChild(VARIANT* pvar)
|
|
{
|
|
//
|
|
// This validates a VARIANT parameter and translates missing/empty
|
|
// params.
|
|
//
|
|
|
|
TryAgain:
|
|
// Missing parameter, a la VBA
|
|
switch (pvar->vt)
|
|
{
|
|
case VT_VARIANT | VT_BYREF:
|
|
VariantCopy(pvar, pvar->pvarVal);
|
|
goto TryAgain;
|
|
|
|
case VT_ERROR:
|
|
if (pvar->scode != DISP_E_PARAMNOTFOUND)
|
|
return(FALSE);
|
|
// FALL THRU
|
|
|
|
case VT_EMPTY:
|
|
pvar->vt = VT_I4;
|
|
pvar->lVal = 0;
|
|
break;
|
|
|
|
// remove this! VT_I2 is not valid!!
|
|
#ifdef VT_I2_IS_VALID // it isn't now...
|
|
case VT_I2:
|
|
pvar->vt = VT_I4;
|
|
pvar->lVal = (long)pvar->iVal;
|
|
// FALL THROUGH
|
|
#endif
|
|
|
|
case VT_I4:
|
|
if ((pvar->lVal > 0) || (pvar->lVal < (long)OBJID_WINDOW_FIRST))
|
|
return(FALSE);
|
|
break;
|
|
|
|
default:
|
|
return(FALSE);
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
//
|
|
// CWindow::get_accParent()
|
|
//
|
|
// --------------------------------------------------------------------------
|
|
STDMETHODIMP CWindow::get_accParent(IDispatch ** ppdispParent)
|
|
{
|
|
HWND hwndParent;
|
|
|
|
InitPv(ppdispParent);
|
|
|
|
hwndParent = MyGetAncestor(m_hwnd, GA_PARENT);
|
|
if (! hwndParent)
|
|
return(S_FALSE);
|
|
|
|
return(AccessibleObjectFromWindow(hwndParent, OBJID_CLIENT, IID_IDispatch,
|
|
(void **)ppdispParent));
|
|
}
|
|
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
//
|
|
// CWindow::get_accChild()
|
|
//
|
|
// --------------------------------------------------------------------------
|
|
STDMETHODIMP CWindow::get_accChild(VARIANT varChild, IDispatch ** ppdispChild)
|
|
{
|
|
InitPv(ppdispChild);
|
|
|
|
//
|
|
// Validate parameters
|
|
//
|
|
if (! ValidateChild(&varChild))
|
|
return(E_INVALIDARG);
|
|
|
|
return(AccessibleObjectFromWindow(m_hwnd, varChild.lVal,
|
|
IID_IDispatch, (void**)ppdispChild));
|
|
}
|
|
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
//
|
|
// CWindow::get_accName()
|
|
//
|
|
// --------------------------------------------------------------------------
|
|
STDMETHODIMP CWindow::get_accName(VARIANT varChild, BSTR* pszName)
|
|
{
|
|
IAccessible * poleacc;
|
|
HRESULT hr;
|
|
|
|
InitPv(pszName);
|
|
|
|
//
|
|
// Validate parameters
|
|
//
|
|
if (! ValidateChild(&varChild))
|
|
return(E_INVALIDARG);
|
|
|
|
//
|
|
// If the caller want's our name, forward to the client object
|
|
//
|
|
if (varChild.lVal == CHILDID_SELF)
|
|
varChild.lVal = OBJID_CLIENT;
|
|
|
|
|
|
//
|
|
// Get the name of our child frame object.
|
|
//
|
|
poleacc = NULL;
|
|
hr = AccessibleObjectFromWindow(m_hwnd, varChild.lVal,
|
|
IID_IAccessible, (void **)&poleacc);
|
|
if (!SUCCEEDED(hr))
|
|
return(hr);
|
|
|
|
varChild.lVal = CHILDID_SELF;
|
|
hr = poleacc->get_accName(varChild, pszName);
|
|
poleacc->Release();
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
//
|
|
// CWindow::get_accDescription()
|
|
//
|
|
// --------------------------------------------------------------------------
|
|
STDMETHODIMP CWindow::get_accDescription(VARIANT varChild, BSTR* pszDesc)
|
|
{
|
|
InitPv(pszDesc);
|
|
|
|
//
|
|
// Validate parameters
|
|
//
|
|
if (! ValidateChild(&varChild))
|
|
return(E_INVALIDARG);
|
|
|
|
if (varChild.lVal == CHILDID_SELF)
|
|
{
|
|
return(S_FALSE);
|
|
}
|
|
else
|
|
{
|
|
IAccessible * poleacc;
|
|
HRESULT hr;
|
|
|
|
//
|
|
// Get the description of our child frame object.
|
|
//
|
|
poleacc = NULL;
|
|
hr = AccessibleObjectFromWindow(m_hwnd, varChild.lVal, IID_IAccessible,
|
|
(void **)&poleacc);
|
|
if (!SUCCEEDED(hr))
|
|
return(hr);
|
|
if (!poleacc)
|
|
return(S_FALSE);
|
|
|
|
varChild.lVal = CHILDID_SELF;
|
|
hr = poleacc->get_accDescription(varChild, pszDesc);
|
|
poleacc->Release();
|
|
|
|
return(hr);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
//
|
|
// CWindow::get_accHelp()
|
|
//
|
|
// --------------------------------------------------------------------------
|
|
STDMETHODIMP CWindow::get_accHelp(VARIANT varChild, BSTR* pszHelp)
|
|
{
|
|
InitPv(pszHelp);
|
|
|
|
//
|
|
// Validate parameters
|
|
//
|
|
if (! ValidateChild(&varChild))
|
|
return(E_INVALIDARG);
|
|
|
|
if (varChild.lVal == CHILDID_SELF)
|
|
return(E_NOT_APPLICABLE);
|
|
else
|
|
{
|
|
IAccessible * poleacc;
|
|
HRESULT hr;
|
|
|
|
//
|
|
// Get the help for our child frame object.
|
|
//
|
|
poleacc = NULL;
|
|
hr = AccessibleObjectFromWindow(m_hwnd, varChild.lVal,
|
|
IID_IAccessible, (void **)&poleacc);
|
|
if (!SUCCEEDED(hr))
|
|
return(hr);
|
|
if (!poleacc)
|
|
return(S_FALSE);
|
|
|
|
varChild.lVal = CHILDID_SELF;
|
|
hr = poleacc->get_accHelp(varChild, pszHelp);
|
|
poleacc->Release();
|
|
|
|
return(hr);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
//
|
|
// CWindow::get_accRole()
|
|
//
|
|
// --------------------------------------------------------------------------
|
|
STDMETHODIMP CWindow::get_accRole(VARIANT varChild, VARIANT* pvarRole)
|
|
{
|
|
InitPvar(pvarRole);
|
|
|
|
//
|
|
// Validate parameters
|
|
//
|
|
if (! ValidateChild(&varChild))
|
|
return(E_INVALIDARG);
|
|
|
|
if (varChild.lVal == CHILDID_SELF)
|
|
{
|
|
//
|
|
// Fill in our role.
|
|
//
|
|
pvarRole->vt = VT_I4;
|
|
pvarRole->lVal = ROLE_SYSTEM_WINDOW;
|
|
}
|
|
else
|
|
{
|
|
IAccessible * poleacc;
|
|
HRESULT hr;
|
|
|
|
//
|
|
// Get the role of our child frame object.
|
|
//
|
|
poleacc = NULL;
|
|
hr = AccessibleObjectFromWindow(m_hwnd, varChild.lVal,
|
|
IID_IAccessible, (void **)&poleacc);
|
|
if (!SUCCEEDED(hr))
|
|
return(hr);
|
|
if (!poleacc)
|
|
return(S_FALSE);
|
|
|
|
varChild.lVal = CHILDID_SELF;
|
|
hr = poleacc->get_accRole(varChild, pvarRole);
|
|
poleacc->Release();
|
|
|
|
return(hr);
|
|
}
|
|
|
|
return(S_OK);
|
|
}
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
//
|
|
// CWindow::get_accState()
|
|
//
|
|
// --------------------------------------------------------------------------
|
|
STDMETHODIMP CWindow::get_accState(VARIANT varChild, VARIANT* pvarState)
|
|
{
|
|
HWND hwndParent;
|
|
|
|
InitPvar(pvarState);
|
|
|
|
//
|
|
// Validate parameters
|
|
//
|
|
if (! ValidateChild(&varChild))
|
|
return(E_INVALIDARG);
|
|
|
|
pvarState->vt = VT_I4;
|
|
pvarState->lVal = 0;
|
|
|
|
if (varChild.lVal == CHILDID_SELF)
|
|
{
|
|
//
|
|
// Get our state.
|
|
//
|
|
WINDOWINFO wi;
|
|
RECT rcParent;
|
|
|
|
if (! MyGetWindowInfo(m_hwnd, &wi))
|
|
{
|
|
pvarState->lVal |= STATE_SYSTEM_INVISIBLE;
|
|
return(S_OK);
|
|
}
|
|
|
|
if (!(wi.dwStyle & WS_VISIBLE))
|
|
pvarState->lVal |= STATE_SYSTEM_INVISIBLE;
|
|
|
|
if (wi.dwStyle & WS_DISABLED)
|
|
pvarState->lVal |= STATE_SYSTEM_UNAVAILABLE;
|
|
|
|
if (wi.dwStyle & WS_THICKFRAME)
|
|
pvarState->lVal |= STATE_SYSTEM_SIZEABLE;
|
|
|
|
if ((wi.dwStyle & WS_CAPTION) == WS_CAPTION)
|
|
{
|
|
pvarState->lVal |= STATE_SYSTEM_MOVEABLE;
|
|
pvarState->lVal |= STATE_SYSTEM_FOCUSABLE;
|
|
}
|
|
|
|
// Windows are not selectable, so they shouldn't be selected either.
|
|
#if 0
|
|
if (wi.dwWindowStatus & WS_ACTIVECAPTION)
|
|
pvarState->lVal |= STATE_SYSTEM_SELECTED;
|
|
#endif
|
|
|
|
if (MyGetFocus() == m_hwnd)
|
|
pvarState->lVal |= STATE_SYSTEM_FOCUSED;
|
|
|
|
if (GetForegroundWindow() == MyGetAncestor(m_hwnd, GA_ROOT))
|
|
pvarState->lVal |= STATE_SYSTEM_FOCUSABLE;
|
|
|
|
// This is the _real_ parent window.
|
|
if (hwndParent = MyGetAncestor(m_hwnd, GA_PARENT))
|
|
{
|
|
MyGetRect(hwndParent, &rcParent, FALSE);
|
|
MapWindowPoints(hwndParent, NULL, (LPPOINT)&rcParent, 2);
|
|
|
|
if ( hwndParent == GetDesktopWindow() )
|
|
{
|
|
if ( MonitorFromRect( &wi.rcWindow, MONITOR_DEFAULTTONULL ) == NULL )
|
|
pvarState->lVal |= STATE_SYSTEM_INVISIBLE;
|
|
}
|
|
else
|
|
{
|
|
if ( Rect1IsOutsideRect2( wi.rcWindow, rcParent ) )
|
|
{
|
|
pvarState->lVal |= STATE_SYSTEM_INVISIBLE | STATE_SYSTEM_OFFSCREEN;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
IAccessible * poleacc;
|
|
HRESULT hr;
|
|
|
|
//
|
|
// Ask the frame element what its state is.
|
|
//
|
|
poleacc = NULL;
|
|
hr = AccessibleObjectFromWindow(m_hwnd, varChild.lVal,
|
|
IID_IAccessible, (void **)&poleacc);
|
|
if (!SUCCEEDED(hr))
|
|
return(hr);
|
|
if (!poleacc)
|
|
{
|
|
pvarState->lVal |= STATE_SYSTEM_INVISIBLE;
|
|
return(S_OK);
|
|
}
|
|
|
|
varChild.lVal = CHILDID_SELF;
|
|
hr = poleacc->get_accState(varChild, pvarState);
|
|
poleacc->Release();
|
|
|
|
return(hr);
|
|
}
|
|
|
|
return(S_OK);
|
|
}
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
//
|
|
// CWindow::get_accKeyboardShortcut()
|
|
//
|
|
// --------------------------------------------------------------------------
|
|
STDMETHODIMP CWindow::get_accKeyboardShortcut(VARIANT varChild, BSTR* pszShortcut)
|
|
{
|
|
IAccessible * poleacc;
|
|
HRESULT hr;
|
|
|
|
InitPv(pszShortcut);
|
|
|
|
//
|
|
// Validate parameters
|
|
//
|
|
if (! ValidateChild(&varChild))
|
|
return(E_INVALIDARG);
|
|
|
|
//
|
|
// If the caller is asking us for our shortcut, forward to the client.
|
|
//
|
|
if (varChild.lVal == CHILDID_SELF)
|
|
varChild.lVal = OBJID_CLIENT;
|
|
|
|
//
|
|
// Ask the child.
|
|
//
|
|
poleacc = NULL;
|
|
hr = AccessibleObjectFromWindow(m_hwnd, varChild.lVal,
|
|
IID_IAccessible, (void **)&poleacc);
|
|
if (!SUCCEEDED(hr))
|
|
return(hr);
|
|
|
|
varChild.lVal = CHILDID_SELF;
|
|
hr = poleacc->get_accKeyboardShortcut(varChild, pszShortcut);
|
|
poleacc->Release();
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
//
|
|
// CWindow::get_accFocus()
|
|
//
|
|
// --------------------------------------------------------------------------
|
|
STDMETHODIMP CWindow::get_accFocus(VARIANT* pvarChild)
|
|
{
|
|
HWND hwndFocus;
|
|
|
|
InitPvar(pvarChild);
|
|
|
|
//
|
|
// BOGUS! If we are in menu mode, then menu object has focus. If
|
|
// we are in scrolling mode, scrollbar has the focus. etc.
|
|
//
|
|
hwndFocus = MyGetFocus();
|
|
|
|
if ((m_hwnd == hwndFocus) || IsChild(m_hwnd, hwndFocus))
|
|
return(GetNoncObject(m_hwnd, OBJID_CLIENT, pvarChild));
|
|
|
|
return(S_FALSE);
|
|
}
|
|
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
//
|
|
// CWindow::accNavigate()
|
|
//
|
|
// --------------------------------------------------------------------------
|
|
STDMETHODIMP CWindow::accNavigate(long dwNavDir, VARIANT varStart,
|
|
VARIANT* pvarEnd)
|
|
{
|
|
InitPvar(pvarEnd);
|
|
|
|
//
|
|
// Validate parameters
|
|
//
|
|
if (! ValidateChild(&varStart) ||
|
|
! ValidateNavDir(dwNavDir, varStart.lVal))
|
|
return(E_INVALIDARG);
|
|
|
|
if (dwNavDir == NAVDIR_FIRSTCHILD)
|
|
return(FrameNavigate(m_hwnd, 0, NAVDIR_NEXT, pvarEnd));
|
|
else if (dwNavDir == NAVDIR_LASTCHILD)
|
|
return(FrameNavigate(m_hwnd, OBJID_SIZEGRIP-1, NAVDIR_PREVIOUS, pvarEnd));
|
|
else if (varStart.lVal == CHILDID_SELF)
|
|
{
|
|
HWND hwndParent;
|
|
|
|
hwndParent = MyGetAncestor(m_hwnd, GA_PARENT);
|
|
if (!hwndParent)
|
|
return(S_FALSE);
|
|
|
|
return (GetParentToNavigate(HWNDIDFromHwnd(hwndParent, m_hwnd), hwndParent,
|
|
OBJID_CLIENT, dwNavDir, pvarEnd));
|
|
}
|
|
else
|
|
return(FrameNavigate(m_hwnd, varStart.lVal, dwNavDir, pvarEnd));
|
|
|
|
}
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
//
|
|
// CWindow::accSelect()
|
|
//
|
|
// --------------------------------------------------------------------------
|
|
STDMETHODIMP CWindow::accSelect(long lSelFlags, VARIANT varChild)
|
|
{
|
|
if (! ValidateChild(&varChild) ||
|
|
! ValidateSelFlags(lSelFlags))
|
|
return E_INVALIDARG;
|
|
|
|
if (lSelFlags != SELFLAG_TAKEFOCUS)
|
|
return E_NOT_APPLICABLE;
|
|
|
|
if (varChild.lVal)
|
|
return S_FALSE ;
|
|
|
|
MySetFocus( m_hwnd );
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
//
|
|
// CWindow::accLocation()
|
|
//
|
|
// --------------------------------------------------------------------------
|
|
STDMETHODIMP CWindow::accLocation(long* pxLeft, long* pyTop, long* pcxWidth,
|
|
long* pcyHeight, VARIANT varChild)
|
|
{
|
|
RECT rc;
|
|
|
|
InitAccLocation(pxLeft, pyTop, pcxWidth, pcyHeight);
|
|
|
|
//
|
|
// Validate parameters
|
|
//
|
|
if (! ValidateChild(&varChild))
|
|
return(E_INVALIDARG);
|
|
|
|
if (varChild.lVal == 0)
|
|
{
|
|
MyGetRect(m_hwnd, &rc, TRUE);
|
|
|
|
*pxLeft = rc.left;
|
|
*pyTop = rc.top;
|
|
*pcxWidth = rc.right - rc.left;
|
|
*pcyHeight = rc.bottom - rc.top;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Ask the child.
|
|
//
|
|
IAccessible * poleacc;
|
|
HRESULT hr;
|
|
|
|
//
|
|
// Get the help for our child frame object.
|
|
//
|
|
poleacc = NULL;
|
|
hr = AccessibleObjectFromWindow(m_hwnd, varChild.lVal,
|
|
IID_IAccessible, (void **)&poleacc);
|
|
if (!SUCCEEDED(hr))
|
|
return(hr);
|
|
if (!poleacc)
|
|
return(S_FALSE);
|
|
|
|
varChild.lVal = CHILDID_SELF;
|
|
hr = poleacc->accLocation(pxLeft, pyTop, pcxWidth, pcyHeight, varChild);
|
|
poleacc->Release();
|
|
|
|
return(hr);
|
|
}
|
|
|
|
return(S_OK);
|
|
}
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
//
|
|
// CWindow::accHitTest()
|
|
//
|
|
// --------------------------------------------------------------------------
|
|
STDMETHODIMP CWindow::accHitTest(long xLeft, long yTop, VARIANT* pvarHit)
|
|
{
|
|
WINDOWINFO wi;
|
|
long lEnd;
|
|
long lHit;
|
|
POINT pt;
|
|
|
|
InitPvar(pvarHit);
|
|
|
|
lEnd = 0;
|
|
|
|
if (! MyGetWindowInfo(m_hwnd, &wi))
|
|
return(S_FALSE);
|
|
|
|
//
|
|
// Find out where point is. But special case the client area!
|
|
//
|
|
pt.x = xLeft;
|
|
pt.y = yTop;
|
|
if (PtInRect(&wi.rcClient, pt))
|
|
goto ReallyTheClient;
|
|
|
|
lHit = SendMessageINT(m_hwnd, WM_NCHITTEST, 0, MAKELONG(xLeft, yTop));
|
|
|
|
switch (lHit)
|
|
{
|
|
case HTERROR:
|
|
case HTNOWHERE:
|
|
return(S_FALSE);
|
|
|
|
case HTCAPTION:
|
|
case HTMINBUTTON:
|
|
case HTMAXBUTTON:
|
|
case HTHELP:
|
|
case HTCLOSE:
|
|
// case HTIME!
|
|
lEnd = OBJID_TITLEBAR;
|
|
break;
|
|
|
|
case HTMENU:
|
|
lEnd = OBJID_MENU;
|
|
break;
|
|
|
|
case HTSYSMENU:
|
|
lEnd = OBJID_SYSMENU;
|
|
break;
|
|
|
|
case HTHSCROLL:
|
|
lEnd = OBJID_HSCROLL;
|
|
break;
|
|
|
|
case HTVSCROLL:
|
|
lEnd = OBJID_VSCROLL;
|
|
break;
|
|
|
|
case HTCLIENT:
|
|
case HTTRANSPARENT:
|
|
ReallyTheClient:
|
|
lEnd = OBJID_CLIENT;
|
|
break;
|
|
|
|
case HTGROWBOX:
|
|
lEnd = OBJID_SIZEGRIP;
|
|
break;
|
|
|
|
case HTBOTTOMRIGHT:
|
|
// Note that for sizeable windows, being over the size grip may
|
|
// return in fact HTBOTTOMRIGHT for sizing purposes. If this
|
|
// point is inside the window borders, that is the case.
|
|
if ((xLeft < wi.rcWindow.right - (int)wi.cxWindowBorders) &&
|
|
(yTop < wi.rcWindow.bottom - (int)wi.cyWindowBorders))
|
|
{
|
|
lEnd = OBJID_SIZEGRIP;
|
|
}
|
|
break;
|
|
|
|
// Includes borders!
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (lEnd)
|
|
return(GetNoncObject(m_hwnd, lEnd, pvarHit));
|
|
else
|
|
{
|
|
pvarHit->vt = VT_I4;
|
|
pvarHit->lVal = lEnd;
|
|
}
|
|
|
|
return(S_OK);
|
|
}
|
|
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
//
|
|
// CWindow::Next()
|
|
//
|
|
// We do loop from 0 to cChildren, it's just that the IDs are NEGATIVE,
|
|
// not positive. We accept child ids that are OBJIDs.
|
|
//
|
|
// --------------------------------------------------------------------------
|
|
STDMETHODIMP CWindow::Next(ULONG celt, VARIANT* rgvar, ULONG* pceltFetched)
|
|
{
|
|
VARIANT* pvar;
|
|
long cFetched;
|
|
long iCur;
|
|
|
|
// Can be NULL
|
|
if (pceltFetched)
|
|
*pceltFetched = 0;
|
|
|
|
pvar = rgvar;
|
|
cFetched = 0;
|
|
iCur = m_idChildCur;
|
|
|
|
//
|
|
// Loop through our items
|
|
//
|
|
while ((cFetched < (long)celt) && (iCur < m_cChildren))
|
|
{
|
|
cFetched++;
|
|
iCur++;
|
|
|
|
//
|
|
// Note this gives us -((index)+1), which means we start at -1 and
|
|
// decrement. Conveniently, this corresponds to OBJID values!
|
|
//
|
|
pvar->vt = VT_I4;
|
|
pvar->lVal = 0 - iCur;
|
|
++pvar;
|
|
}
|
|
|
|
//
|
|
// Advance the current position
|
|
//
|
|
m_idChildCur = iCur;
|
|
|
|
//
|
|
// Fill in the number fetched
|
|
//
|
|
if (pceltFetched)
|
|
*pceltFetched = cFetched;
|
|
|
|
//
|
|
// Return S_FALSE if we grabbed fewer items than requested
|
|
//
|
|
return((cFetched < (long)celt) ? S_FALSE : S_OK);
|
|
}
|
|
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
//
|
|
// CWindow::Clone()
|
|
//
|
|
// --------------------------------------------------------------------------
|
|
STDMETHODIMP CWindow::Clone(IEnumVARIANT ** ppenum)
|
|
{
|
|
InitPv(ppenum);
|
|
|
|
// Look for (and create) a suitable proxy/handler if one
|
|
// exists. Use CreateWindowThing as default if none found.
|
|
// (TRUE => use window, as opposed to client, classes)
|
|
return FindAndCreateWindowClass( m_hwnd, TRUE, CLASS_WindowObject,
|
|
OBJID_WINDOW, m_idChildCur, IID_IEnumVARIANT, (void**)ppenum );
|
|
}
|
|
|
|
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
//
|
|
// FrameNavigate()
|
|
//
|
|
// Default handling of navigation among frame children. The standard
|
|
// frame widget handlers (titlebar, menubar, scrollbar, etc.) hand off
|
|
// peer navigation to us, their parent. There are two big reasons for this:
|
|
//
|
|
// (1) It saves on code and ease of implementation, since the knowledge of
|
|
// what is to the left of what, what is below what, etc. only has to
|
|
// be coded in one place.
|
|
//
|
|
// (2) It allows apps that want to manage their own frame and e.g. add a
|
|
// new element that acts like a frame piece yet still have navigation
|
|
// work properly. Their frame handler can hand off to the default
|
|
// implementation but trap navigation.
|
|
//
|
|
// --------------------------------------------------------------------------
|
|
HRESULT FrameNavigate(HWND hwndFrame, long lStart, long dwNavDir,
|
|
VARIANT * pvarEnd)
|
|
{
|
|
long lEnd;
|
|
long lMask;
|
|
WINDOWINFO wi;
|
|
TCHAR szClassName[128];
|
|
BOOL bFound = FALSE;
|
|
IAccessible * poleacc;
|
|
IDispatch * pdispEl;
|
|
HRESULT hr;
|
|
|
|
//
|
|
// Currently, we get an index (fix validation layer so IDs are OBJIDs)
|
|
//
|
|
lEnd = 0;
|
|
|
|
lStart = IndexFromObjid(lStart);
|
|
|
|
//
|
|
// Figure out what is present, what isn't.
|
|
//
|
|
if (!MyGetWindowInfo(hwndFrame, &wi))
|
|
return(E_FAIL);
|
|
|
|
lMask = 0;
|
|
lMask |= MaskBit(IndexFromObjid(OBJID_CLIENT));
|
|
|
|
if ((wi.dwStyle & WS_CAPTION)== WS_CAPTION)
|
|
lMask |= MaskBit(IndexFromObjid(OBJID_TITLEBAR));
|
|
|
|
if (wi.dwStyle & WS_SYSMENU)
|
|
lMask |= MaskBit(IndexFromObjid(OBJID_SYSMENU));
|
|
|
|
if (wi.dwStyle & WS_VSCROLL)
|
|
lMask |= MaskBit(IndexFromObjid(OBJID_VSCROLL));
|
|
|
|
if (wi.dwStyle & WS_HSCROLL)
|
|
lMask |= MaskBit(IndexFromObjid(OBJID_HSCROLL));
|
|
|
|
if ((wi.dwStyle & (WS_HSCROLL | WS_VSCROLL)) == (WS_HSCROLL | WS_VSCROLL))
|
|
lMask |= MaskBit(IndexFromObjid(OBJID_SIZEGRIP));
|
|
|
|
if (!(wi.dwStyle & WS_CHILD) && GetMenu(hwndFrame))
|
|
lMask |= MaskBit(IndexFromObjid(OBJID_MENU));
|
|
|
|
// HACKISH BIT for new IE4/Shell Menubands
|
|
// The menus aren't menus, so we have to see if this thing
|
|
// has menubands.
|
|
// First, check the classname - only the browser and shell
|
|
// windows have these things...
|
|
// The reason we have to do this is because the IE4 guys are
|
|
// slackers and didn't do very much for accessibility.
|
|
GetClassName (hwndFrame, szClassName,ARRAYSIZE(szClassName));
|
|
if ((0 == lstrcmp (szClassName,TEXT("IEFrame"))) ||
|
|
(0 == lstrcmp (szClassName,TEXT("CabinetWClass"))))
|
|
{
|
|
HWND hwndWorker;
|
|
HWND hwndRebar;
|
|
HWND hwndSysPager;
|
|
HWND hwndToolbar;
|
|
|
|
// We can just send a WM_GETOBJECT to the menuband window,
|
|
// we just have to find it. Let's use FindWindowEx to do that.
|
|
// This is not easy: There are 4 children of an IEFrame Window,
|
|
// and I am not sure how many children of a shell window (CabinetWClass).
|
|
// For IEFrame windows, the menuband is the:
|
|
// ToolbarWindow32 child of a SysPager that is the child of a
|
|
// RebarWindow32 that is the child of a Worker.
|
|
// But there are 2 Worker windows at the 1st level down,
|
|
// and 2 SysPagers that are children of the RebarWindow32.
|
|
|
|
bFound = FALSE;
|
|
hwndWorker = NULL;
|
|
while (!bFound)
|
|
{
|
|
hwndWorker = FindWindowEx (hwndFrame,hwndWorker,TEXT("Worker"),NULL);
|
|
if (!hwndWorker)
|
|
break;
|
|
|
|
hwndRebar = FindWindowEx (hwndWorker,NULL,TEXT("RebarWindow32"),NULL);
|
|
if (!hwndRebar)
|
|
continue;
|
|
|
|
hwndSysPager = NULL;
|
|
while (!bFound)
|
|
{
|
|
hwndSysPager = FindWindowEx (hwndRebar,hwndSysPager,TEXT("SysPager"),NULL);
|
|
if (!hwndSysPager)
|
|
break;
|
|
hwndToolbar = FindWindowEx (hwndSysPager,NULL,TEXT("ToolbarWindow32"),NULL);
|
|
hr = AccessibleObjectFromWindow (hwndToolbar,OBJID_MENU,
|
|
IID_IAccessible, (void **)&poleacc);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
bFound = TRUE;
|
|
lMask |= MaskBit(IndexFromObjid(OBJID_MENU));
|
|
}
|
|
}
|
|
}
|
|
} // end if we are talking to something that might have a menuband
|
|
|
|
switch (dwNavDir)
|
|
{
|
|
case NAVDIR_NEXT:
|
|
lEnd = lStart;
|
|
while (++lEnd <= CCHILDREN_FRAME)
|
|
{
|
|
// Is the next item present?
|
|
if (lMask & MaskBit(lEnd))
|
|
break;
|
|
}
|
|
|
|
if (lEnd > CCHILDREN_FRAME)
|
|
lEnd = 0;
|
|
break;
|
|
|
|
case NAVDIR_PREVIOUS:
|
|
lEnd = lStart;
|
|
while (--lEnd > 0)
|
|
{
|
|
// Is the previous item present?
|
|
if (lMask & MaskBit(lEnd))
|
|
break;
|
|
}
|
|
|
|
Assert(lEnd >= 0);
|
|
break;
|
|
|
|
case NAVDIR_UP:
|
|
case NAVDIR_DOWN:
|
|
case NAVDIR_LEFT:
|
|
case NAVDIR_RIGHT:
|
|
lEnd = lStart;
|
|
while (lEnd = rgFrameNavigate[lEnd-1].NavPeer[IndexFromNavDir(dwNavDir)])
|
|
{
|
|
// Is this item around?
|
|
if (lMask & MaskBit(lEnd))
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (lEnd)
|
|
{
|
|
// now finish up our hackish work. For normal things, we just
|
|
// return GetNoncObject, which is basically just a call to
|
|
// AccessibleObjectFromWindow with the id of the frame element,
|
|
// and then it just stuffs the return value (an IDispatch) into
|
|
// the VARIANT.
|
|
// For IE4 hackish stuff, we have an IAccessible, we'll QI for
|
|
// IDispatch, Release the IAccessible, and stuff the IDispatch
|
|
// into a VARIANT.
|
|
if (bFound && lEnd == IndexFromObjid(OBJID_MENU))
|
|
{
|
|
hr = poleacc->QueryInterface(IID_IDispatch,(void**)&pdispEl);
|
|
poleacc->Release();
|
|
|
|
if (!SUCCEEDED(hr))
|
|
return(hr);
|
|
if (!pdispEl)
|
|
return(E_FAIL);
|
|
|
|
pvarEnd->vt = VT_DISPATCH;
|
|
pvarEnd->pdispVal = pdispEl;
|
|
return (S_OK);
|
|
}
|
|
else
|
|
return(GetNoncObject(hwndFrame, ObjidFromIndex(lEnd), pvarEnd));
|
|
}
|
|
else
|
|
return(S_FALSE);
|
|
}
|
|
|
|
|