/////////////////////////////////////////////////////////////////////////////
// Name: accesstest.cpp
// Purpose: wxWidgets accessibility sample
// Author: Julian Smart
// Modified by:
// Created: 2002-02-12
// RCS-ID: $Id: accesstest.cpp 27472 2004-05-27 17:50:54Z ABX $
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
// for all others, include the necessary headers (this file is usually all you
// need because it includes almost all "standard" wxWidgets headers)
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif
#if wxUSE_ACCESSIBILITY
#include "wx/access.h"
#endif // wxUSE_ACCESSIBILITY
#include "wx/splitter.h"
#include "wx/cshelp.h"
#ifdef __WXMSW__
#include "windows.h"
#include <ole2.h>
#include <oleauto.h>
#if wxUSE_ACCESSIBILITY
#include <oleacc.h>
#endif // wxUSE_ACCESSIBILITY
#include "wx/msw/ole/oleutils.h"
#include "wx/msw/winundef.h"
#ifndef OBJID_CLIENT
#define OBJID_CLIENT 0xFFFFFFFC
#endif
#endif
// ----------------------------------------------------------------------------
// resources
// ----------------------------------------------------------------------------
// the application icon (under Windows and OS/2 it is in resources)
#if defined(__WXGTK__) || defined(__WXMOTIF__) || defined(__WXMAC__) || defined(__WXMGL__) || defined(__WXX11__)
#include "mondrian.xpm"
#endif
// ----------------------------------------------------------------------------
// private classes
// ----------------------------------------------------------------------------
// Define a new application type, each program should derive a class from wxApp
class MyApp : public wxApp
{
public:
// override base class virtuals
// ----------------------------
// this one is called on application startup and is a good place for the app
// initialization (doing it here and not in the ctor allows to have an error
// return: if OnInit() returns false, the application terminates)
virtual bool OnInit();
};
#if wxUSE_ACCESSIBILITY
// Define a new frame type: this is going to be our main frame
class MyFrame : public wxFrame
{
public:
// ctor(s)
MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size,
long style = wxDEFAULT_FRAME_STYLE);
// event handlers (these functions should _not_ be virtual)
void OnQuit(wxCommandEvent& event);
void OnQuery(wxCommandEvent& event);
void OnAbout(wxCommandEvent& event);
// Log messages to the text control
void Log(const wxString& text);
// Recursively give information about an object
void LogObject(int indent, IAccessible* obj);
// Get info for a child (id > 0) or object (id == 0)
void GetInfo(IAccessible* accessible, int id, wxString& name, wxString& role);
private:
wxTextCtrl* m_textCtrl;
// any class wishing to process wxWidgets events must use this macro
DECLARE_EVENT_TABLE()
};
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
// IDs for the controls and the menu commands
enum
{
// menu items
AccessTest_Quit = 1,
// query the hierarchy
AccessTest_Query,
// it is important for the id corresponding to the "About" command to have
// this standard value as otherwise it won't be handled properly under Mac
// (where it is special and put into the "Apple" menu)
AccessTest_About = wxID_ABOUT
};
// ----------------------------------------------------------------------------
// event tables and other macros for wxWidgets
// ----------------------------------------------------------------------------
// the event tables connect the wxWidgets events with the functions (event
// handlers) which process them. It can be also done at run-time, but for the
// simple menu events like this the static method is much simpler.
BEGIN_EVENT_TABLE(MyFrame, wxFrame)
EVT_MENU(AccessTest_Quit, MyFrame::OnQuit)
EVT_MENU(AccessTest_Query, MyFrame::OnQuery)
EVT_MENU(AccessTest_About, MyFrame::OnAbout)
END_EVENT_TABLE()
#endif // wxUSE_ACCESSIBILITY
// Create a new application object: this macro will allow wxWidgets to create
// the application object during program execution (it's better than using a
// static object for many reasons) and also declares the accessor function
// wxGetApp() which will return the reference of the right type (i.e. MyApp and
// not wxApp)
IMPLEMENT_APP(MyApp)
// ============================================================================
// implementation
// ============================================================================
// ----------------------------------------------------------------------------
// the application class
// ----------------------------------------------------------------------------
// 'Main program' equivalent: the program execution "starts" here
bool MyApp::OnInit()
{
#if wxUSE_ACCESSIBILITY
// Note: JAWS for Windows will only speak the context-sensitive
// help if you use this help provider:
// wxHelpProvider::Set(new wxHelpControllerHelpProvider(m_helpController)).
// JAWS does not seem to be getting the help text from
// the wxAccessible object.
wxHelpProvider::Set(new wxSimpleHelpProvider());
// create the main application window
MyFrame *frame = new MyFrame(_T("AccessTest wxWidgets App"),
wxPoint(50, 50), wxSize(450, 340));
// and show it (the frames, unlike simple controls, are not shown when
// created initially)
frame->Show(true);
// success: wxApp::OnRun() will be called which will enter the main message
// loop and the application will run. If we returned false here, the
// application would exit immediately.
return true;
#else
wxMessageBox( _T("This sample has to be compiled with wxUSE_ACCESSIBILITY"), _T("Building error"), wxOK);
return false;
#endif // wxUSE_ACCESSIBILITY
}
#if wxUSE_ACCESSIBILITY
class FrameAccessible: public wxWindowAccessible
{
public:
FrameAccessible(wxWindow* win): wxWindowAccessible(win) {}
// Gets the name of the specified object.
virtual wxAccStatus GetName(int childId, wxString* name)
{
if (childId == wxACC_SELF)
{
* name = wxT("Julian's Frame");
return wxACC_OK;
}
else
return wxACC_NOT_IMPLEMENTED;
}
};
class ScrolledWindowAccessible: public wxWindowAccessible
{
public:
ScrolledWindowAccessible(wxWindow* win): wxWindowAccessible(win) {}
// Gets the name of the specified object.
virtual wxAccStatus GetName(int childId, wxString* name)
{
if (childId == wxACC_SELF)
{
* name = wxT("My scrolled window");
return wxACC_OK;
}
else
return wxACC_NOT_IMPLEMENTED;
}
};
class SplitterWindowAccessible: public wxWindowAccessible
{
public:
SplitterWindowAccessible(wxWindow* win): wxWindowAccessible(win) {}
// Gets the name of the specified object.
virtual wxAccStatus GetName(int childId, wxString* name);
// Can return either a child object, or an integer
// representing the child element, starting from 1.
virtual wxAccStatus HitTest(const wxPoint& pt, int* childId, wxAccessible** childObject);
// Returns the rectangle for this object (id = 0) or a child element (id > 0).
virtual wxAccStatus GetLocation(wxRect& rect, int elementId);
// Navigates from fromId to toId/toObject.
virtual wxAccStatus Navigate(wxNavDir navDir, int fromId,
int* toId, wxAccessible** toObject);
// Gets the number of children.
virtual wxAccStatus GetChildCount(int* childCount);
// Gets the specified child (starting from 1).
// If *child is NULL and return value is wxACC_OK,
// this means that the child is a simple element and
// not an accessible object.
virtual wxAccStatus GetChild(int childId, wxAccessible** child);
// Gets the parent, or NULL.
virtual wxAccStatus GetParent(wxAccessible** parent);
// Performs the default action. childId is 0 (the action for this object)
// or > 0 (the action for a child).
// Return wxACC_NOT_SUPPORTED if there is no default action for this
// window (e.g. an edit control).
virtual wxAccStatus DoDefaultAction(int childId);
// Gets the default action for this object (0) or > 0 (the action for a child).
// Return wxACC_OK even if there is no action. actionName is the action, or the empty
// string if there is no action.
// The retrieved string describes the action that is performed on an object,
// not what the object does as a result. For example, a toolbar button that prints
// a document has a default action of "Press" rather than "Prints the current document."
virtual wxAccStatus GetDefaultAction(int childId, wxString* actionName);
// Returns the description for this object or a child.
virtual wxAccStatus GetDescription(int childId, wxString* description);
// Returns help text for this object or a child, similar to tooltip text.
virtual wxAccStatus GetHelpText(int childId, wxString* helpText);
// Returns the keyboard shortcut for this object or child.
// Return e.g. ALT+K
virtual wxAccStatus GetKeyboardShortcut(int childId, wxString* shortcut);
// Returns a role constant.
virtual wxAccStatus GetRole(int childId, wxAccRole* role);
// Returns a state constant.
virtual wxAccStatus GetState(int childId, long* state);
// Returns a localized string representing the value for the object
// or child.
virtual wxAccStatus GetValue(int childId, wxString* strValue);
// Selects the object or child.
virtual wxAccStatus Select(int childId, wxAccSelectionFlags selectFlags);
// Gets the window with the keyboard focus.
// If childId is 0 and child is NULL, no object in
// this subhierarchy has the focus.
// If this object has the focus, child should be 'this'.
virtual wxAccStatus GetFocus(int* childId, wxAccessible** child);
// Gets a variant representing the selected children
// of this object.
// Acceptable values:
// - a null variant (IsNull() returns true)
// - a list variant (GetType() == wxT("list"))
// - an integer representing the selected child element,
// or 0 if this object is selected (GetType() == wxT("long"))
// - a "void*" pointer to a wxAccessible child object
virtual wxAccStatus GetSelections(wxVariant* selections);
};
// ----------------------------------------------------------------------------
// main frame
// ----------------------------------------------------------------------------
// frame constructor
MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size, long style)
: wxFrame(NULL, wxID_ANY, title, pos, size, style)
{
m_textCtrl = NULL;
SetAccessible(new FrameAccessible(this));
// set the frame icon
SetIcon(wxICON(mondrian));
#if wxUSE_MENUS
// create a menu bar
wxMenu *menuFile = new wxMenu;
// the "About" item should be in the help menu
wxMenu *helpMenu = new wxMenu;
helpMenu->Append(AccessTest_About, _T("&About..."), _T("Show about dialog"));
menuFile->Append(AccessTest_Query, _T("Query"), _T("Query the window hierarchy"));
menuFile->AppendSeparator();
menuFile->Append(AccessTest_Quit, _T("E&xit\tAlt-X"), _T("Quit this program"));
// now append the freshly created menu to the menu bar...
wxMenuBar *menuBar = new wxMenuBar();
menuBar->Append(menuFile, _T("&File"));
menuBar->Append(helpMenu, _T("&Help"));
// ... and attach this menu bar to the frame
SetMenuBar(menuBar);
#endif // wxUSE_MENUS
#if 0 // wxUSE_STATUSBAR
// create a status bar just for fun (by default with 1 pane only)
CreateStatusBar(2);
SetStatusText(_T("Welcome to wxWidgets!"));
#endif // wxUSE_STATUSBAR
wxSplitterWindow* splitter = new wxSplitterWindow(this, wxID_ANY);
splitter->SetAccessible(new SplitterWindowAccessible(splitter));
wxListBox* listBox = new wxListBox(splitter, wxID_ANY);
listBox->Append(wxT("Cabbages"));
listBox->Append(wxT("Kings"));
listBox->Append(wxT("Sealing wax"));
listBox->Append(wxT("Strings"));
listBox->CreateAccessible();
listBox->SetHelpText(wxT("This is a sample wxWidgets listbox, with a number of items in it."));
m_textCtrl = new wxTextCtrl(splitter, wxID_ANY, wxT(""), wxDefaultPosition,
wxDefaultSize, wxTE_MULTILINE);
m_textCtrl->CreateAccessible();
m_textCtrl->SetHelpText(wxT("This is a sample wxWidgets multiline text control."));
splitter->SplitHorizontally(listBox, m_textCtrl, 150);
#if 0
wxScrolledWindow* scrolledWindow = new wxScrolledWindow(this, wxID_ANY);
scrolledWindow->SetAccessible(new ScrolledWindowAccessible(scrolledWindow));
#endif
}
// event handlers
void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
{
// true is to force the frame to close
Close(true);
}
void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
{
wxString msg;
msg.Printf( _T("This is the About dialog of the AccessTest sample.\n")
_T("Welcome to %s"), wxVERSION_STRING);
wxMessageBox(msg, _T("About AccessTest"), wxOK | wxICON_INFORMATION, this);
}
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();
}
}
// Log messages to the text control
void MyFrame::Log(const wxString& text)
{
if (m_textCtrl)
{
wxString text2(text);
text2.Replace(wxT("\n"), wxT(" "));
text2.Replace(wxT("\r"), wxT(" "));
m_textCtrl->SetInsertionPointEnd();
m_textCtrl->WriteText(text2 + wxT("\n"));
}
}
// Recursively give information about an object
void MyFrame::LogObject(int indent, IAccessible* obj)
{
wxString name, role;
if (indent == 0)
{
GetInfo(obj, 0, name, role);
wxString str;
str.Printf(wxT("Name = %s; Role = %s"), name.c_str(), role.c_str());
str.Pad(indent, wxT(' '), false);
Log(str);
}
long childCount = 0;
if (S_OK == obj->get_accChildCount(& childCount))
{
wxString str;
str.Printf(wxT("There are %d children."), (int) childCount);
str.Pad(indent, wxT(' '), false);
Log(str);
Log(wxT(""));
}
int i;
for (i = 1; i <= childCount; i++)
{
GetInfo(obj, i, name, role);
wxString str;
str.Printf(wxT("%d) Name = %s; Role = %s"), i, name.c_str(), role.c_str());
str.Pad(indent, wxT(' '), false);
Log(str);
VARIANT var;
VariantInit(& var);
var.vt = VT_I4;
var.lVal = i;
IDispatch* pDisp = NULL;
IAccessible* childObject = NULL;
if (S_OK == obj->get_accChild(var, & pDisp) && pDisp)
{
wxString str;
str.Printf(wxT("This is a real object."));
str.Pad(indent+4, wxT(' '), false);
Log(str);
if (pDisp->QueryInterface(IID_IAccessible, (LPVOID*) & childObject) == S_OK)
{
LogObject(indent + 4, childObject);
childObject->Release();
}
pDisp->Release();
}
else
{
wxString str;
str.Printf(wxT("This is an element."));
str.Pad(indent+4, wxT(' '), false);
Log(str);
}
// Log(wxT(""));
}
}
// Get info for a child (id > 0) or object (id == 0)
void MyFrame::GetInfo(IAccessible* accessible, int id, wxString& name, wxString& role)
{
VARIANT var;
VariantInit(& var);
var.vt = VT_I4;
var.lVal = id;
BSTR bStrName = 0;
HRESULT hResult = accessible->get_accName(var, & bStrName);
if (hResult == S_OK)
{
name = wxConvertStringFromOle(bStrName);
SysFreeString(bStrName);
}
else
{
name = wxT("NO NAME");
}
VARIANT varRole;
VariantInit(& varRole);
hResult = accessible->get_accRole(var, & varRole);
if (hResult == S_OK && varRole.vt == VT_I4)
{
wxChar buf[256];
GetRoleText(varRole.lVal, buf, 256);
role = buf;
}
else
{
role = wxT("NO ROLE");
}
}
/*
* SplitterWindowAccessible implementation
*/
// Gets the name of the specified object.
wxAccStatus SplitterWindowAccessible::GetName(int childId, wxString* name)
{
if (childId == wxACC_SELF)
{
* name = wxT("Splitter window");
return wxACC_OK;
}
wxSplitterWindow* splitter = wxDynamicCast(GetWindow(), wxSplitterWindow);
if (splitter)
{
if (splitter->IsSplit())
{
// Two windows, and the sash.
if (childId == 1 || childId == 3)
return wxACC_NOT_IMPLEMENTED;
else if (childId == 2)
{
*name = wxT("Sash");
return wxACC_OK;
}
}
}
// Let the framework handle the other cases.
return wxACC_NOT_IMPLEMENTED;
}
// Can return either a child object, or an integer
// representing the child element, starting from 1.
wxAccStatus SplitterWindowAccessible::HitTest(const wxPoint& pt, int* childId, wxAccessible** WXUNUSED(childObject))
{
wxSplitterWindow* splitter = wxDynamicCast(GetWindow(), wxSplitterWindow);
if (splitter)
{
if (splitter->IsSplit())
{
wxPoint clientPt = splitter->ScreenToClient(pt);
if (splitter->SashHitTest(clientPt.x, clientPt.y, 1))
{
// We're over the sash
*childId = 2;
return wxACC_OK;
}
}
}
// Let the framework handle the other cases.
return wxACC_NOT_IMPLEMENTED;
}
// Returns the rectangle for this object (id = 0) or a child element (id > 0).
wxAccStatus SplitterWindowAccessible::GetLocation(wxRect& rect, int elementId)
{
wxSplitterWindow* splitter = wxDynamicCast(GetWindow(), wxSplitterWindow);
if (splitter && elementId == 2 && splitter->IsSplit())
{
wxSize clientSize = splitter->GetClientSize();
if (splitter->GetSplitMode() == wxSPLIT_VERTICAL)
{
rect.x = splitter->GetSashPosition();
rect.y = 0;
rect.SetPosition(splitter->ClientToScreen(rect.GetPosition()));
rect.width = splitter->GetSashSize();
rect.height = clientSize.y;
}
else
{
rect.x = 0;
rect.y = splitter->GetSashPosition();
rect.SetPosition(splitter->ClientToScreen(rect.GetPosition()));
rect.width = clientSize.x;
rect.height = splitter->GetSashSize();
}
return wxACC_OK;
}
// Let the framework handle the other cases.
return wxACC_NOT_IMPLEMENTED;
}
// Navigates from fromId to toId/toObject.
wxAccStatus SplitterWindowAccessible::Navigate(wxNavDir navDir, int fromId,
int* toId, wxAccessible** toObject)
{
wxSplitterWindow* splitter = wxDynamicCast(GetWindow(), wxSplitterWindow);
if (splitter && splitter->IsSplit())
{
switch (navDir)
{
case wxNAVDIR_DOWN:
{
if (splitter->GetSplitMode() != wxSPLIT_VERTICAL)
{
if (fromId == 1)
{
*toId = 2;
*toObject = NULL;
return wxACC_OK;
}
else if (fromId == 2)
{
*toId = 3;
*toObject = splitter->GetWindow2()->GetAccessible();
return wxACC_OK;
}
}
return wxACC_FALSE;
#if 0
// below line is not executed due to earlier return
break;
#endif
}
case wxNAVDIR_FIRSTCHILD:
{
if (fromId == 2)
return wxACC_FALSE;
}
break;
case wxNAVDIR_LASTCHILD:
{
if (fromId == 2)
return wxACC_FALSE;
}
break;
case wxNAVDIR_LEFT:
{
if (splitter->GetSplitMode() != wxSPLIT_HORIZONTAL)
{
if (fromId == 3)
{
*toId = 2;
*toObject = NULL;
return wxACC_OK;
}
else if (fromId == 2)
{
*toId = 1;
*toObject = splitter->GetWindow1()->GetAccessible();
return wxACC_OK;
}
}
return wxACC_FALSE;
}
#if 0
// below line is not executed due to earlier return
break;
#endif
case wxNAVDIR_NEXT:
{
if (fromId == 1)
{
*toId = 2;
*toObject = NULL;
return wxACC_OK;
}
else if (fromId == 2)
{
*toId = 3;
*toObject = splitter->GetWindow2()->GetAccessible();
return wxACC_OK;
}
return wxACC_FALSE;
}
#if 0
// below line is not executed due to earlier return
break;
#endif
case wxNAVDIR_PREVIOUS:
{
if (fromId == 3)
{
*toId = 2;
*toObject = NULL;
return wxACC_OK;
}
else if (fromId == 2)
{
*toId = 1;
*toObject = splitter->GetWindow1()->GetAccessible();
return wxACC_OK;
}
return wxACC_FALSE;
}
#if 0
// below line is not executed due to earlier return
break;
#endif
case wxNAVDIR_RIGHT:
{
if (splitter->GetSplitMode() != wxSPLIT_HORIZONTAL)
{
if (fromId == 1)
{
*toId = 2;
*toObject = NULL;
return wxACC_OK;
}
else if (fromId == 2)
{
*toId = 3;
*toObject = splitter->GetWindow2()->GetAccessible();
return wxACC_OK;
}
}
// Can't go right spatially if split horizontally.
return wxACC_FALSE;
}
#if 0
// below line is not executed due to earlier return
break;
#endif
case wxNAVDIR_UP:
{
if (splitter->GetSplitMode() != wxSPLIT_VERTICAL)
{
if (fromId == 3)
{
*toId = 2;
return wxACC_OK;
}
else if (fromId == 2)
{
*toId = 1;
*toObject = splitter->GetWindow1()->GetAccessible();
return wxACC_OK;
}
}
// Can't go up spatially if split vertically.
return wxACC_FALSE;
#if 0
// below line is not executed due to earlier return
break;
#endif
}
}
}
// Let the framework handle the other cases.
return wxACC_NOT_IMPLEMENTED;
}
// Gets the number of children.
wxAccStatus SplitterWindowAccessible::GetChildCount(int* childCount)
{
wxSplitterWindow* splitter = wxDynamicCast(GetWindow(), wxSplitterWindow);
if (splitter)
{
if (splitter->IsSplit())
{
// Two windows, and the sash.
*childCount = 3;
return wxACC_OK;
}
else
{
// No sash -- 1 or 0 windows.
if (splitter->GetWindow1() || splitter->GetWindow2())
{
*childCount = 1;
return wxACC_OK;
}
else
{
*childCount = 0;
return wxACC_OK;
}
}
}
// Let the framework handle the other cases.
return wxACC_NOT_IMPLEMENTED;
}
// Gets the specified child (starting from 1).
// If *child is NULL and return value is wxACC_OK,
// this means that the child is a simple element and
// not an accessible object.
wxAccStatus SplitterWindowAccessible::GetChild(int childId, wxAccessible** child)
{
if (childId == wxACC_SELF)
{
*child = this;
return wxACC_OK;
}
wxSplitterWindow* splitter = wxDynamicCast(GetWindow(), wxSplitterWindow);
if (splitter)
{
if (splitter->IsSplit())
{
// Two windows, and the sash.
if (childId == 1)
{
*child = splitter->GetWindow1()->GetAccessible();
}
else if (childId == 2)
{
*child = NULL; // Sash
}
else if (childId == 3)
{
*child = splitter->GetWindow2()->GetAccessible();
}
else
{
return wxACC_FAIL;
}
return wxACC_OK;
}
else
{
// No sash -- 1 or 0 windows.
if (childId == 1)
{
if (splitter->GetWindow1())
{
*child = splitter->GetWindow1()->GetAccessible();
return wxACC_OK;
}
else if (splitter->GetWindow2())
{
*child = splitter->GetWindow2()->GetAccessible();
return wxACC_OK;
}
else
{
return wxACC_FAIL;
}
}
else
return wxACC_FAIL;
}
}
// Let the framework handle the other cases.
return wxACC_NOT_IMPLEMENTED;
}
// Gets the parent, or NULL.
wxAccStatus SplitterWindowAccessible::GetParent(wxAccessible** WXUNUSED(parent))
{
return wxACC_NOT_IMPLEMENTED;
}
// Performs the default action. childId is 0 (the action for this object)
// or > 0 (the action for a child).
// Return wxACC_NOT_SUPPORTED if there is no default action for this
// window (e.g. an edit control).
wxAccStatus SplitterWindowAccessible::DoDefaultAction(int WXUNUSED(childId))
{
return wxACC_NOT_IMPLEMENTED;
}
// Gets the default action for this object (0) or > 0 (the action for a child).
// Return wxACC_OK even if there is no action. actionName is the action, or the empty
// string if there is no action.
// The retrieved string describes the action that is performed on an object,
// not what the object does as a result. For example, a toolbar button that prints
// a document has a default action of "Press" rather than "Prints the current document."
wxAccStatus SplitterWindowAccessible::GetDefaultAction(int childId, wxString* WXUNUSED(actionName))
{
wxSplitterWindow* splitter = wxDynamicCast(GetWindow(), wxSplitterWindow);
if (splitter && splitter->IsSplit() && childId == 2)
{
// No default action for the splitter.
return wxACC_FALSE;
}
// Let the framework handle the other cases.
return wxACC_NOT_IMPLEMENTED;
}
// Returns the description for this object or a child.
wxAccStatus SplitterWindowAccessible::GetDescription(int childId, wxString* description)
{
wxSplitterWindow* splitter = wxDynamicCast(GetWindow(), wxSplitterWindow);
if (splitter)
{
if (splitter->IsSplit())
{
if (childId == 2)
{
* description = _("The splitter window sash.");
return wxACC_OK;
}
}
}
// Let the framework handle the other cases.
return wxACC_NOT_IMPLEMENTED;
}
// Returns help text for this object or a child, similar to tooltip text.
wxAccStatus SplitterWindowAccessible::GetHelpText(int childId, wxString* helpText)
{
wxSplitterWindow* splitter = wxDynamicCast(GetWindow(), wxSplitterWindow);
if (splitter)
{
if (splitter->IsSplit())
{
if (childId == 2)
{
* helpText = _("The splitter window sash.");
return wxACC_OK;
}
}
}
// Let the framework handle the other cases.
return wxACC_NOT_IMPLEMENTED;
}
// Returns the keyboard shortcut for this object or child.
// Return e.g. ALT+K
wxAccStatus SplitterWindowAccessible::GetKeyboardShortcut(int childId, wxString* WXUNUSED(shortcut))
{
wxSplitterWindow* splitter = wxDynamicCast(GetWindow(), wxSplitterWindow);
if (splitter && splitter->IsSplit() && childId == 2)
{
// No keyboard shortcut for the splitter.
return wxACC_FALSE;
}
// Let the framework handle the other cases.
return wxACC_NOT_IMPLEMENTED;
}
// Returns a role constant.
wxAccStatus SplitterWindowAccessible::GetRole(int childId, wxAccRole* role)
{
wxSplitterWindow* splitter = wxDynamicCast(GetWindow(), wxSplitterWindow);
if (splitter)
{
if (splitter->IsSplit())
{
if (childId == 2)
{
* role = wxROLE_SYSTEM_GRIP;
return wxACC_OK;
}
}
}
// Let the framework handle the other cases.
return wxACC_NOT_IMPLEMENTED;
}
// Returns a state constant.
wxAccStatus SplitterWindowAccessible::GetState(int childId, long* state)
{
wxSplitterWindow* splitter = wxDynamicCast(GetWindow(), wxSplitterWindow);
if (splitter && splitter->IsSplit() && childId == 2)
{
// No particular state. Not sure what would be appropriate here.
*state = wxACC_STATE_SYSTEM_UNAVAILABLE;
return wxACC_OK;
}
// Let the framework handle the other cases.
return wxACC_NOT_IMPLEMENTED;
}
// Returns a localized string representing the value for the object
// or child.
wxAccStatus SplitterWindowAccessible::GetValue(int childId, wxString* strValue)
{
wxSplitterWindow* splitter = wxDynamicCast(GetWindow(), wxSplitterWindow);
if (splitter && splitter->IsSplit() && childId == 2)
{
// The sash position is the value.
wxString pos;
pos << splitter->GetSashPosition();
*strValue = pos;
return wxACC_OK;
}
// Let the framework handle the other cases.
return wxACC_NOT_IMPLEMENTED;
}
// Selects the object or child.
wxAccStatus SplitterWindowAccessible::Select(int childId, wxAccSelectionFlags WXUNUSED(selectFlags))
{
wxSplitterWindow* splitter = wxDynamicCast(GetWindow(), wxSplitterWindow);
if (splitter && splitter->IsSplit() && childId == 2)
{
// Can't select the sash.
return wxACC_FALSE;
}
// Let the framework handle the other cases.
return wxACC_NOT_IMPLEMENTED;
}
// Gets the window with the keyboard focus.
// If childId is 0 and child is NULL, no object in
// this subhierarchy has the focus.
// If this object has the focus, child should be 'this'.
wxAccStatus SplitterWindowAccessible::GetFocus(int* WXUNUSED(childId), wxAccessible** WXUNUSED(child))
{
return wxACC_NOT_IMPLEMENTED;
}
// Gets a variant representing the selected children
// of this object.
// Acceptable values:
// - a null variant (IsNull() returns true)
// - a list variant (GetType() == wxT("list"))
// - an integer representing the selected child element,
// or 0 if this object is selected (GetType() == wxT("long"))
// - a "void*" pointer to a wxAccessible child object
wxAccStatus SplitterWindowAccessible::GetSelections(wxVariant* WXUNUSED(selections))
{
return wxACC_NOT_IMPLEMENTED;
}
#endif // wxUSE_ACCESSIBILITY
