#include "content/browser/accessibility/browser_accessibility_state_impl.h"
#include "content/common/accessibility_messages.h"
#include "content/public/common/content_client.h"
-#include "ui/base/accessibility/accessible_text_utils.h"
+#include "ui/accessibility/ax_text_utils.h"
#include "ui/base/win/accessibility_ids_win.h"
#include "ui/base/win/accessibility_misc_utils.h"
+#include "ui/base/win/atl_module.h"
namespace content {
0xa5d8e1f3, 0x3571, 0x4d8f,
0x95, 0x21, 0x07, 0xed, 0x28, 0xfb, 0x07, 0x2e};
-const char16 BrowserAccessibilityWin::kEmbeddedCharacter[] = L"\xfffc";
+const base::char16 BrowserAccessibilityWin::kEmbeddedCharacter[] = L"\xfffc";
// static
LONG BrowserAccessibilityWin::next_unique_id_win_ =
CONTENT_EXPORT virtual ~BrowserAccessibilityRelation() {}
CONTENT_EXPORT void Initialize(BrowserAccessibilityWin* owner,
- const string16& type);
+ const base::string16& type);
CONTENT_EXPORT void AddTarget(int target_id);
// IAccessibleRelation methods.
}
private:
- string16 type_;
+ base::string16 type_;
base::win::ScopedComPtr<BrowserAccessibilityWin> owner_;
std::vector<int> target_ids_;
};
void BrowserAccessibilityRelation::Initialize(BrowserAccessibilityWin* owner,
- const string16& type) {
+ const base::string16& type) {
owner_ = owner;
type_ = type;
}
BrowserAccessibilityManager* manager = owner_->manager();
for (long i = *n_targets - 1; i >= 0; --i) {
- BrowserAccessibility* result = manager->GetFromRendererID(target_ids_[i]);
+ BrowserAccessibility* result = manager->GetFromID(target_ids_[i]);
if (!result || !result->instance_active()) {
*n_targets = 0;
break;
BrowserAccessibilityManager* manager = owner_->manager();
BrowserAccessibility* result =
- manager->GetFromRendererID(target_ids_[target_index]);
+ manager->GetFromID(target_ids_[target_index]);
if (!result || !result->instance_active())
return E_FAIL;
// static
BrowserAccessibility* BrowserAccessibility::Create() {
+ ui::win::CreateATLModuleIfNeeded();
CComObject<BrowserAccessibilityWin>* instance;
HRESULT hr = CComObject<BrowserAccessibilityWin>::CreateInstance(&instance);
DCHECK(SUCCEEDED(hr));
ia2_role_(0),
ia2_state_(0),
first_time_(true),
- old_ia_state_(0) {
+ old_ia_state_(0),
+ previous_scroll_x_(0),
+ previous_scroll_y_(0) {
// Start unique IDs at -1 and decrement each time, because get_accChild
// uses positive IDs to enumerate children, so we use negative IDs to
// clearly distinguish between indices and unique IDs.
// IAccessible methods.
//
// Conventions:
-// * Always test for instance_active_ first and return E_FAIL if it's false.
+// * Always test for instance_active() first and return E_FAIL if it's false.
// * Always check for invalid arguments first, even if they're unused.
// * Return S_FALSE if the only output is a string argument and it's empty.
//
HRESULT BrowserAccessibilityWin::accDoDefaultAction(VARIANT var_id) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
if (!target)
return E_INVALIDARG;
- manager_->DoDefaultAction(*target);
+ manager()->DoDefaultAction(*target);
return S_OK;
}
STDMETHODIMP BrowserAccessibilityWin::accHitTest(LONG x_left,
LONG y_top,
VARIANT* child) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!child)
LONG* width,
LONG* height,
VARIANT var_id) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!x_left || !y_top || !width || !height)
return E_INVALIDARG;
}
+ uint32 child_count = target->PlatformChildCount();
+
BrowserAccessibility* result = NULL;
switch (nav_dir) {
case NAVDIR_DOWN:
// These directions are not implemented, matching Mozilla and IE.
return E_NOTIMPL;
case NAVDIR_FIRSTCHILD:
- if (!target->children_.empty())
- result = target->children_.front();
+ if (child_count > 0)
+ result = target->PlatformGetChild(0);
break;
case NAVDIR_LASTCHILD:
- if (!target->children_.empty())
- result = target->children_.back();
+ if (child_count > 0)
+ result = target->PlatformGetChild(child_count - 1);
break;
case NAVDIR_NEXT:
result = target->GetNextSibling();
STDMETHODIMP BrowserAccessibilityWin::get_accChild(VARIANT var_child,
IDispatch** disp_child) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!disp_child)
}
STDMETHODIMP BrowserAccessibilityWin::get_accChildCount(LONG* child_count) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!child_count)
STDMETHODIMP BrowserAccessibilityWin::get_accDefaultAction(VARIANT var_id,
BSTR* def_action) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!def_action)
return E_INVALIDARG;
return target->GetStringAttributeAsBstr(
- AccessibilityNodeData::ATTR_SHORTCUT, def_action);
+ ui::AX_ATTR_SHORTCUT, def_action);
}
STDMETHODIMP BrowserAccessibilityWin::get_accDescription(VARIANT var_id,
BSTR* desc) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!desc)
return E_INVALIDARG;
return target->GetStringAttributeAsBstr(
- AccessibilityNodeData::ATTR_DESCRIPTION, desc);
+ ui::AX_ATTR_DESCRIPTION, desc);
}
STDMETHODIMP BrowserAccessibilityWin::get_accFocus(VARIANT* focus_child) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!focus_child)
return E_INVALIDARG;
BrowserAccessibilityWin* focus = static_cast<BrowserAccessibilityWin*>(
- manager_->GetFocus(this));
+ manager()->GetFocus(this));
if (focus == this) {
focus_child->vt = VT_I4;
focus_child->lVal = CHILDID_SELF;
}
STDMETHODIMP BrowserAccessibilityWin::get_accHelp(VARIANT var_id, BSTR* help) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!help)
return E_INVALIDARG;
return target->GetStringAttributeAsBstr(
- AccessibilityNodeData::ATTR_HELP, help);
+ ui::AX_ATTR_HELP, help);
}
STDMETHODIMP BrowserAccessibilityWin::get_accKeyboardShortcut(VARIANT var_id,
BSTR* acc_key) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!acc_key)
return E_INVALIDARG;
return target->GetStringAttributeAsBstr(
- AccessibilityNodeData::ATTR_SHORTCUT, acc_key);
+ ui::AX_ATTR_SHORTCUT, acc_key);
}
STDMETHODIMP BrowserAccessibilityWin::get_accName(VARIANT var_id, BSTR* name) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!name)
// If the name is empty, see if it's labeled by another element.
if (name_str.empty()) {
int title_elem_id;
- if (target->GetIntAttribute(AccessibilityNodeData::ATTR_TITLE_UI_ELEMENT,
+ if (target->GetIntAttribute(ui::AX_ATTR_TITLE_UI_ELEMENT,
&title_elem_id)) {
BrowserAccessibility* title_elem =
- manager_->GetFromRendererID(title_elem_id);
+ manager()->GetFromID(title_elem_id);
if (title_elem)
name_str = title_elem->GetTextRecursive();
}
if (name_str.empty())
return S_FALSE;
- *name = SysAllocString(UTF8ToUTF16(name_str).c_str());
+ *name = SysAllocString(base::UTF8ToUTF16(name_str).c_str());
DCHECK(*name);
return S_OK;
}
STDMETHODIMP BrowserAccessibilityWin::get_accParent(IDispatch** disp_parent) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!disp_parent)
return E_INVALIDARG;
- IAccessible* parent = parent_->ToBrowserAccessibilityWin();
- if (parent == NULL) {
+ IAccessible* parent_obj = GetParent()->ToBrowserAccessibilityWin();
+ if (parent_obj == NULL) {
// This happens if we're the root of the tree;
// return the IAccessible for the window.
- parent = manager_->ToBrowserAccessibilityManagerWin()->parent_iaccessible();
+ parent_obj =
+ manager()->ToBrowserAccessibilityManagerWin()->GetParentIAccessible();
// |parent| can only be NULL if the manager was created before the parent
// IAccessible was known and it wasn't subsequently set before a client
- // requested it. Crash hard if this happens so that we get crash reports.
- CHECK(parent);
+ // requested it. This has been fixed. |parent| may also be NULL during
+ // destruction. Possible cases where this could occur include tabs being
+ // dragged to a new window, etc.
+ if (!parent_obj) {
+ DVLOG(1) << "In Function: "
+ << __FUNCTION__
+ << ". Parent IAccessible interface is NULL. Returning failure";
+ return E_FAIL;
+ }
}
-
- parent->AddRef();
- *disp_parent = parent;
+ parent_obj->AddRef();
+ *disp_parent = parent_obj;
return S_OK;
}
STDMETHODIMP BrowserAccessibilityWin::get_accRole(VARIANT var_id,
VARIANT* role) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!role)
STDMETHODIMP BrowserAccessibilityWin::get_accState(VARIANT var_id,
VARIANT* state) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!state)
state->vt = VT_I4;
state->lVal = target->ia_state_;
- if (manager_->GetFocus(NULL) == this)
+ if (manager()->GetFocus(NULL) == this)
state->lVal |= STATE_SYSTEM_FOCUSED;
return S_OK;
STDMETHODIMP BrowserAccessibilityWin::get_accValue(VARIANT var_id,
BSTR* value) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!value)
if (target->ia_role() == ROLE_SYSTEM_PROGRESSBAR ||
target->ia_role() == ROLE_SYSTEM_SCROLLBAR ||
target->ia_role() == ROLE_SYSTEM_SLIDER) {
- string16 value_text = target->GetValueText();
+ base::string16 value_text = target->GetValueText();
*value = SysAllocString(value_text.c_str());
DCHECK(*value);
return S_OK;
// Expose color well value.
if (target->ia2_role() == IA2_ROLE_COLOR_CHOOSER) {
int r = target->GetIntAttribute(
- AccessibilityNodeData::ATTR_COLOR_VALUE_RED);
+ ui::AX_ATTR_COLOR_VALUE_RED);
int g = target->GetIntAttribute(
- AccessibilityNodeData::ATTR_COLOR_VALUE_GREEN);
+ ui::AX_ATTR_COLOR_VALUE_GREEN);
int b = target->GetIntAttribute(
- AccessibilityNodeData::ATTR_COLOR_VALUE_BLUE);
- string16 value_text;
+ ui::AX_ATTR_COLOR_VALUE_BLUE);
+ base::string16 value_text;
value_text = base::IntToString16((r * 100) / 255) + L"% red " +
base::IntToString16((g * 100) / 255) + L"% green " +
base::IntToString16((b * 100) / 255) + L"% blue";
return S_OK;
}
- *value = SysAllocString(UTF8ToUTF16(target->value()).c_str());
+ *value = SysAllocString(base::UTF8ToUTF16(target->value()).c_str());
DCHECK(*value);
return S_OK;
}
}
STDMETHODIMP BrowserAccessibilityWin::get_accSelection(VARIANT* selected) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
- if (role_ != WebKit::WebAXRoleListBox)
+ if (GetRole() != ui::AX_ROLE_LIST_BOX)
return E_NOTIMPL;
unsigned long selected_count = 0;
- for (size_t i = 0; i < children_.size(); ++i) {
- if (children_[i]->HasState(WebKit::WebAXStateSelected))
+ for (size_t i = 0; i < InternalChildCount(); ++i) {
+ if (InternalGetChild(i)->HasState(ui::AX_STATE_SELECTED))
++selected_count;
}
}
if (selected_count == 1) {
- for (size_t i = 0; i < children_.size(); ++i) {
- if (children_[i]->HasState(WebKit::WebAXStateSelected)) {
+ for (size_t i = 0; i < InternalChildCount(); ++i) {
+ if (InternalGetChild(i)->HasState(ui::AX_STATE_SELECTED)) {
selected->vt = VT_DISPATCH;
selected->pdispVal =
- children_[i]->ToBrowserAccessibilityWin()->NewReference();
+ InternalGetChild(i)->ToBrowserAccessibilityWin()->NewReference();
return S_OK;
}
}
new base::win::EnumVariant(selected_count);
enum_variant->AddRef();
unsigned long index = 0;
- for (size_t i = 0; i < children_.size(); ++i) {
- if (children_[i]->HasState(WebKit::WebAXStateSelected)) {
+ for (size_t i = 0; i < InternalChildCount(); ++i) {
+ if (InternalGetChild(i)->HasState(ui::AX_STATE_SELECTED)) {
enum_variant->ItemAt(index)->vt = VT_DISPATCH;
enum_variant->ItemAt(index)->pdispVal =
- children_[i]->ToBrowserAccessibilityWin()->NewReference();
+ InternalGetChild(i)->ToBrowserAccessibilityWin()->NewReference();
++index;
}
}
STDMETHODIMP BrowserAccessibilityWin::accSelect(
LONG flags_sel, VARIANT var_id) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (flags_sel & SELFLAG_TAKEFOCUS) {
- manager_->SetFocus(this, true);
+ manager()->SetFocus(this, true);
return S_OK;
}
//
STDMETHODIMP BrowserAccessibilityWin::role(LONG* role) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!role)
}
STDMETHODIMP BrowserAccessibilityWin::get_attributes(BSTR* attributes) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!attributes)
// The iaccessible2 attributes are a set of key-value pairs
// separated by semicolons, with a colon between the key and the value.
- string16 str;
+ base::string16 str;
for (unsigned int i = 0; i < ia2_attributes_.size(); ++i) {
if (i != 0)
str += L';';
}
STDMETHODIMP BrowserAccessibilityWin::get_states(AccessibleStates* states) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!states)
}
STDMETHODIMP BrowserAccessibilityWin::get_uniqueID(LONG* unique_id) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!unique_id)
}
STDMETHODIMP BrowserAccessibilityWin::get_windowHandle(HWND* window_handle) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!window_handle)
return E_INVALIDARG;
- *window_handle = manager_->ToBrowserAccessibilityManagerWin()->parent_hwnd();
+ *window_handle =
+ manager()->ToBrowserAccessibilityManagerWin()->GetParentHWND();
+ if (!*window_handle)
+ return E_FAIL;
+
return S_OK;
}
STDMETHODIMP BrowserAccessibilityWin::get_indexInParent(LONG* index_in_parent) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!index_in_parent)
return E_INVALIDARG;
- *index_in_parent = index_in_parent_;
+ *index_in_parent = this->GetIndexInParent();
return S_OK;
}
STDMETHODIMP BrowserAccessibilityWin::get_nRelations(LONG* n_relations) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!n_relations)
STDMETHODIMP BrowserAccessibilityWin::get_relation(
LONG relation_index,
IAccessibleRelation** relation) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (relation_index < 0 ||
LONG max_relations,
IAccessibleRelation** relations,
LONG* n_relations) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!relations || !n_relations)
}
STDMETHODIMP BrowserAccessibilityWin::scrollTo(enum IA2ScrollType scroll_type) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
- gfx::Rect r = location_;
+ gfx::Rect r = GetLocation();
switch(scroll_type) {
case IA2_SCROLL_TYPE_TOP_LEFT:
- manager_->ScrollToMakeVisible(*this, gfx::Rect(r.x(), r.y(), 0, 0));
+ manager()->ScrollToMakeVisible(*this, gfx::Rect(r.x(), r.y(), 0, 0));
break;
case IA2_SCROLL_TYPE_BOTTOM_RIGHT:
- manager_->ScrollToMakeVisible(
+ manager()->ScrollToMakeVisible(
*this, gfx::Rect(r.right(), r.bottom(), 0, 0));
break;
case IA2_SCROLL_TYPE_TOP_EDGE:
- manager_->ScrollToMakeVisible(
+ manager()->ScrollToMakeVisible(
*this, gfx::Rect(r.x(), r.y(), r.width(), 0));
break;
case IA2_SCROLL_TYPE_BOTTOM_EDGE:
- manager_->ScrollToMakeVisible(
+ manager()->ScrollToMakeVisible(
*this, gfx::Rect(r.x(), r.bottom(), r.width(), 0));
break;
case IA2_SCROLL_TYPE_LEFT_EDGE:
- manager_->ScrollToMakeVisible(
+ manager()->ScrollToMakeVisible(
*this, gfx::Rect(r.x(), r.y(), 0, r.height()));
break;
case IA2_SCROLL_TYPE_RIGHT_EDGE:
- manager_->ScrollToMakeVisible(
+ manager()->ScrollToMakeVisible(
*this, gfx::Rect(r.right(), r.y(), 0, r.height()));
break;
case IA2_SCROLL_TYPE_ANYWHERE:
default:
- manager_->ScrollToMakeVisible(*this, r);
+ manager()->ScrollToMakeVisible(*this, r);
break;
}
- static_cast<BrowserAccessibilityManagerWin*>(manager_)
- ->TrackScrollingObject(this);
+ manager()->ToBrowserAccessibilityManagerWin()->TrackScrollingObject(this);
return S_OK;
}
enum IA2CoordinateType coordinate_type,
LONG x,
LONG y) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
gfx::Point scroll_to(x, y);
if (coordinate_type == IA2_COORDTYPE_SCREEN_RELATIVE) {
- scroll_to -= manager_->GetViewBounds().OffsetFromOrigin();
+ scroll_to -= manager()->GetViewBounds().OffsetFromOrigin();
} else if (coordinate_type == IA2_COORDTYPE_PARENT_RELATIVE) {
- if (parent_)
- scroll_to += parent_->location().OffsetFromOrigin();
+ if (GetParent())
+ scroll_to += GetParent()->GetLocation().OffsetFromOrigin();
} else {
return E_INVALIDARG;
}
- manager_->ScrollToPoint(*this, scroll_to);
-
- static_cast<BrowserAccessibilityManagerWin*>(manager_)
- ->TrackScrollingObject(this);
+ manager()->ScrollToPoint(*this, scroll_to);
+ manager()->ToBrowserAccessibilityManagerWin()->TrackScrollingObject(this);
return S_OK;
}
LONG* group_level,
LONG* similar_items_in_group,
LONG* position_in_group) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!group_level || !similar_items_in_group || !position_in_group)
return E_INVALIDARG;
- if (role_ == WebKit::WebAXRoleListBoxOption &&
- parent_ &&
- parent_->role() == WebKit::WebAXRoleListBox) {
+ if (GetRole() == ui::AX_ROLE_LIST_BOX_OPTION &&
+ GetParent() &&
+ GetParent()->GetRole() == ui::AX_ROLE_LIST_BOX) {
*group_level = 0;
- *similar_items_in_group = parent_->PlatformChildCount();
- *position_in_group = index_in_parent_ + 1;
+ *similar_items_in_group = GetParent()->PlatformChildCount();
+ *position_in_group = GetIndexInParent() + 1;
return S_OK;
}
//
STDMETHODIMP BrowserAccessibilityWin::get_appName(BSTR* app_name) {
- // No need to check |instance_active_| because this interface is
+ // No need to check |instance_active()| because this interface is
// global, and doesn't depend on any local state.
if (!app_name)
DCHECK_EQ(2U, product_components.size());
if (product_components.size() != 2)
return E_FAIL;
- *app_name = SysAllocString(UTF8ToUTF16(product_components[0]).c_str());
+ *app_name = SysAllocString(base::UTF8ToUTF16(product_components[0]).c_str());
DCHECK(*app_name);
return *app_name ? S_OK : E_FAIL;
}
STDMETHODIMP BrowserAccessibilityWin::get_appVersion(BSTR* app_version) {
- // No need to check |instance_active_| because this interface is
+ // No need to check |instance_active()| because this interface is
// global, and doesn't depend on any local state.
if (!app_version)
DCHECK_EQ(2U, product_components.size());
if (product_components.size() != 2)
return E_FAIL;
- *app_version = SysAllocString(UTF8ToUTF16(product_components[1]).c_str());
+ *app_version =
+ SysAllocString(base::UTF8ToUTF16(product_components[1]).c_str());
DCHECK(*app_version);
return *app_version ? S_OK : E_FAIL;
}
STDMETHODIMP BrowserAccessibilityWin::get_toolkitName(BSTR* toolkit_name) {
- // No need to check |instance_active_| because this interface is
+ // No need to check |instance_active()| because this interface is
// global, and doesn't depend on any local state.
if (!toolkit_name)
STDMETHODIMP BrowserAccessibilityWin::get_toolkitVersion(
BSTR* toolkit_version) {
- // No need to check |instance_active_| because this interface is
+ // No need to check |instance_active()| because this interface is
// global, and doesn't depend on any local state.
if (!toolkit_version)
return E_INVALIDARG;
std::string user_agent = GetContentClient()->GetUserAgent();
- *toolkit_version = SysAllocString(UTF8ToUTF16(user_agent).c_str());
+ *toolkit_version = SysAllocString(base::UTF8ToUTF16(user_agent).c_str());
DCHECK(*toolkit_version);
return *toolkit_version ? S_OK : E_FAIL;
}
//
STDMETHODIMP BrowserAccessibilityWin::get_description(BSTR* desc) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!desc)
return E_INVALIDARG;
return GetStringAttributeAsBstr(
- AccessibilityNodeData::ATTR_DESCRIPTION, desc);
+ ui::AX_ATTR_DESCRIPTION, desc);
}
STDMETHODIMP BrowserAccessibilityWin::get_imagePosition(
enum IA2CoordinateType coordinate_type,
LONG* x,
LONG* y) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!x || !y)
if (coordinate_type == IA2_COORDTYPE_SCREEN_RELATIVE) {
HWND parent_hwnd =
- manager_->ToBrowserAccessibilityManagerWin()->parent_hwnd();
+ manager()->ToBrowserAccessibilityManagerWin()->GetParentHWND();
+ if (!parent_hwnd)
+ return E_FAIL;
POINT top_left = {0, 0};
::ClientToScreen(parent_hwnd, &top_left);
- *x = location_.x() + top_left.x;
- *y = location_.y() + top_left.y;
+ *x = GetLocation().x() + top_left.x;
+ *y = GetLocation().y() + top_left.y;
} else if (coordinate_type == IA2_COORDTYPE_PARENT_RELATIVE) {
- *x = location_.x();
- *y = location_.y();
- if (parent_) {
- *x -= parent_->location().x();
- *y -= parent_->location().y();
+ *x = GetLocation().x();
+ *y = GetLocation().y();
+ if (GetParent()) {
+ *x -= GetParent()->GetLocation().x();
+ *y -= GetParent()->GetLocation().y();
}
} else {
return E_INVALIDARG;
}
STDMETHODIMP BrowserAccessibilityWin::get_imageSize(LONG* height, LONG* width) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!height || !width)
return E_INVALIDARG;
- *height = location_.height();
- *width = location_.width();
+ *height = GetLocation().height();
+ *width = GetLocation().width();
return S_OK;
}
long row,
long column,
IUnknown** accessible) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!accessible)
int columns;
int rows;
if (!GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_COLUMN_COUNT, &columns) ||
+ ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
!GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_ROW_COUNT, &rows) ||
+ ui::AX_ATTR_TABLE_ROW_COUNT, &rows) ||
columns <= 0 ||
rows <= 0) {
return S_FALSE;
return E_INVALIDARG;
const std::vector<int32>& cell_ids = GetIntListAttribute(
- AccessibilityNodeData::ATTR_CELL_IDS);
+ ui::AX_ATTR_CELL_IDS);
DCHECK_EQ(columns * rows, static_cast<int>(cell_ids.size()));
int cell_id = cell_ids[row * columns + column];
- BrowserAccessibilityWin* cell = GetFromRendererID(cell_id);
+ BrowserAccessibilityWin* cell = GetFromID(cell_id);
if (cell) {
*accessible = static_cast<IAccessible*>(cell->NewReference());
return S_OK;
}
STDMETHODIMP BrowserAccessibilityWin::get_caption(IUnknown** accessible) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!accessible)
STDMETHODIMP BrowserAccessibilityWin::get_childIndex(long row,
long column,
long* cell_index) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!cell_index)
int columns;
int rows;
if (!GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_COLUMN_COUNT, &columns) ||
+ ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
!GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_ROW_COUNT, &rows) ||
+ ui::AX_ATTR_TABLE_ROW_COUNT, &rows) ||
columns <= 0 ||
rows <= 0) {
return S_FALSE;
return E_INVALIDARG;
const std::vector<int32>& cell_ids = GetIntListAttribute(
- AccessibilityNodeData::ATTR_CELL_IDS);
+ ui::AX_ATTR_CELL_IDS);
const std::vector<int32>& unique_cell_ids = GetIntListAttribute(
- AccessibilityNodeData::ATTR_UNIQUE_CELL_IDS);
+ ui::AX_ATTR_UNIQUE_CELL_IDS);
DCHECK_EQ(columns * rows, static_cast<int>(cell_ids.size()));
int cell_id = cell_ids[row * columns + column];
for (size_t i = 0; i < unique_cell_ids.size(); ++i) {
STDMETHODIMP BrowserAccessibilityWin::get_columnDescription(long column,
BSTR* description) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!description)
int columns;
int rows;
if (!GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_COLUMN_COUNT, &columns) ||
- !GetIntAttribute(AccessibilityNodeData::ATTR_TABLE_ROW_COUNT, &rows) ||
+ ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
+ !GetIntAttribute(ui::AX_ATTR_TABLE_ROW_COUNT, &rows) ||
columns <= 0 ||
rows <= 0) {
return S_FALSE;
return E_INVALIDARG;
const std::vector<int32>& cell_ids = GetIntListAttribute(
- AccessibilityNodeData::ATTR_CELL_IDS);
+ ui::AX_ATTR_CELL_IDS);
for (int i = 0; i < rows; ++i) {
int cell_id = cell_ids[i * columns + column];
BrowserAccessibilityWin* cell = static_cast<BrowserAccessibilityWin*>(
- manager_->GetFromRendererID(cell_id));
- if (cell && cell->role_ == WebKit::WebAXRoleColumnHeader) {
- string16 cell_name = cell->GetString16Attribute(
- AccessibilityNodeData::ATTR_NAME);
+ manager()->GetFromID(cell_id));
+ if (cell && cell->GetRole() == ui::AX_ROLE_COLUMN_HEADER) {
+ base::string16 cell_name = cell->GetString16Attribute(
+ ui::AX_ATTR_NAME);
if (cell_name.size() > 0) {
*description = SysAllocString(cell_name.c_str());
return S_OK;
}
return cell->GetStringAttributeAsBstr(
- AccessibilityNodeData::ATTR_DESCRIPTION, description);
+ ui::AX_ATTR_DESCRIPTION, description);
}
}
long row,
long column,
long* n_columns_spanned) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!n_columns_spanned)
int columns;
int rows;
if (!GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_COLUMN_COUNT, &columns) ||
- !GetIntAttribute(AccessibilityNodeData::ATTR_TABLE_ROW_COUNT, &rows) ||
+ ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
+ !GetIntAttribute(ui::AX_ATTR_TABLE_ROW_COUNT, &rows) ||
columns <= 0 ||
rows <= 0) {
return S_FALSE;
return E_INVALIDARG;
const std::vector<int32>& cell_ids = GetIntListAttribute(
- AccessibilityNodeData::ATTR_CELL_IDS);
+ ui::AX_ATTR_CELL_IDS);
int cell_id = cell_ids[row * columns + column];
BrowserAccessibilityWin* cell = static_cast<BrowserAccessibilityWin*>(
- manager_->GetFromRendererID(cell_id));
+ manager()->GetFromID(cell_id));
int colspan;
if (cell &&
cell->GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_CELL_COLUMN_SPAN, &colspan) &&
+ ui::AX_ATTR_TABLE_CELL_COLUMN_SPAN, &colspan) &&
colspan >= 1) {
*n_columns_spanned = colspan;
return S_OK;
STDMETHODIMP BrowserAccessibilityWin::get_columnIndex(long cell_index,
long* column_index) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!column_index)
return E_INVALIDARG;
const std::vector<int32>& unique_cell_ids = GetIntListAttribute(
- AccessibilityNodeData::ATTR_UNIQUE_CELL_IDS);
+ ui::AX_ATTR_UNIQUE_CELL_IDS);
int cell_id_count = static_cast<int>(unique_cell_ids.size());
if (cell_index < 0)
return E_INVALIDARG;
int cell_id = unique_cell_ids[cell_index];
BrowserAccessibilityWin* cell =
- manager_->GetFromRendererID(cell_id)->ToBrowserAccessibilityWin();
+ manager()->GetFromID(cell_id)->ToBrowserAccessibilityWin();
int col_index;
if (cell &&
cell->GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_CELL_COLUMN_INDEX, &col_index)) {
+ ui::AX_ATTR_TABLE_CELL_COLUMN_INDEX, &col_index)) {
*column_index = col_index;
return S_OK;
}
}
STDMETHODIMP BrowserAccessibilityWin::get_nColumns(long* column_count) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!column_count)
int columns;
if (GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_COLUMN_COUNT, &columns)) {
+ ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns)) {
*column_count = columns;
return S_OK;
}
}
STDMETHODIMP BrowserAccessibilityWin::get_nRows(long* row_count) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!row_count)
return E_INVALIDARG;
int rows;
- if (GetIntAttribute(AccessibilityNodeData::ATTR_TABLE_ROW_COUNT, &rows)) {
+ if (GetIntAttribute(ui::AX_ATTR_TABLE_ROW_COUNT, &rows)) {
*row_count = rows;
return S_OK;
}
}
STDMETHODIMP BrowserAccessibilityWin::get_nSelectedChildren(long* cell_count) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!cell_count)
}
STDMETHODIMP BrowserAccessibilityWin::get_nSelectedColumns(long* column_count) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!column_count)
}
STDMETHODIMP BrowserAccessibilityWin::get_nSelectedRows(long* row_count) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!row_count)
STDMETHODIMP BrowserAccessibilityWin::get_rowDescription(long row,
BSTR* description) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!description)
int columns;
int rows;
if (!GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_COLUMN_COUNT, &columns) ||
- !GetIntAttribute(AccessibilityNodeData::ATTR_TABLE_ROW_COUNT, &rows) ||
+ ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
+ !GetIntAttribute(ui::AX_ATTR_TABLE_ROW_COUNT, &rows) ||
columns <= 0 ||
rows <= 0) {
return S_FALSE;
return E_INVALIDARG;
const std::vector<int32>& cell_ids = GetIntListAttribute(
- AccessibilityNodeData::ATTR_CELL_IDS);
+ ui::AX_ATTR_CELL_IDS);
for (int i = 0; i < columns; ++i) {
int cell_id = cell_ids[row * columns + i];
BrowserAccessibilityWin* cell =
- manager_->GetFromRendererID(cell_id)->ToBrowserAccessibilityWin();
- if (cell && cell->role_ == WebKit::WebAXRoleRowHeader) {
- string16 cell_name = cell->GetString16Attribute(
- AccessibilityNodeData::ATTR_NAME);
+ manager()->GetFromID(cell_id)->ToBrowserAccessibilityWin();
+ if (cell && cell->GetRole() == ui::AX_ROLE_ROW_HEADER) {
+ base::string16 cell_name = cell->GetString16Attribute(
+ ui::AX_ATTR_NAME);
if (cell_name.size() > 0) {
*description = SysAllocString(cell_name.c_str());
return S_OK;
}
return cell->GetStringAttributeAsBstr(
- AccessibilityNodeData::ATTR_DESCRIPTION, description);
+ ui::AX_ATTR_DESCRIPTION, description);
}
}
STDMETHODIMP BrowserAccessibilityWin::get_rowExtentAt(long row,
long column,
long* n_rows_spanned) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!n_rows_spanned)
int columns;
int rows;
if (!GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_COLUMN_COUNT, &columns) ||
- !GetIntAttribute(AccessibilityNodeData::ATTR_TABLE_ROW_COUNT, &rows) ||
+ ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
+ !GetIntAttribute(ui::AX_ATTR_TABLE_ROW_COUNT, &rows) ||
columns <= 0 ||
rows <= 0) {
return S_FALSE;
return E_INVALIDARG;
const std::vector<int32>& cell_ids = GetIntListAttribute(
- AccessibilityNodeData::ATTR_CELL_IDS);
+ ui::AX_ATTR_CELL_IDS);
int cell_id = cell_ids[row * columns + column];
BrowserAccessibilityWin* cell =
- manager_->GetFromRendererID(cell_id)->ToBrowserAccessibilityWin();
+ manager()->GetFromID(cell_id)->ToBrowserAccessibilityWin();
int rowspan;
if (cell &&
cell->GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_CELL_ROW_SPAN, &rowspan) &&
+ ui::AX_ATTR_TABLE_CELL_ROW_SPAN, &rowspan) &&
rowspan >= 1) {
*n_rows_spanned = rowspan;
return S_OK;
STDMETHODIMP BrowserAccessibilityWin::get_rowIndex(long cell_index,
long* row_index) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!row_index)
return E_INVALIDARG;
const std::vector<int32>& unique_cell_ids = GetIntListAttribute(
- AccessibilityNodeData::ATTR_UNIQUE_CELL_IDS);
+ ui::AX_ATTR_UNIQUE_CELL_IDS);
int cell_id_count = static_cast<int>(unique_cell_ids.size());
if (cell_index < 0)
return E_INVALIDARG;
int cell_id = unique_cell_ids[cell_index];
BrowserAccessibilityWin* cell =
- manager_->GetFromRendererID(cell_id)->ToBrowserAccessibilityWin();
+ manager()->GetFromID(cell_id)->ToBrowserAccessibilityWin();
int cell_row_index;
if (cell &&
cell->GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_CELL_ROW_INDEX, &cell_row_index)) {
+ ui::AX_ATTR_TABLE_CELL_ROW_INDEX, &cell_row_index)) {
*row_index = cell_row_index;
return S_OK;
}
STDMETHODIMP BrowserAccessibilityWin::get_selectedChildren(long max_children,
long** children,
long* n_children) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!children || !n_children)
STDMETHODIMP BrowserAccessibilityWin::get_selectedColumns(long max_columns,
long** columns,
long* n_columns) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!columns || !n_columns)
STDMETHODIMP BrowserAccessibilityWin::get_selectedRows(long max_rows,
long** rows,
long* n_rows) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!rows || !n_rows)
}
STDMETHODIMP BrowserAccessibilityWin::get_summary(IUnknown** accessible) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!accessible)
STDMETHODIMP BrowserAccessibilityWin::get_isColumnSelected(
long column,
boolean* is_selected) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!is_selected)
STDMETHODIMP BrowserAccessibilityWin::get_isRowSelected(long row,
boolean* is_selected) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!is_selected)
STDMETHODIMP BrowserAccessibilityWin::get_isSelected(long row,
long column,
boolean* is_selected) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!is_selected)
long* row_extents,
long* column_extents,
boolean* is_selected) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!row || !column || !row_extents || !column_extents || !is_selected)
return E_INVALIDARG;
const std::vector<int32>& unique_cell_ids = GetIntListAttribute(
- AccessibilityNodeData::ATTR_UNIQUE_CELL_IDS);
+ ui::AX_ATTR_UNIQUE_CELL_IDS);
int cell_id_count = static_cast<int>(unique_cell_ids.size());
if (index < 0)
return E_INVALIDARG;
int cell_id = unique_cell_ids[index];
BrowserAccessibilityWin* cell =
- manager_->GetFromRendererID(cell_id)->ToBrowserAccessibilityWin();
+ manager()->GetFromID(cell_id)->ToBrowserAccessibilityWin();
int rowspan;
int colspan;
if (cell &&
cell->GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_CELL_ROW_SPAN, &rowspan) &&
+ ui::AX_ATTR_TABLE_CELL_ROW_SPAN, &rowspan) &&
cell->GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_CELL_COLUMN_SPAN, &colspan) &&
+ ui::AX_ATTR_TABLE_CELL_COLUMN_SPAN, &colspan) &&
rowspan >= 1 &&
colspan >= 1) {
*row_extents = rowspan;
STDMETHODIMP BrowserAccessibilityWin::get_selectedCells(
IUnknown*** cells,
long* n_selected_cells) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!cells || !n_selected_cells)
STDMETHODIMP BrowserAccessibilityWin::get_selectedColumns(long** columns,
long* n_columns) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!columns || !n_columns)
STDMETHODIMP BrowserAccessibilityWin::get_selectedRows(long** rows,
long* n_rows) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!rows || !n_rows)
STDMETHODIMP BrowserAccessibilityWin::get_columnExtent(
long* n_columns_spanned) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!n_columns_spanned)
int colspan;
if (GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_CELL_COLUMN_SPAN, &colspan) &&
+ ui::AX_ATTR_TABLE_CELL_COLUMN_SPAN, &colspan) &&
colspan >= 1) {
*n_columns_spanned = colspan;
return S_OK;
STDMETHODIMP BrowserAccessibilityWin::get_columnHeaderCells(
IUnknown*** cell_accessibles,
long* n_column_header_cells) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!cell_accessibles || !n_column_header_cells)
int column;
if (!GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_CELL_COLUMN_INDEX, &column)) {
+ ui::AX_ATTR_TABLE_CELL_COLUMN_INDEX, &column)) {
return S_FALSE;
}
- BrowserAccessibility* table = parent();
- while (table && table->role() != WebKit::WebAXRoleTable)
- table = table->parent();
+ BrowserAccessibility* table = GetParent();
+ while (table && table->GetRole() != ui::AX_ROLE_TABLE)
+ table = table->GetParent();
if (!table) {
NOTREACHED();
return S_FALSE;
int columns;
int rows;
if (!table->GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_COLUMN_COUNT, &columns) ||
+ ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
!table->GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_ROW_COUNT, &rows)) {
+ ui::AX_ATTR_TABLE_ROW_COUNT, &rows)) {
return S_FALSE;
}
if (columns <= 0 || rows <= 0 || column < 0 || column >= columns)
return S_FALSE;
const std::vector<int32>& cell_ids = table->GetIntListAttribute(
- AccessibilityNodeData::ATTR_CELL_IDS);
+ ui::AX_ATTR_CELL_IDS);
for (int i = 0; i < rows; ++i) {
int cell_id = cell_ids[i * columns + column];
BrowserAccessibilityWin* cell =
- manager_->GetFromRendererID(cell_id)->ToBrowserAccessibilityWin();
- if (cell && cell->role_ == WebKit::WebAXRoleColumnHeader)
+ manager()->GetFromID(cell_id)->ToBrowserAccessibilityWin();
+ if (cell && cell->GetRole() == ui::AX_ROLE_COLUMN_HEADER)
(*n_column_header_cells)++;
}
int index = 0;
for (int i = 0; i < rows; ++i) {
int cell_id = cell_ids[i * columns + column];
- BrowserAccessibilityWin* cell =
- manager_->GetFromRendererID(cell_id)->ToBrowserAccessibilityWin();
- if (cell && cell->role_ == WebKit::WebAXRoleColumnHeader) {
- (*cell_accessibles)[index] =
- static_cast<IAccessible*>(cell->NewReference());
+ BrowserAccessibility* cell = manager()->GetFromID(cell_id);
+ if (cell && cell->GetRole() == ui::AX_ROLE_COLUMN_HEADER) {
+ (*cell_accessibles)[index] = static_cast<IAccessible*>(
+ cell->ToBrowserAccessibilityWin()->NewReference());
++index;
}
}
}
STDMETHODIMP BrowserAccessibilityWin::get_columnIndex(long* column_index) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!column_index)
int column;
if (GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_CELL_COLUMN_INDEX, &column)) {
+ ui::AX_ATTR_TABLE_CELL_COLUMN_INDEX, &column)) {
*column_index = column;
return S_OK;
}
}
STDMETHODIMP BrowserAccessibilityWin::get_rowExtent(long* n_rows_spanned) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!n_rows_spanned)
int rowspan;
if (GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_CELL_ROW_SPAN, &rowspan) &&
+ ui::AX_ATTR_TABLE_CELL_ROW_SPAN, &rowspan) &&
rowspan >= 1) {
*n_rows_spanned = rowspan;
return S_OK;
STDMETHODIMP BrowserAccessibilityWin::get_rowHeaderCells(
IUnknown*** cell_accessibles,
long* n_row_header_cells) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!cell_accessibles || !n_row_header_cells)
int row;
if (!GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_CELL_ROW_INDEX, &row)) {
+ ui::AX_ATTR_TABLE_CELL_ROW_INDEX, &row)) {
return S_FALSE;
}
- BrowserAccessibility* table = parent();
- while (table && table->role() != WebKit::WebAXRoleTable)
- table = table->parent();
+ BrowserAccessibility* table = GetParent();
+ while (table && table->GetRole() != ui::AX_ROLE_TABLE)
+ table = table->GetParent();
if (!table) {
NOTREACHED();
return S_FALSE;
int columns;
int rows;
if (!table->GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_COLUMN_COUNT, &columns) ||
+ ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
!table->GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_ROW_COUNT, &rows)) {
+ ui::AX_ATTR_TABLE_ROW_COUNT, &rows)) {
return S_FALSE;
}
if (columns <= 0 || rows <= 0 || row < 0 || row >= rows)
return S_FALSE;
const std::vector<int32>& cell_ids = table->GetIntListAttribute(
- AccessibilityNodeData::ATTR_CELL_IDS);
+ ui::AX_ATTR_CELL_IDS);
for (int i = 0; i < columns; ++i) {
int cell_id = cell_ids[row * columns + i];
- BrowserAccessibilityWin* cell =
- manager_->GetFromRendererID(cell_id)->ToBrowserAccessibilityWin();
- if (cell && cell->role_ == WebKit::WebAXRoleRowHeader)
+ BrowserAccessibility* cell = manager()->GetFromID(cell_id);
+ if (cell && cell->GetRole() == ui::AX_ROLE_ROW_HEADER)
(*n_row_header_cells)++;
}
int index = 0;
for (int i = 0; i < columns; ++i) {
int cell_id = cell_ids[row * columns + i];
- BrowserAccessibilityWin* cell =
- manager_->GetFromRendererID(cell_id)->ToBrowserAccessibilityWin();
- if (cell && cell->role_ == WebKit::WebAXRoleRowHeader) {
- (*cell_accessibles)[index] =
- static_cast<IAccessible*>(cell->NewReference());
+ BrowserAccessibility* cell = manager()->GetFromID(cell_id);
+ if (cell && cell->GetRole() == ui::AX_ROLE_ROW_HEADER) {
+ (*cell_accessibles)[index] = static_cast<IAccessible*>(
+ cell->ToBrowserAccessibilityWin()->NewReference());
++index;
}
}
}
STDMETHODIMP BrowserAccessibilityWin::get_rowIndex(long* row_index) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!row_index)
return E_INVALIDARG;
int row;
- if (GetIntAttribute(AccessibilityNodeData::ATTR_TABLE_CELL_ROW_INDEX, &row)) {
+ if (GetIntAttribute(ui::AX_ATTR_TABLE_CELL_ROW_INDEX, &row)) {
*row_index = row;
return S_OK;
}
}
STDMETHODIMP BrowserAccessibilityWin::get_isSelected(boolean* is_selected) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!is_selected)
long* row_extents,
long* column_extents,
boolean* is_selected) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!row_index ||
int column;
int rowspan;
int colspan;
- if (GetIntAttribute(AccessibilityNodeData::ATTR_TABLE_CELL_ROW_INDEX, &row) &&
+ if (GetIntAttribute(ui::AX_ATTR_TABLE_CELL_ROW_INDEX, &row) &&
GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_CELL_COLUMN_INDEX, &column) &&
+ ui::AX_ATTR_TABLE_CELL_COLUMN_INDEX, &column) &&
GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_CELL_ROW_SPAN, &rowspan) &&
+ ui::AX_ATTR_TABLE_CELL_ROW_SPAN, &rowspan) &&
GetIntAttribute(
- AccessibilityNodeData::ATTR_TABLE_CELL_COLUMN_SPAN, &colspan)) {
+ ui::AX_ATTR_TABLE_CELL_COLUMN_SPAN, &colspan)) {
*row_index = row;
*column_index = column;
*row_extents = rowspan;
}
STDMETHODIMP BrowserAccessibilityWin::get_table(IUnknown** table) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!table)
int row;
int column;
- GetIntAttribute(AccessibilityNodeData::ATTR_TABLE_CELL_ROW_INDEX, &row);
- GetIntAttribute(AccessibilityNodeData::ATTR_TABLE_CELL_COLUMN_INDEX, &column);
+ GetIntAttribute(ui::AX_ATTR_TABLE_CELL_ROW_INDEX, &row);
+ GetIntAttribute(ui::AX_ATTR_TABLE_CELL_COLUMN_INDEX, &column);
- BrowserAccessibility* find_table = parent();
- while (find_table && find_table->role() != WebKit::WebAXRoleTable)
- find_table = find_table->parent();
+ BrowserAccessibility* find_table = GetParent();
+ while (find_table && find_table->GetRole() != ui::AX_ROLE_TABLE)
+ find_table = find_table->GetParent();
if (!find_table) {
NOTREACHED();
return S_FALSE;
//
STDMETHODIMP BrowserAccessibilityWin::get_nCharacters(LONG* n_characters) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!n_characters)
}
STDMETHODIMP BrowserAccessibilityWin::get_caretOffset(LONG* offset) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!offset)
return E_INVALIDARG;
*offset = 0;
- if (role_ == WebKit::WebAXRoleTextField ||
- role_ == WebKit::WebAXRoleTextArea) {
+ if (GetRole() == ui::AX_ROLE_TEXT_FIELD ||
+ GetRole() == ui::AX_ROLE_TEXT_AREA) {
int sel_start = 0;
- if (GetIntAttribute(AccessibilityNodeData::ATTR_TEXT_SEL_START,
+ if (GetIntAttribute(ui::AX_ATTR_TEXT_SEL_START,
&sel_start))
*offset = sel_start;
}
return S_OK;
}
+STDMETHODIMP BrowserAccessibilityWin::get_characterExtents(
+ LONG offset,
+ enum IA2CoordinateType coordinate_type,
+ LONG* out_x,
+ LONG* out_y,
+ LONG* out_width,
+ LONG* out_height) {
+ if (!instance_active())
+ return E_FAIL;
+
+ if (!out_x || !out_y || !out_width || !out_height)
+ return E_INVALIDARG;
+
+ const base::string16& text_str = TextForIAccessibleText();
+ HandleSpecialTextOffset(text_str, &offset);
+
+ if (offset < 0 || offset > static_cast<LONG>(text_str.size()))
+ return E_INVALIDARG;
+
+ gfx::Rect character_bounds;
+ if (coordinate_type == IA2_COORDTYPE_SCREEN_RELATIVE) {
+ character_bounds = GetGlobalBoundsForRange(offset, 1);
+ } else if (coordinate_type == IA2_COORDTYPE_PARENT_RELATIVE) {
+ character_bounds = GetLocalBoundsForRange(offset, 1);
+ character_bounds -= GetLocation().OffsetFromOrigin();
+ } else {
+ return E_INVALIDARG;
+ }
+
+ *out_x = character_bounds.x();
+ *out_y = character_bounds.y();
+ *out_width = character_bounds.width();
+ *out_height = character_bounds.height();
+
+ return S_OK;
+}
+
STDMETHODIMP BrowserAccessibilityWin::get_nSelections(LONG* n_selections) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!n_selections)
return E_INVALIDARG;
*n_selections = 0;
- if (role_ == WebKit::WebAXRoleTextField ||
- role_ == WebKit::WebAXRoleTextArea) {
+ if (GetRole() == ui::AX_ROLE_TEXT_FIELD ||
+ GetRole() == ui::AX_ROLE_TEXT_AREA) {
int sel_start = 0;
int sel_end = 0;
- if (GetIntAttribute(AccessibilityNodeData::ATTR_TEXT_SEL_START,
+ if (GetIntAttribute(ui::AX_ATTR_TEXT_SEL_START,
&sel_start) &&
- GetIntAttribute(AccessibilityNodeData::ATTR_TEXT_SEL_END, &sel_end) &&
+ GetIntAttribute(ui::AX_ATTR_TEXT_SEL_END, &sel_end) &&
sel_start != sel_end)
*n_selections = 1;
}
STDMETHODIMP BrowserAccessibilityWin::get_selection(LONG selection_index,
LONG* start_offset,
LONG* end_offset) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!start_offset || !end_offset || selection_index != 0)
*start_offset = 0;
*end_offset = 0;
- if (role_ == WebKit::WebAXRoleTextField ||
- role_ == WebKit::WebAXRoleTextArea) {
+ if (GetRole() == ui::AX_ROLE_TEXT_FIELD ||
+ GetRole() == ui::AX_ROLE_TEXT_AREA) {
int sel_start = 0;
int sel_end = 0;
if (GetIntAttribute(
- AccessibilityNodeData::ATTR_TEXT_SEL_START, &sel_start) &&
- GetIntAttribute(AccessibilityNodeData::ATTR_TEXT_SEL_END, &sel_end)) {
+ ui::AX_ATTR_TEXT_SEL_START, &sel_start) &&
+ GetIntAttribute(ui::AX_ATTR_TEXT_SEL_END, &sel_end)) {
*start_offset = sel_start;
*end_offset = sel_end;
}
STDMETHODIMP BrowserAccessibilityWin::get_text(LONG start_offset,
LONG end_offset,
BSTR* text) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!text)
return E_INVALIDARG;
- const string16& text_str = TextForIAccessibleText();
+ const base::string16& text_str = TextForIAccessibleText();
// Handle special text offsets.
HandleSpecialTextOffset(text_str, &start_offset);
if (end_offset > len)
return E_INVALIDARG;
- string16 substr = text_str.substr(start_offset, end_offset - start_offset);
+ base::string16 substr = text_str.substr(start_offset,
+ end_offset - start_offset);
if (substr.empty())
return S_FALSE;
LONG* start_offset,
LONG* end_offset,
BSTR* text) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!start_offset || !end_offset || !text)
return S_FALSE;
}
- const string16& text_str = TextForIAccessibleText();
+ const base::string16& text_str = TextForIAccessibleText();
*start_offset = FindBoundary(
text_str, boundary_type, offset, ui::BACKWARDS_DIRECTION);
LONG* start_offset,
LONG* end_offset,
BSTR* text) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!start_offset || !end_offset || !text)
return S_FALSE;
}
- const string16& text_str = TextForIAccessibleText();
+ const base::string16& text_str = TextForIAccessibleText();
*start_offset = FindBoundary(
text_str, boundary_type, offset, ui::BACKWARDS_DIRECTION);
LONG* start_offset,
LONG* end_offset,
BSTR* text) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!start_offset || !end_offset || !text)
return S_FALSE;
}
- const string16& text_str = TextForIAccessibleText();
+ const base::string16& text_str = TextForIAccessibleText();
*start_offset = offset;
*end_offset = FindBoundary(
}
STDMETHODIMP BrowserAccessibilityWin::get_newText(IA2TextSegment* new_text) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!new_text)
return E_INVALIDARG;
- string16 text = TextForIAccessibleText();
+ base::string16 text = TextForIAccessibleText();
new_text->text = SysAllocString(text.c_str());
new_text->start = 0;
}
STDMETHODIMP BrowserAccessibilityWin::get_oldText(IA2TextSegment* old_text) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!old_text)
LONG y,
enum IA2CoordinateType coord_type,
LONG* offset) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!offset)
STDMETHODIMP BrowserAccessibilityWin::addSelection(LONG start_offset,
LONG end_offset) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
- const string16& text_str = TextForIAccessibleText();
+ const base::string16& text_str = TextForIAccessibleText();
HandleSpecialTextOffset(text_str, &start_offset);
HandleSpecialTextOffset(text_str, &end_offset);
- manager_->SetTextSelection(*this, start_offset, end_offset);
+ manager()->SetTextSelection(*this, start_offset, end_offset);
return S_OK;
}
STDMETHODIMP BrowserAccessibilityWin::removeSelection(LONG selection_index) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (selection_index != 0)
return E_INVALIDARG;
- manager_->SetTextSelection(*this, 0, 0);
+ manager()->SetTextSelection(*this, 0, 0);
return S_OK;
}
STDMETHODIMP BrowserAccessibilityWin::setCaretOffset(LONG offset) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
- const string16& text_str = TextForIAccessibleText();
+ const base::string16& text_str = TextForIAccessibleText();
HandleSpecialTextOffset(text_str, &offset);
- manager_->SetTextSelection(*this, offset, offset);
+ manager()->SetTextSelection(*this, offset, offset);
return S_OK;
}
STDMETHODIMP BrowserAccessibilityWin::setSelection(LONG selection_index,
LONG start_offset,
LONG end_offset) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (selection_index != 0)
return E_INVALIDARG;
- const string16& text_str = TextForIAccessibleText();
+ const base::string16& text_str = TextForIAccessibleText();
HandleSpecialTextOffset(text_str, &start_offset);
HandleSpecialTextOffset(text_str, &end_offset);
- manager_->SetTextSelection(*this, start_offset, end_offset);
+ manager()->SetTextSelection(*this, start_offset, end_offset);
return S_OK;
}
//
STDMETHODIMP BrowserAccessibilityWin::get_nHyperlinks(long* hyperlink_count) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!hyperlink_count)
STDMETHODIMP BrowserAccessibilityWin::get_hyperlink(
long index,
IAccessibleHyperlink** hyperlink) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!hyperlink ||
}
BrowserAccessibilityWin* child =
- children_[hyperlinks_[index]]->ToBrowserAccessibilityWin();
+ InternalGetChild(hyperlinks_[index])->ToBrowserAccessibilityWin();
*hyperlink = static_cast<IAccessibleHyperlink*>(child->NewReference());
return S_OK;
}
STDMETHODIMP BrowserAccessibilityWin::get_hyperlinkIndex(
long char_index,
long* hyperlink_index) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!hyperlink_index)
//
STDMETHODIMP BrowserAccessibilityWin::get_currentValue(VARIANT* value) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!value)
float float_val;
if (GetFloatAttribute(
- AccessibilityNodeData::ATTR_VALUE_FOR_RANGE, &float_val)) {
+ ui::AX_ATTR_VALUE_FOR_RANGE, &float_val)) {
value->vt = VT_R8;
value->dblVal = float_val;
return S_OK;
}
STDMETHODIMP BrowserAccessibilityWin::get_minimumValue(VARIANT* value) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!value)
return E_INVALIDARG;
float float_val;
- if (GetFloatAttribute(AccessibilityNodeData::ATTR_MIN_VALUE_FOR_RANGE,
+ if (GetFloatAttribute(ui::AX_ATTR_MIN_VALUE_FOR_RANGE,
&float_val)) {
value->vt = VT_R8;
value->dblVal = float_val;
}
STDMETHODIMP BrowserAccessibilityWin::get_maximumValue(VARIANT* value) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!value)
return E_INVALIDARG;
float float_val;
- if (GetFloatAttribute(AccessibilityNodeData::ATTR_MAX_VALUE_FOR_RANGE,
+ if (GetFloatAttribute(ui::AX_ATTR_MAX_VALUE_FOR_RANGE,
&float_val)) {
value->vt = VT_R8;
value->dblVal = float_val;
//
STDMETHODIMP BrowserAccessibilityWin::get_URL(BSTR* url) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!url)
return E_INVALIDARG;
- return GetStringAttributeAsBstr(AccessibilityNodeData::ATTR_DOC_URL, url);
+ return GetStringAttributeAsBstr(ui::AX_ATTR_DOC_URL, url);
}
STDMETHODIMP BrowserAccessibilityWin::get_title(BSTR* title) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!title)
return E_INVALIDARG;
- return GetStringAttributeAsBstr(AccessibilityNodeData::ATTR_DOC_TITLE, title);
+ return GetStringAttributeAsBstr(ui::AX_ATTR_DOC_TITLE, title);
}
STDMETHODIMP BrowserAccessibilityWin::get_mimeType(BSTR* mime_type) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!mime_type)
return E_INVALIDARG;
return GetStringAttributeAsBstr(
- AccessibilityNodeData::ATTR_DOC_MIMETYPE, mime_type);
+ ui::AX_ATTR_DOC_MIMETYPE, mime_type);
}
STDMETHODIMP BrowserAccessibilityWin::get_docType(BSTR* doc_type) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!doc_type)
return E_INVALIDARG;
return GetStringAttributeAsBstr(
- AccessibilityNodeData::ATTR_DOC_DOCTYPE, doc_type);
+ ui::AX_ATTR_DOC_DOCTYPE, doc_type);
}
//
unsigned int* num_children,
unsigned int* unique_id,
unsigned short* node_type) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!node_name || !name_space_id || !node_value || !num_children ||
return E_INVALIDARG;
}
- string16 tag;
- if (GetString16Attribute(AccessibilityNodeData::ATTR_HTML_TAG, &tag))
+ base::string16 tag;
+ if (GetString16Attribute(ui::AX_ATTR_HTML_TAG, &tag))
*node_name = SysAllocString(tag.c_str());
else
*node_name = NULL;
*name_space_id = 0;
- *node_value = SysAllocString(UTF8ToUTF16(value_).c_str());
- *num_children = children_.size();
+ *node_value = SysAllocString(base::UTF8ToUTF16(value()).c_str());
+ *num_children = PlatformChildCount();
*unique_id = unique_id_win_;
if (ia_role_ == ROLE_SYSTEM_DOCUMENT) {
short* name_space_id,
BSTR* attrib_values,
unsigned short* num_attribs) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!attrib_names || !name_space_id || !attrib_values || !num_attribs)
return E_INVALIDARG;
*num_attribs = max_attribs;
- if (*num_attribs > html_attributes_.size())
- *num_attribs = html_attributes_.size();
+ if (*num_attribs > GetHtmlAttributes().size())
+ *num_attribs = GetHtmlAttributes().size();
for (unsigned short i = 0; i < *num_attribs; ++i) {
attrib_names[i] = SysAllocString(
- UTF8ToUTF16(html_attributes_[i].first).c_str());
+ base::UTF8ToUTF16(GetHtmlAttributes()[i].first).c_str());
name_space_id[i] = 0;
attrib_values[i] = SysAllocString(
- UTF8ToUTF16(html_attributes_[i].second).c_str());
+ base::UTF8ToUTF16(GetHtmlAttributes()[i].second).c_str());
}
return S_OK;
}
BSTR* attrib_names,
short* name_space_id,
BSTR* attrib_values) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!attrib_names || !name_space_id || !attrib_values)
for (unsigned short i = 0; i < num_attribs; ++i) {
name_space_id[i] = 0;
bool found = false;
- std::string name = UTF16ToUTF8((LPCWSTR)attrib_names[i]);
- for (unsigned int j = 0; j < html_attributes_.size(); ++j) {
- if (html_attributes_[j].first == name) {
+ std::string name = base::UTF16ToUTF8((LPCWSTR)attrib_names[i]);
+ for (unsigned int j = 0; j < GetHtmlAttributes().size(); ++j) {
+ if (GetHtmlAttributes()[j].first == name) {
attrib_values[i] = SysAllocString(
- UTF8ToUTF16(html_attributes_[j].second).c_str());
+ base::UTF8ToUTF16(GetHtmlAttributes()[j].second).c_str());
found = true;
break;
}
BSTR* style_properties,
BSTR* style_values,
unsigned short *num_style_properties) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!style_properties || !style_values)
// We only cache a single style property for now: DISPLAY
- string16 display;
+ base::string16 display;
if (max_style_properties == 0 ||
- !GetString16Attribute(AccessibilityNodeData::ATTR_DISPLAY, &display)) {
+ !GetString16Attribute(ui::AX_ATTR_DISPLAY, &display)) {
*num_style_properties = 0;
return S_OK;
}
boolean use_alternate_view,
BSTR* style_properties,
BSTR* style_values) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!style_properties || !style_values)
// We only cache a single style property for now: DISPLAY
for (unsigned short i = 0; i < num_style_properties; ++i) {
- string16 name = (LPCWSTR)style_properties[i];
- StringToLowerASCII(&name);
+ base::string16 name = (LPCWSTR)style_properties[i];
+ base::StringToLowerASCII(&name);
if (name == L"display") {
- string16 display = GetString16Attribute(
- AccessibilityNodeData::ATTR_DISPLAY);
+ base::string16 display = GetString16Attribute(
+ ui::AX_ATTR_DISPLAY);
style_values[i] = SysAllocString(display.c_str());
} else {
style_values[i] = NULL;
}
STDMETHODIMP BrowserAccessibilityWin::get_parentNode(ISimpleDOMNode** node) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!node)
return E_INVALIDARG;
- *node = parent_->ToBrowserAccessibilityWin()->NewReference();
+ *node = GetParent()->ToBrowserAccessibilityWin()->NewReference();
return S_OK;
}
STDMETHODIMP BrowserAccessibilityWin::get_firstChild(ISimpleDOMNode** node) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!node)
return E_INVALIDARG;
- if (children_.empty()) {
+ if (PlatformChildCount() == 0) {
*node = NULL;
return S_FALSE;
}
- *node = children_[0]->ToBrowserAccessibilityWin()->NewReference();
+ *node = PlatformGetChild(0)->ToBrowserAccessibilityWin()->NewReference();
return S_OK;
}
STDMETHODIMP BrowserAccessibilityWin::get_lastChild(ISimpleDOMNode** node) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!node)
return E_INVALIDARG;
- if (children_.empty()) {
+ if (PlatformChildCount() == 0) {
*node = NULL;
return S_FALSE;
}
- *node = (*children_.rbegin())->ToBrowserAccessibilityWin()->NewReference();
+ *node = PlatformGetChild(PlatformChildCount() - 1)
+ ->ToBrowserAccessibilityWin()->NewReference();
return S_OK;
}
STDMETHODIMP BrowserAccessibilityWin::get_previousSibling(
ISimpleDOMNode** node) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!node)
return E_INVALIDARG;
- if (!parent_ || index_in_parent_ <= 0) {
+ if (!GetParent() || GetIndexInParent() <= 0) {
*node = NULL;
return S_FALSE;
}
- *node = parent_->children()[index_in_parent_ - 1]->
+ *node = GetParent()->InternalGetChild(GetIndexInParent() - 1)->
ToBrowserAccessibilityWin()->NewReference();
return S_OK;
}
STDMETHODIMP BrowserAccessibilityWin::get_nextSibling(ISimpleDOMNode** node) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!node)
return E_INVALIDARG;
- if (!parent_ ||
- index_in_parent_ < 0 ||
- index_in_parent_ >= static_cast<int>(parent_->children().size()) - 1) {
+ if (!GetParent() ||
+ GetIndexInParent() < 0 ||
+ GetIndexInParent() >= static_cast<int>(
+ GetParent()->InternalChildCount()) - 1) {
*node = NULL;
return S_FALSE;
}
- *node = parent_->children()[index_in_parent_ + 1]->
+ *node = GetParent()->InternalGetChild(GetIndexInParent() + 1)->
ToBrowserAccessibilityWin()->NewReference();
return S_OK;
}
STDMETHODIMP BrowserAccessibilityWin::get_childAt(
unsigned int child_index,
ISimpleDOMNode** node) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!node)
return E_INVALIDARG;
+ if (child_index >= PlatformChildCount())
+ return E_INVALIDARG;
+
BrowserAccessibility* child = PlatformGetChild(child_index);
if (!child) {
*node = NULL;
//
STDMETHODIMP BrowserAccessibilityWin::get_domText(BSTR* dom_text) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
if (!dom_text)
return E_INVALIDARG;
return GetStringAttributeAsBstr(
- AccessibilityNodeData::ATTR_NAME, dom_text);
+ ui::AX_ATTR_NAME, dom_text);
+}
+
+STDMETHODIMP BrowserAccessibilityWin::get_clippedSubstringBounds(
+ unsigned int start_index,
+ unsigned int end_index,
+ int* out_x,
+ int* out_y,
+ int* out_width,
+ int* out_height) {
+ // TODO(dmazzoni): fully support this API by intersecting the
+ // rect with the container's rect.
+ return get_unclippedSubstringBounds(
+ start_index, end_index, out_x, out_y, out_width, out_height);
+}
+
+STDMETHODIMP BrowserAccessibilityWin::get_unclippedSubstringBounds(
+ unsigned int start_index,
+ unsigned int end_index,
+ int* out_x,
+ int* out_y,
+ int* out_width,
+ int* out_height) {
+ if (!instance_active())
+ return E_FAIL;
+
+ if (!out_x || !out_y || !out_width || !out_height)
+ return E_INVALIDARG;
+
+ const base::string16& text_str = TextForIAccessibleText();
+ if (start_index > text_str.size() ||
+ end_index > text_str.size() ||
+ start_index > end_index) {
+ return E_INVALIDARG;
+ }
+
+ gfx::Rect bounds = GetGlobalBoundsForRange(
+ start_index, end_index - start_index);
+ *out_x = bounds.x();
+ *out_y = bounds.y();
+ *out_width = bounds.width();
+ *out_height = bounds.height();
+ return S_OK;
+}
+
+STDMETHODIMP BrowserAccessibilityWin::scrollToSubstring(
+ unsigned int start_index,
+ unsigned int end_index) {
+ if (!instance_active())
+ return E_FAIL;
+
+ const base::string16& text_str = TextForIAccessibleText();
+ if (start_index > text_str.size() ||
+ end_index > text_str.size() ||
+ start_index > end_index) {
+ return E_INVALIDARG;
+ }
+
+ manager()->ScrollToMakeVisible(*this, GetLocalBoundsForRange(
+ start_index, end_index - start_index));
+ manager()->ToBrowserAccessibilityManagerWin()->TrackScrollingObject(this);
+
+ return S_OK;
}
//
STDMETHODIMP BrowserAccessibilityWin::QueryService(REFGUID guidService,
REFIID riid,
void** object) {
- if (!instance_active_)
+ if (!instance_active())
return E_FAIL;
// The system uses IAccessible APIs for many purposes, but only
// Special Mozilla extension: return the accessible for the root document.
// Screen readers use this to distinguish between a document loaded event
// on the root document vs on an iframe.
- return manager_->GetRoot()->ToBrowserAccessibilityWin()->QueryInterface(
+ return manager()->GetRoot()->ToBrowserAccessibilityWin()->QueryInterface(
IID_IAccessible2, object);
}
<< id;
if (id == UIA_ValuePatternId || id == UIA_TextPatternId) {
if (IsEditableText()) {
- // The BrowserAccessibilityManager keeps track of instances when
- // we don't want to show the on-screen keyboard.
- if (!manager_->IsOSKAllowed(GetGlobalBoundsRect()))
- return E_NOTIMPL;
-
DVLOG(1) << "Returning UIA text provider";
- base::win::UIATextProvider::CreateTextProvider(true, provider);
+ base::win::UIATextProvider::CreateTextProvider(
+ GetValueText(), true, provider);
return S_OK;
}
}
// CComObjectRootEx methods.
//
+// static
HRESULT WINAPI BrowserAccessibilityWin::InternalQueryInterface(
void* this_ptr,
const _ATL_INTMAP_ENTRY* entries,
REFIID iid,
void** object) {
+ int32 ia_role =
+ reinterpret_cast<BrowserAccessibilityWin*>(this_ptr)->ia_role_;
if (iid == IID_IAccessibleImage) {
- if (ia_role_ != ROLE_SYSTEM_GRAPHIC) {
+ if (ia_role != ROLE_SYSTEM_GRAPHIC) {
*object = NULL;
return E_NOINTERFACE;
}
} else if (iid == IID_IAccessibleTable || iid == IID_IAccessibleTable2) {
- if (ia_role_ != ROLE_SYSTEM_TABLE) {
+ if (ia_role != ROLE_SYSTEM_TABLE) {
*object = NULL;
return E_NOINTERFACE;
}
} else if (iid == IID_IAccessibleTableCell) {
- if (ia_role_ != ROLE_SYSTEM_CELL) {
+ if (ia_role != ROLE_SYSTEM_CELL) {
*object = NULL;
return E_NOINTERFACE;
}
} else if (iid == IID_IAccessibleValue) {
- if (ia_role_ != ROLE_SYSTEM_PROGRESSBAR &&
- ia_role_ != ROLE_SYSTEM_SCROLLBAR &&
- ia_role_ != ROLE_SYSTEM_SLIDER) {
+ if (ia_role != ROLE_SYSTEM_PROGRESSBAR &&
+ ia_role != ROLE_SYSTEM_SCROLLBAR &&
+ ia_role != ROLE_SYSTEM_SLIDER) {
*object = NULL;
return E_NOINTERFACE;
}
} else if (iid == IID_ISimpleDOMDocument) {
- if (ia_role_ != ROLE_SYSTEM_DOCUMENT) {
+ if (ia_role != ROLE_SYSTEM_DOCUMENT) {
*object = NULL;
return E_NOINTERFACE;
}
// Private methods.
//
-// Initialize this object and mark it as active.
-void BrowserAccessibilityWin::PreInitialize() {
- BrowserAccessibility::PreInitialize();
+// Called every time this node's data changes.
+void BrowserAccessibilityWin::OnDataChanged() {
+ BrowserAccessibility::OnDataChanged();
InitRoleAndState();
// Expose the "display" and "tag" attributes.
- StringAttributeToIA2(AccessibilityNodeData::ATTR_DISPLAY, "display");
- StringAttributeToIA2(AccessibilityNodeData::ATTR_HTML_TAG, "tag");
- StringAttributeToIA2(AccessibilityNodeData::ATTR_ROLE, "xml-roles");
+ StringAttributeToIA2(ui::AX_ATTR_DISPLAY, "display");
+ StringAttributeToIA2(ui::AX_ATTR_TEXT_INPUT_TYPE, "text-input-type");
+ StringAttributeToIA2(ui::AX_ATTR_HTML_TAG, "tag");
+ StringAttributeToIA2(ui::AX_ATTR_ROLE, "xml-roles");
// Expose "level" attribute for headings, trees, etc.
- IntAttributeToIA2(AccessibilityNodeData::ATTR_HIERARCHICAL_LEVEL, "level");
+ IntAttributeToIA2(ui::AX_ATTR_HIERARCHICAL_LEVEL, "level");
// Expose the set size and position in set for listbox options.
- if (role_ == WebKit::WebAXRoleListBoxOption &&
- parent_ &&
- parent_->role() == WebKit::WebAXRoleListBox) {
+ if (GetRole() == ui::AX_ROLE_LIST_BOX_OPTION &&
+ GetParent() &&
+ GetParent()->GetRole() == ui::AX_ROLE_LIST_BOX) {
ia2_attributes_.push_back(
- L"setsize:" + base::IntToString16(parent_->PlatformChildCount()));
+ L"setsize:" + base::IntToString16(GetParent()->PlatformChildCount()));
ia2_attributes_.push_back(
- L"setsize:" + base::IntToString16(index_in_parent_ + 1));
+ L"setsize:" + base::IntToString16(GetIndexInParent() + 1));
}
if (ia_role_ == ROLE_SYSTEM_CHECKBUTTON ||
ia_role_ == ROLE_SYSTEM_RADIOBUTTON ||
+ ia2_role_ == IA2_ROLE_CHECK_MENU_ITEM ||
+ ia2_role_ == IA2_ROLE_RADIO_MENU_ITEM ||
ia2_role_ == IA2_ROLE_TOGGLE_BUTTON) {
ia2_attributes_.push_back(L"checkable:true");
}
// Expose live region attributes.
- StringAttributeToIA2(AccessibilityNodeData::ATTR_LIVE_STATUS, "live");
- StringAttributeToIA2(AccessibilityNodeData::ATTR_LIVE_RELEVANT, "relevant");
- BoolAttributeToIA2(AccessibilityNodeData::ATTR_LIVE_ATOMIC, "atomic");
- BoolAttributeToIA2(AccessibilityNodeData::ATTR_LIVE_BUSY, "busy");
+ StringAttributeToIA2(ui::AX_ATTR_LIVE_STATUS, "live");
+ StringAttributeToIA2(ui::AX_ATTR_LIVE_RELEVANT, "relevant");
+ BoolAttributeToIA2(ui::AX_ATTR_LIVE_ATOMIC, "atomic");
+ BoolAttributeToIA2(ui::AX_ATTR_LIVE_BUSY, "busy");
// Expose container live region attributes.
- StringAttributeToIA2(AccessibilityNodeData::ATTR_CONTAINER_LIVE_STATUS,
+ StringAttributeToIA2(ui::AX_ATTR_CONTAINER_LIVE_STATUS,
"container-live");
- StringAttributeToIA2(AccessibilityNodeData::ATTR_CONTAINER_LIVE_RELEVANT,
+ StringAttributeToIA2(ui::AX_ATTR_CONTAINER_LIVE_RELEVANT,
"container-relevant");
- BoolAttributeToIA2(AccessibilityNodeData::ATTR_CONTAINER_LIVE_ATOMIC,
+ BoolAttributeToIA2(ui::AX_ATTR_CONTAINER_LIVE_ATOMIC,
"container-atomic");
- BoolAttributeToIA2(AccessibilityNodeData::ATTR_CONTAINER_LIVE_BUSY,
+ BoolAttributeToIA2(ui::AX_ATTR_CONTAINER_LIVE_BUSY,
"container-busy");
// Expose slider value.
// Expose table cell index.
if (ia_role_ == ROLE_SYSTEM_CELL) {
- BrowserAccessibility* table = parent();
- while (table && table->role() != WebKit::WebAXRoleTable)
- table = table->parent();
+ BrowserAccessibility* table = GetParent();
+ while (table && table->GetRole() != ui::AX_ROLE_TABLE)
+ table = table->GetParent();
if (table) {
const std::vector<int32>& unique_cell_ids = table->GetIntListAttribute(
- AccessibilityNodeData::ATTR_UNIQUE_CELL_IDS);
+ ui::AX_ATTR_UNIQUE_CELL_IDS);
for (size_t i = 0; i < unique_cell_ids.size(); ++i) {
- if (unique_cell_ids[i] == renderer_id_) {
+ if (unique_cell_ids[i] == GetId()) {
ia2_attributes_.push_back(
- string16(L"table-cell-index:") + base::IntToString16(i));
+ base::string16(L"table-cell-index:") + base::IntToString16(i));
}
}
}
// if any, in "description".
int title_elem_id = GetIntAttribute(
- AccessibilityNodeData::ATTR_TITLE_UI_ELEMENT);
- std::string help = GetStringAttribute(AccessibilityNodeData::ATTR_HELP);
+ ui::AX_ATTR_TITLE_UI_ELEMENT);
+ std::string help = GetStringAttribute(ui::AX_ATTR_HELP);
std::string description = GetStringAttribute(
- AccessibilityNodeData::ATTR_DESCRIPTION);
+ ui::AX_ATTR_DESCRIPTION);
// WebKit annoyingly puts the title in the description if there's no other
// description, which just confuses the rest of the logic. Put it back.
// it's nonempty, and the help should become the description if
// there's no description - or the name if there's no name or description.
if (!description.empty()) {
- name_ = description;
+ set_name(description);
description.clear();
}
if (!help.empty() && description.empty()) {
description = help;
help.clear();
}
- if (!description.empty() && name_.empty() && !title_elem_id) {
- name_ = description;
+ if (!description.empty() && name().empty() && !title_elem_id) {
+ set_name(description);
description.clear();
}
// If it's a text field, also consider the placeholder.
std::string placeholder;
- if (role_ == WebKit::WebAXRoleTextField &&
- HasState(WebKit::WebAXStateFocusable) &&
+ if (GetRole() == ui::AX_ROLE_TEXT_FIELD &&
+ HasState(ui::AX_STATE_FOCUSABLE) &&
GetHtmlAttribute("placeholder", &placeholder)) {
- if (name_.empty() && !title_elem_id) {
- name_ = placeholder;
+ if (name().empty() && !title_elem_id) {
+ set_name(placeholder);
} else if (description.empty()) {
description = placeholder;
}
}
- SetStringAttribute(AccessibilityNodeData::ATTR_DESCRIPTION, description);
- SetStringAttribute(AccessibilityNodeData::ATTR_HELP, help);
+ SetStringAttribute(ui::AX_ATTR_DESCRIPTION, description);
+ SetStringAttribute(ui::AX_ATTR_HELP, help);
// On Windows, the value of a document should be its url.
- if (role_ == WebKit::WebAXRoleRootWebArea ||
- role_ == WebKit::WebAXRoleWebArea) {
- GetStringAttribute(AccessibilityNodeData::ATTR_DOC_URL, &value_);
+ if (GetRole() == ui::AX_ROLE_ROOT_WEB_AREA ||
+ GetRole() == ui::AX_ROLE_WEB_AREA) {
+ set_value(GetStringAttribute(ui::AX_ATTR_DOC_URL));
}
// For certain roles (listbox option, static text, and list marker)
// WebKit stores the main accessible text in the "value" - swap it so
// that it's the "name".
- if (name_.empty() &&
- (role_ == WebKit::WebAXRoleListBoxOption ||
- role_ == WebKit::WebAXRoleStaticText ||
- role_ == WebKit::WebAXRoleListMarker)) {
- name_.swap(value_);
+ if (name().empty() &&
+ (GetRole() == ui::AX_ROLE_LIST_BOX_OPTION ||
+ GetRole() == ui::AX_ROLE_STATIC_TEXT ||
+ GetRole() == ui::AX_ROLE_LIST_MARKER)) {
+ std::string tmp = value();
+ set_value(name());
+ set_name(tmp);
}
// If this doesn't have a value and is linked then set its value to the url
// attribute. This allows screen readers to read an empty link's destination.
- if (value_.empty() && (ia_state_ & STATE_SYSTEM_LINKED))
- GetStringAttribute(AccessibilityNodeData::ATTR_URL, &value_);
+ if (value().empty() && (ia_state_ & STATE_SYSTEM_LINKED))
+ set_value(GetStringAttribute(ui::AX_ATTR_URL));
// Clear any old relationships between this node and other nodes.
for (size_t i = 0; i < relations_.size(); ++i)
}
}
-void BrowserAccessibilityWin::PostInitialize() {
- BrowserAccessibility::PostInitialize();
-
+void BrowserAccessibilityWin::OnUpdateFinished() {
// Construct the hypertext for this node.
hyperlink_offset_to_index_.clear();
hyperlinks_.clear();
hypertext_.clear();
for (unsigned int i = 0; i < PlatformChildCount(); ++i) {
BrowserAccessibility* child = PlatformGetChild(i);
- if (child->role() == WebKit::WebAXRoleStaticText) {
- hypertext_ += UTF8ToUTF16(child->name());
+ if (child->GetRole() == ui::AX_ROLE_STATIC_TEXT) {
+ hypertext_ += base::UTF8ToUTF16(child->name());
} else {
hyperlink_offset_to_index_[hypertext_.size()] = hyperlinks_.size();
hypertext_ += kEmbeddedCharacter;
DCHECK_EQ(hyperlink_offset_to_index_.size(), hyperlinks_.size());
// Fire an event when an alert first appears.
- if (role_ == WebKit::WebAXRoleAlert && first_time_)
- manager_->NotifyAccessibilityEvent(WebKit::WebAXEventAlert, this);
+ if (GetRole() == ui::AX_ROLE_ALERT && first_time_)
+ manager()->NotifyAccessibilityEvent(ui::AX_EVENT_ALERT, this);
// Fire events if text has changed.
- string16 text = TextForIAccessibleText();
+ base::string16 text = TextForIAccessibleText();
if (previous_text_ != text) {
if (!previous_text_.empty() && !text.empty()) {
- manager_->NotifyAccessibilityEvent(
- WebKit::WebAXEventShow, this);
+ manager()->NotifyAccessibilityEvent(
+ ui::AX_EVENT_SHOW, this);
}
// TODO(dmazzoni): Look into HIDE events, too.
previous_text_ = text;
}
+ BrowserAccessibilityManagerWin* manager =
+ this->manager()->ToBrowserAccessibilityManagerWin();
+
// Fire events if the state has changed.
if (!first_time_ && ia_state_ != old_ia_state_) {
- BrowserAccessibilityManagerWin* manager =
- manager_->ToBrowserAccessibilityManagerWin();
-
// Normally focus events are handled elsewhere, however
// focus for managed descendants is platform-specific.
// Fire a focus event if the focused descendant in a multi-select
// list box changes.
- if (role_ == WebKit::WebAXRoleListBoxOption &&
+ if (GetRole() == ui::AX_ROLE_LIST_BOX_OPTION &&
(ia_state_ & STATE_SYSTEM_FOCUSABLE) &&
(ia_state_ & STATE_SYSTEM_SELECTABLE) &&
(ia_state_ & STATE_SYSTEM_FOCUSED) &&
old_ia_state_ = ia_state_;
}
+ // Fire an event if this container object has scrolled.
+ int sx = 0;
+ int sy = 0;
+ if (GetIntAttribute(ui::AX_ATTR_SCROLL_X, &sx) &&
+ GetIntAttribute(ui::AX_ATTR_SCROLL_Y, &sy)) {
+ if (!first_time_ &&
+ (sx != previous_scroll_x_ || sy != previous_scroll_y_)) {
+ manager->MaybeCallNotifyWinEvent(EVENT_SYSTEM_SCROLLINGEND,
+ unique_id_win());
+ }
+ previous_scroll_x_ = sx;
+ previous_scroll_y_ = sy;
+ }
+
first_time_ = false;
}
return true;
}
-void BrowserAccessibilityWin::SetLocation(const gfx::Rect& new_location) {
- BrowserAccessibility::SetLocation(new_location);
- manager_->ToBrowserAccessibilityManagerWin()->MaybeCallNotifyWinEvent(
+void BrowserAccessibilityWin::OnLocationChanged() {
+ manager()->ToBrowserAccessibilityManagerWin()->MaybeCallNotifyWinEvent(
EVENT_OBJECT_LOCATIONCHANGE, unique_id_win());
}
if (child_id >= 1 && child_id <= static_cast<LONG>(PlatformChildCount()))
return PlatformGetChild(child_id - 1)->ToBrowserAccessibilityWin();
- return manager_->ToBrowserAccessibilityManagerWin()->
+ return manager()->ToBrowserAccessibilityManagerWin()->
GetFromUniqueIdWin(child_id);
}
HRESULT BrowserAccessibilityWin::GetStringAttributeAsBstr(
- AccessibilityNodeData::StringAttribute attribute,
+ ui::AXStringAttribute attribute,
BSTR* value_bstr) {
- string16 str;
+ base::string16 str;
if (!GetString16Attribute(attribute, &str))
return S_FALSE;
}
void BrowserAccessibilityWin::StringAttributeToIA2(
- AccessibilityNodeData::StringAttribute attribute,
+ ui::AXStringAttribute attribute,
const char* ia2_attr) {
- string16 value;
+ base::string16 value;
if (GetString16Attribute(attribute, &value))
- ia2_attributes_.push_back(ASCIIToUTF16(ia2_attr) + L":" + value);
+ ia2_attributes_.push_back(base::ASCIIToUTF16(ia2_attr) + L":" + value);
}
void BrowserAccessibilityWin::BoolAttributeToIA2(
- AccessibilityNodeData::BoolAttribute attribute,
+ ui::AXBoolAttribute attribute,
const char* ia2_attr) {
bool value;
if (GetBoolAttribute(attribute, &value)) {
- ia2_attributes_.push_back((ASCIIToUTF16(ia2_attr) + L":") +
+ ia2_attributes_.push_back((base::ASCIIToUTF16(ia2_attr) + L":") +
(value ? L"true" : L"false"));
}
}
void BrowserAccessibilityWin::IntAttributeToIA2(
- AccessibilityNodeData::IntAttribute attribute,
+ ui::AXIntAttribute attribute,
const char* ia2_attr) {
int value;
if (GetIntAttribute(attribute, &value)) {
- ia2_attributes_.push_back(ASCIIToUTF16(ia2_attr) + L":" +
+ ia2_attributes_.push_back(base::ASCIIToUTF16(ia2_attr) + L":" +
base::IntToString16(value));
}
}
-string16 BrowserAccessibilityWin::GetValueText() {
+base::string16 BrowserAccessibilityWin::GetValueText() {
float fval;
- string16 value = UTF8ToUTF16(value_);
+ base::string16 value = base::UTF8ToUTF16(this->value());
+
if (value.empty() &&
- GetFloatAttribute(AccessibilityNodeData::ATTR_VALUE_FOR_RANGE, &fval)) {
- value = UTF8ToUTF16(base::DoubleToString(fval));
+ GetFloatAttribute(ui::AX_ATTR_VALUE_FOR_RANGE, &fval)) {
+ value = base::UTF8ToUTF16(base::DoubleToString(fval));
}
return value;
}
-string16 BrowserAccessibilityWin::TextForIAccessibleText() {
+base::string16 BrowserAccessibilityWin::TextForIAccessibleText() {
if (IsEditableText())
- return UTF8ToUTF16(value_);
- return (role_ == WebKit::WebAXRoleStaticText) ?
- UTF8ToUTF16(name_) : hypertext_;
+ return base::UTF8ToUTF16(value());
+ return (GetRole() == ui::AX_ROLE_STATIC_TEXT) ?
+ base::UTF8ToUTF16(name()) : hypertext_;
}
-void BrowserAccessibilityWin::HandleSpecialTextOffset(const string16& text,
- LONG* offset) {
+void BrowserAccessibilityWin::HandleSpecialTextOffset(
+ const base::string16& text,
+ LONG* offset) {
if (*offset == IA2_TEXT_OFFSET_LENGTH)
*offset = static_cast<LONG>(text.size());
else if (*offset == IA2_TEXT_OFFSET_CARET)
}
LONG BrowserAccessibilityWin::FindBoundary(
- const string16& text,
+ const base::string16& text,
IA2TextBoundaryType ia2_boundary,
LONG start_offset,
ui::TextBoundaryDirection direction) {
HandleSpecialTextOffset(text, &start_offset);
ui::TextBoundaryType boundary = IA2TextBoundaryToTextBoundary(ia2_boundary);
const std::vector<int32>& line_breaks = GetIntListAttribute(
- AccessibilityNodeData::ATTR_LINE_BREAKS);
+ ui::AX_ATTR_LINE_BREAKS);
return ui::FindAccessibleTextBoundary(
text, line_breaks, boundary, start_offset, direction);
}
-BrowserAccessibilityWin* BrowserAccessibilityWin::GetFromRendererID(
- int32 renderer_id) {
- return manager_->GetFromRendererID(renderer_id)->ToBrowserAccessibilityWin();
+BrowserAccessibilityWin* BrowserAccessibilityWin::GetFromID(int32 id) {
+ return manager()->GetFromID(id)->ToBrowserAccessibilityWin();
}
void BrowserAccessibilityWin::InitRoleAndState() {
ia2_state_ = IA2_STATE_OPAQUE;
ia2_attributes_.clear();
- if (HasState(WebKit::WebAXStateBusy))
+ if (HasState(ui::AX_STATE_BUSY))
ia_state_ |= STATE_SYSTEM_BUSY;
- if (HasState(WebKit::WebAXStateChecked))
+ if (HasState(ui::AX_STATE_CHECKED))
ia_state_ |= STATE_SYSTEM_CHECKED;
- if (HasState(WebKit::WebAXStateCollapsed))
+ if (HasState(ui::AX_STATE_COLLAPSED))
ia_state_ |= STATE_SYSTEM_COLLAPSED;
- if (HasState(WebKit::WebAXStateExpanded))
+ if (HasState(ui::AX_STATE_EXPANDED))
ia_state_ |= STATE_SYSTEM_EXPANDED;
- if (HasState(WebKit::WebAXStateFocusable))
+ if (HasState(ui::AX_STATE_FOCUSABLE))
ia_state_ |= STATE_SYSTEM_FOCUSABLE;
- if (HasState(WebKit::WebAXStateHaspopup))
+ if (HasState(ui::AX_STATE_HASPOPUP))
ia_state_ |= STATE_SYSTEM_HASPOPUP;
- if (HasState(WebKit::WebAXStateHovered))
+ if (HasState(ui::AX_STATE_HOVERED))
ia_state_ |= STATE_SYSTEM_HOTTRACKED;
- if (HasState(WebKit::WebAXStateIndeterminate))
+ if (HasState(ui::AX_STATE_INDETERMINATE))
ia_state_ |= STATE_SYSTEM_INDETERMINATE;
- if (HasState(WebKit::WebAXStateInvisible))
+ if (HasState(ui::AX_STATE_INVISIBLE))
ia_state_ |= STATE_SYSTEM_INVISIBLE;
- if (HasState(WebKit::WebAXStateLinked))
+ if (HasState(ui::AX_STATE_LINKED))
ia_state_ |= STATE_SYSTEM_LINKED;
- if (HasState(WebKit::WebAXStateMultiselectable)) {
+ if (HasState(ui::AX_STATE_MULTISELECTABLE)) {
ia_state_ |= STATE_SYSTEM_EXTSELECTABLE;
ia_state_ |= STATE_SYSTEM_MULTISELECTABLE;
}
// TODO(ctguil): Support STATE_SYSTEM_EXTSELECTABLE/accSelect.
- if (HasState(WebKit::WebAXStateOffscreen))
+ if (HasState(ui::AX_STATE_OFFSCREEN))
ia_state_ |= STATE_SYSTEM_OFFSCREEN;
- if (HasState(WebKit::WebAXStatePressed))
+ if (HasState(ui::AX_STATE_PRESSED))
ia_state_ |= STATE_SYSTEM_PRESSED;
- if (HasState(WebKit::WebAXStateProtected))
+ if (HasState(ui::AX_STATE_PROTECTED))
ia_state_ |= STATE_SYSTEM_PROTECTED;
- if (HasState(WebKit::WebAXStateRequired))
+ if (HasState(ui::AX_STATE_REQUIRED))
ia2_state_ |= IA2_STATE_REQUIRED;
- if (HasState(WebKit::WebAXStateSelectable))
+ if (HasState(ui::AX_STATE_SELECTABLE))
ia_state_ |= STATE_SYSTEM_SELECTABLE;
- if (HasState(WebKit::WebAXStateSelected))
+ if (HasState(ui::AX_STATE_SELECTED))
ia_state_ |= STATE_SYSTEM_SELECTED;
- if (HasState(WebKit::WebAXStateVisited))
+ if (HasState(ui::AX_STATE_VISITED))
ia_state_ |= STATE_SYSTEM_TRAVERSED;
- if (!HasState(WebKit::WebAXStateEnabled))
+ if (!HasState(ui::AX_STATE_ENABLED))
ia_state_ |= STATE_SYSTEM_UNAVAILABLE;
- if (HasState(WebKit::WebAXStateVertical)) {
+ if (HasState(ui::AX_STATE_VERTICAL)) {
ia2_state_ |= IA2_STATE_VERTICAL;
} else {
ia2_state_ |= IA2_STATE_HORIZONTAL;
}
- if (HasState(WebKit::WebAXStateVisited))
+ if (HasState(ui::AX_STATE_VISITED))
ia_state_ |= STATE_SYSTEM_TRAVERSED;
// WebKit marks everything as readonly unless it's editable text, so if it's
// not readonly, mark it as editable now. The final computation of the
// READONLY state for MSAA is below, after the switch.
- if (!HasState(WebKit::WebAXStateReadonly))
+ if (!HasState(ui::AX_STATE_READ_ONLY))
ia2_state_ |= IA2_STATE_EDITABLE;
- string16 invalid;
+ base::string16 invalid;
if (GetHtmlAttribute("aria-invalid", &invalid))
ia2_state_ |= IA2_STATE_INVALID_ENTRY;
- if (GetBoolAttribute(AccessibilityNodeData::ATTR_BUTTON_MIXED))
+ if (GetBoolAttribute(ui::AX_ATTR_BUTTON_MIXED))
ia_state_ |= STATE_SYSTEM_MIXED;
- if (GetBoolAttribute(AccessibilityNodeData::ATTR_CAN_SET_VALUE))
+ if (GetBoolAttribute(ui::AX_ATTR_CAN_SET_VALUE))
ia2_state_ |= IA2_STATE_EDITABLE;
- string16 html_tag = GetString16Attribute(
- AccessibilityNodeData::ATTR_HTML_TAG);
+ base::string16 html_tag = GetString16Attribute(
+ ui::AX_ATTR_HTML_TAG);
ia_role_ = 0;
ia2_role_ = 0;
- switch (role_) {
- case WebKit::WebAXRoleAlert:
+ switch (GetRole()) {
+ case ui::AX_ROLE_ALERT:
ia_role_ = ROLE_SYSTEM_ALERT;
break;
- case WebKit::WebAXRoleAlertDialog:
+ case ui::AX_ROLE_ALERT_DIALOG:
ia_role_ = ROLE_SYSTEM_DIALOG;
break;
- case WebKit::WebAXRoleApplication:
+ case ui::AX_ROLE_APPLICATION:
ia_role_ = ROLE_SYSTEM_APPLICATION;
break;
- case WebKit::WebAXRoleArticle:
+ case ui::AX_ROLE_ARTICLE:
+ ia_role_ = ROLE_SYSTEM_DOCUMENT;
+ ia_state_ |= STATE_SYSTEM_READONLY;
+ break;
+ case ui::AX_ROLE_BANNER:
ia_role_ = ROLE_SYSTEM_GROUPING;
+ ia2_role_ = IA2_ROLE_HEADER;
+ break;
+ case ui::AX_ROLE_BLOCKQUOTE:
+ role_name_ = html_tag;
ia2_role_ = IA2_ROLE_SECTION;
- ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleBusyIndicator:
+ case ui::AX_ROLE_BUSY_INDICATOR:
ia_role_ = ROLE_SYSTEM_ANIMATION;
ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleButton:
+ case ui::AX_ROLE_BUTTON:
ia_role_ = ROLE_SYSTEM_PUSHBUTTON;
bool is_aria_pressed_defined;
bool is_mixed;
if (is_mixed)
ia_state_ |= STATE_SYSTEM_MIXED;
break;
- case WebKit::WebAXRoleCanvas:
- if (GetBoolAttribute(AccessibilityNodeData::ATTR_CANVAS_HAS_FALLBACK)) {
+ case ui::AX_ROLE_CANVAS:
+ if (GetBoolAttribute(ui::AX_ATTR_CANVAS_HAS_FALLBACK)) {
role_name_ = L"canvas";
ia2_role_ = IA2_ROLE_CANVAS;
} else {
ia_role_ = ROLE_SYSTEM_GRAPHIC;
}
break;
- case WebKit::WebAXRoleCell:
+ case ui::AX_ROLE_CELL:
ia_role_ = ROLE_SYSTEM_CELL;
break;
- case WebKit::WebAXRoleCheckBox:
+ case ui::AX_ROLE_CHECK_BOX:
ia_role_ = ROLE_SYSTEM_CHECKBUTTON;
+ ia2_state_ |= IA2_STATE_CHECKABLE;
break;
- case WebKit::WebAXRoleColorWell:
+ case ui::AX_ROLE_COLOR_WELL:
ia_role_ = ROLE_SYSTEM_CLIENT;
ia2_role_ = IA2_ROLE_COLOR_CHOOSER;
break;
- case WebKit::WebAXRoleColumn:
+ case ui::AX_ROLE_COLUMN:
ia_role_ = ROLE_SYSTEM_COLUMN;
- ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleColumnHeader:
+ case ui::AX_ROLE_COLUMN_HEADER:
ia_role_ = ROLE_SYSTEM_COLUMNHEADER;
- ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleComboBox:
+ case ui::AX_ROLE_COMBO_BOX:
ia_role_ = ROLE_SYSTEM_COMBOBOX;
break;
- case WebKit::WebAXRoleDiv:
+ case ui::AX_ROLE_COMPLEMENTARY:
+ ia_role_ = ROLE_SYSTEM_GROUPING;
+ ia2_role_ = IA2_ROLE_NOTE;
+ break;
+ case ui::AX_ROLE_CONTENT_INFO:
+ ia_role_ = ROLE_SYSTEM_TEXT;
+ ia2_role_ = IA2_ROLE_PARAGRAPH;
+ break;
+ case ui::AX_ROLE_DATE:
+ ia_role_ = ROLE_SYSTEM_DROPLIST;
+ ia2_role_ = IA2_ROLE_DATE_EDITOR;
+ break;
+ case ui::AX_ROLE_DATE_TIME:
+ ia_role_ = ROLE_SYSTEM_DROPLIST;
+ ia2_role_ = IA2_ROLE_DATE_EDITOR;
+ break;
+ case ui::AX_ROLE_DIV:
role_name_ = L"div";
+ ia_role_ = ROLE_SYSTEM_GROUPING;
ia2_role_ = IA2_ROLE_SECTION;
break;
- case WebKit::WebAXRoleDefinition:
+ case ui::AX_ROLE_DEFINITION:
role_name_ = html_tag;
ia2_role_ = IA2_ROLE_PARAGRAPH;
ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleDescriptionListDetail:
+ case ui::AX_ROLE_DESCRIPTION_LIST_DETAIL:
role_name_ = html_tag;
ia2_role_ = IA2_ROLE_PARAGRAPH;
ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleDescriptionListTerm:
+ case ui::AX_ROLE_DESCRIPTION_LIST:
+ role_name_ = html_tag;
+ ia_role_ = ROLE_SYSTEM_LIST;
+ ia_state_ |= STATE_SYSTEM_READONLY;
+ break;
+ case ui::AX_ROLE_DESCRIPTION_LIST_TERM:
ia_role_ = ROLE_SYSTEM_LISTITEM;
ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleDialog:
+ case ui::AX_ROLE_DETAILS:
+ role_name_ = html_tag;
+ ia_role_ = ROLE_SYSTEM_GROUPING;
+ break;
+ case ui::AX_ROLE_DIALOG:
ia_role_ = ROLE_SYSTEM_DIALOG;
- ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleDisclosureTriangle:
- ia_role_ = ROLE_SYSTEM_OUTLINEBUTTON;
- ia_state_ |= STATE_SYSTEM_READONLY;
+ case ui::AX_ROLE_DISCLOSURE_TRIANGLE:
+ ia_role_ = ROLE_SYSTEM_PUSHBUTTON;
break;
- case WebKit::WebAXRoleDocument:
- case WebKit::WebAXRoleRootWebArea:
- case WebKit::WebAXRoleWebArea:
+ case ui::AX_ROLE_DOCUMENT:
+ case ui::AX_ROLE_ROOT_WEB_AREA:
+ case ui::AX_ROLE_WEB_AREA:
ia_role_ = ROLE_SYSTEM_DOCUMENT;
ia_state_ |= STATE_SYSTEM_READONLY;
ia_state_ |= STATE_SYSTEM_FOCUSABLE;
break;
- case WebKit::WebAXRoleEditableText:
+ case ui::AX_ROLE_EDITABLE_TEXT:
ia_role_ = ROLE_SYSTEM_TEXT;
ia2_state_ |= IA2_STATE_SINGLE_LINE;
ia2_state_ |= IA2_STATE_EDITABLE;
break;
- case WebKit::WebAXRoleForm:
+ case ui::AX_ROLE_FIGCAPTION:
+ role_name_ = html_tag;
+ ia2_role_ = IA2_ROLE_CAPTION;
+ break;
+ case ui::AX_ROLE_FIGURE:
+ role_name_ = html_tag;
+ ia_role_ = ROLE_SYSTEM_GROUPING;
+ ia2_role_ = IA2_ROLE_SECTION;
+ break;
+ case ui::AX_ROLE_FORM:
role_name_ = L"form";
ia2_role_ = IA2_ROLE_FORM;
break;
- case WebKit::WebAXRoleFooter:
+ case ui::AX_ROLE_FOOTER:
ia_role_ = IA2_ROLE_FOOTER;
ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleGrid:
+ case ui::AX_ROLE_GRID:
ia_role_ = ROLE_SYSTEM_TABLE;
ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleGroup: {
- string16 aria_role = GetString16Attribute(
- AccessibilityNodeData::ATTR_ROLE);
+ case ui::AX_ROLE_GROUP: {
+ base::string16 aria_role = GetString16Attribute(
+ ui::AX_ATTR_ROLE);
if (aria_role == L"group" || html_tag == L"fieldset") {
ia_role_ = ROLE_SYSTEM_GROUPING;
} else if (html_tag == L"li") {
ia_role_ = ROLE_SYSTEM_LISTITEM;
+ ia_state_ |= STATE_SYSTEM_READONLY;
} else {
if (html_tag.empty())
role_name_ = L"div";
role_name_ = html_tag;
ia2_role_ = IA2_ROLE_SECTION;
}
- ia_state_ |= STATE_SYSTEM_READONLY;
break;
}
- case WebKit::WebAXRoleGrowArea:
+ case ui::AX_ROLE_GROW_AREA:
ia_role_ = ROLE_SYSTEM_GRIP;
ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleHeading:
+ case ui::AX_ROLE_HEADING:
role_name_ = html_tag;
ia2_role_ = IA2_ROLE_HEADING;
- ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleHorizontalRule:
+ case ui::AX_ROLE_HORIZONTAL_RULE:
ia_role_ = ROLE_SYSTEM_SEPARATOR;
break;
- case WebKit::WebAXRoleImage:
+ case ui::AX_ROLE_IFRAME:
+ ia_role_ = ROLE_SYSTEM_DOCUMENT;
+ ia2_role_ = IA2_ROLE_INTERNAL_FRAME;
+ ia_state_ = STATE_SYSTEM_READONLY;
+ break;
+ case ui::AX_ROLE_IMAGE:
ia_role_ = ROLE_SYSTEM_GRAPHIC;
ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleImageMap:
+ case ui::AX_ROLE_IMAGE_MAP:
role_name_ = html_tag;
ia2_role_ = IA2_ROLE_IMAGE_MAP;
ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleImageMapLink:
+ case ui::AX_ROLE_IMAGE_MAP_LINK:
ia_role_ = ROLE_SYSTEM_LINK;
ia_state_ |= STATE_SYSTEM_LINKED;
ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleLabel:
+ case ui::AX_ROLE_LABEL_TEXT:
ia_role_ = ROLE_SYSTEM_TEXT;
ia2_role_ = IA2_ROLE_LABEL;
break;
- case WebKit::WebAXRoleBanner:
- case WebKit::WebAXRoleComplementary:
- case WebKit::WebAXRoleContentInfo:
- case WebKit::WebAXRoleMain:
- case WebKit::WebAXRoleNavigation:
- case WebKit::WebAXRoleSearch:
+ case ui::AX_ROLE_SEARCH:
ia_role_ = ROLE_SYSTEM_GROUPING;
ia2_role_ = IA2_ROLE_SECTION;
- ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleLink:
+ case ui::AX_ROLE_LINK:
ia_role_ = ROLE_SYSTEM_LINK;
ia_state_ |= STATE_SYSTEM_LINKED;
break;
- case WebKit::WebAXRoleList:
+ case ui::AX_ROLE_LIST:
ia_role_ = ROLE_SYSTEM_LIST;
ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleListBox:
+ case ui::AX_ROLE_LIST_BOX:
ia_role_ = ROLE_SYSTEM_LIST;
break;
- case WebKit::WebAXRoleListBoxOption:
+ case ui::AX_ROLE_LIST_BOX_OPTION:
ia_role_ = ROLE_SYSTEM_LISTITEM;
if (ia_state_ & STATE_SYSTEM_SELECTABLE) {
ia_state_ |= STATE_SYSTEM_FOCUSABLE;
- if (HasState(WebKit::WebAXStateFocused))
+ if (HasState(ui::AX_STATE_FOCUSED))
ia_state_ |= STATE_SYSTEM_FOCUSED;
}
break;
- case WebKit::WebAXRoleListItem:
+ case ui::AX_ROLE_LIST_ITEM:
ia_role_ = ROLE_SYSTEM_LISTITEM;
ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleListMarker:
- ia_role_ = ROLE_SYSTEM_TEXT;
- ia_state_ |= STATE_SYSTEM_READONLY;
+ case ui::AX_ROLE_MAIN:
+ ia_role_ = ROLE_SYSTEM_GROUPING;
+ ia2_role_ = IA2_ROLE_PARAGRAPH;
break;
- case WebKit::WebAXRoleMath:
+ case ui::AX_ROLE_MARQUEE:
+ ia_role_ = ROLE_SYSTEM_ANIMATION;
+ break;
+ case ui::AX_ROLE_MATH:
ia_role_ = ROLE_SYSTEM_EQUATION;
- ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleMenu:
- case WebKit::WebAXRoleMenuButton:
+ case ui::AX_ROLE_MENU:
+ case ui::AX_ROLE_MENU_BUTTON:
ia_role_ = ROLE_SYSTEM_MENUPOPUP;
break;
- case WebKit::WebAXRoleMenuBar:
+ case ui::AX_ROLE_MENU_BAR:
ia_role_ = ROLE_SYSTEM_MENUBAR;
break;
- case WebKit::WebAXRoleMenuItem:
+ case ui::AX_ROLE_MENU_ITEM:
ia_role_ = ROLE_SYSTEM_MENUITEM;
break;
- case WebKit::WebAXRoleMenuListPopup:
+ case ui::AX_ROLE_MENU_ITEM_CHECK_BOX:
+ ia_role_ = ROLE_SYSTEM_MENUITEM;
+ ia2_role_ = IA2_ROLE_CHECK_MENU_ITEM;
+ ia2_state_ |= IA2_STATE_CHECKABLE;
+ break;
+ case ui::AX_ROLE_MENU_ITEM_RADIO:
+ ia_role_ = ROLE_SYSTEM_MENUITEM;
+ ia2_role_ = IA2_ROLE_RADIO_MENU_ITEM;
+ break;
+ case ui::AX_ROLE_MENU_LIST_POPUP:
ia_role_ = ROLE_SYSTEM_CLIENT;
break;
- case WebKit::WebAXRoleMenuListOption:
+ case ui::AX_ROLE_MENU_LIST_OPTION:
ia_role_ = ROLE_SYSTEM_LISTITEM;
if (ia_state_ & STATE_SYSTEM_SELECTABLE) {
ia_state_ |= STATE_SYSTEM_FOCUSABLE;
- if (HasState(WebKit::WebAXStateFocused))
+ if (HasState(ui::AX_STATE_FOCUSED))
ia_state_ |= STATE_SYSTEM_FOCUSED;
}
break;
- case WebKit::WebAXRoleNote:
+ case ui::AX_ROLE_METER:
+ role_name_ = html_tag;
+ ia_role_ = ROLE_SYSTEM_PROGRESSBAR;
+ break;
+ case ui::AX_ROLE_NAVIGATION:
+ ia_role_ = ROLE_SYSTEM_GROUPING;
+ ia2_role_ = IA2_ROLE_SECTION;
+ break;
+ case ui::AX_ROLE_NOTE:
ia_role_ = ROLE_SYSTEM_GROUPING;
ia2_role_ = IA2_ROLE_NOTE;
ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleOutline:
+ case ui::AX_ROLE_OUTLINE:
ia_role_ = ROLE_SYSTEM_OUTLINE;
- ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleParagraph:
+ case ui::AX_ROLE_PARAGRAPH:
role_name_ = L"P";
ia2_role_ = IA2_ROLE_PARAGRAPH;
break;
- case WebKit::WebAXRolePopUpButton:
+ case ui::AX_ROLE_POP_UP_BUTTON:
if (html_tag == L"select") {
ia_role_ = ROLE_SYSTEM_COMBOBOX;
} else {
ia_role_ = ROLE_SYSTEM_BUTTONMENU;
}
break;
- case WebKit::WebAXRoleProgressIndicator:
+ case ui::AX_ROLE_PRE:
+ role_name_ = html_tag;
+ ia_role_ = ROLE_SYSTEM_TEXT;
+ ia2_role_ = IA2_ROLE_PARAGRAPH;
+ break;
+ case ui::AX_ROLE_PROGRESS_INDICATOR:
ia_role_ = ROLE_SYSTEM_PROGRESSBAR;
ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleRadioButton:
+ case ui::AX_ROLE_RADIO_BUTTON:
ia_role_ = ROLE_SYSTEM_RADIOBUTTON;
break;
- case WebKit::WebAXRoleRadioGroup:
+ case ui::AX_ROLE_RADIO_GROUP:
ia_role_ = ROLE_SYSTEM_GROUPING;
- ia2_role_ = IA2_ROLE_SECTION;
break;
- case WebKit::WebAXRoleRegion:
- ia_role_ = ROLE_SYSTEM_GROUPING;
- ia2_role_ = IA2_ROLE_SECTION;
- ia_state_ |= STATE_SYSTEM_READONLY;
+ case ui::AX_ROLE_REGION:
+ if (html_tag == L"section") {
+ ia_role_ = ROLE_SYSTEM_GROUPING;
+ ia2_role_ = IA2_ROLE_SECTION;
+ } else {
+ ia_role_ = ROLE_SYSTEM_PANE;
+ }
break;
- case WebKit::WebAXRoleRow:
+ case ui::AX_ROLE_ROW:
ia_role_ = ROLE_SYSTEM_ROW;
- ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleRowHeader:
+ case ui::AX_ROLE_ROW_HEADER:
ia_role_ = ROLE_SYSTEM_ROWHEADER;
- ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleRuler:
+ case ui::AX_ROLE_RULER:
ia_role_ = ROLE_SYSTEM_CLIENT;
ia2_role_ = IA2_ROLE_RULER;
ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleScrollArea:
+ case ui::AX_ROLE_SCROLL_AREA:
ia_role_ = ROLE_SYSTEM_CLIENT;
ia2_role_ = IA2_ROLE_SCROLL_PANE;
ia_state_ |= STATE_SYSTEM_READONLY;
+ ia2_state_ &= ~(IA2_STATE_EDITABLE);
break;
- case WebKit::WebAXRoleScrollBar:
+ case ui::AX_ROLE_SCROLL_BAR:
ia_role_ = ROLE_SYSTEM_SCROLLBAR;
break;
- case WebKit::WebAXRoleSlider:
+ case ui::AX_ROLE_SLIDER:
ia_role_ = ROLE_SYSTEM_SLIDER;
break;
- case WebKit::WebAXRoleSpinButton:
+ case ui::AX_ROLE_SPIN_BUTTON:
ia_role_ = ROLE_SYSTEM_SPINBUTTON;
break;
- case WebKit::WebAXRoleSpinButtonPart:
+ case ui::AX_ROLE_SPIN_BUTTON_PART:
ia_role_ = ROLE_SYSTEM_PUSHBUTTON;
break;
- case WebKit::WebAXRoleSplitGroup:
+ case ui::AX_ROLE_SPLIT_GROUP:
ia_role_ = ROLE_SYSTEM_CLIENT;
ia2_role_ = IA2_ROLE_SPLIT_PANE;
ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleAnnotation:
- case WebKit::WebAXRoleStaticText:
- ia_role_ = ROLE_SYSTEM_TEXT;
- ia_state_ |= STATE_SYSTEM_READONLY;
+ case ui::AX_ROLE_ANNOTATION:
+ case ui::AX_ROLE_LIST_MARKER:
+ case ui::AX_ROLE_STATIC_TEXT:
+ ia_role_ = ROLE_SYSTEM_STATICTEXT;
break;
- case WebKit::WebAXRoleStatus:
+ case ui::AX_ROLE_STATUS:
ia_role_ = ROLE_SYSTEM_STATUSBAR;
ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleSplitter:
+ case ui::AX_ROLE_SPLITTER:
ia_role_ = ROLE_SYSTEM_SEPARATOR;
break;
- case WebKit::WebAXRoleSVGRoot:
+ case ui::AX_ROLE_SVG_ROOT:
ia_role_ = ROLE_SYSTEM_GRAPHIC;
break;
- case WebKit::WebAXRoleTab:
+ case ui::AX_ROLE_TAB:
ia_role_ = ROLE_SYSTEM_PAGETAB;
break;
- case WebKit::WebAXRoleTable: {
- string16 aria_role = GetString16Attribute(
- AccessibilityNodeData::ATTR_ROLE);
+ case ui::AX_ROLE_TABLE: {
+ base::string16 aria_role = GetString16Attribute(
+ ui::AX_ATTR_ROLE);
if (aria_role == L"treegrid") {
ia_role_ = ROLE_SYSTEM_OUTLINE;
} else {
ia_role_ = ROLE_SYSTEM_TABLE;
- ia_state_ |= STATE_SYSTEM_READONLY;
}
break;
}
- case WebKit::WebAXRoleTableHeaderContainer:
+ case ui::AX_ROLE_TABLE_HEADER_CONTAINER:
ia_role_ = ROLE_SYSTEM_GROUPING;
ia2_role_ = IA2_ROLE_SECTION;
ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleTabList:
+ case ui::AX_ROLE_TAB_LIST:
ia_role_ = ROLE_SYSTEM_PAGETABLIST;
break;
- case WebKit::WebAXRoleTabPanel:
+ case ui::AX_ROLE_TAB_PANEL:
ia_role_ = ROLE_SYSTEM_PROPERTYPAGE;
break;
- case WebKit::WebAXRoleToggleButton:
+ case ui::AX_ROLE_TOGGLE_BUTTON:
ia_role_ = ROLE_SYSTEM_PUSHBUTTON;
ia2_role_ = IA2_ROLE_TOGGLE_BUTTON;
break;
- case WebKit::WebAXRoleTextArea:
+ case ui::AX_ROLE_TEXT_AREA:
ia_role_ = ROLE_SYSTEM_TEXT;
ia2_state_ |= IA2_STATE_MULTI_LINE;
ia2_state_ |= IA2_STATE_EDITABLE;
ia2_state_ |= IA2_STATE_SELECTABLE_TEXT;
break;
- case WebKit::WebAXRoleTextField:
+ case ui::AX_ROLE_TEXT_FIELD:
ia_role_ = ROLE_SYSTEM_TEXT;
ia2_state_ |= IA2_STATE_SINGLE_LINE;
ia2_state_ |= IA2_STATE_EDITABLE;
ia2_state_ |= IA2_STATE_SELECTABLE_TEXT;
break;
- case WebKit::WebAXRoleTimer:
+ case ui::AX_ROLE_TIME:
+ ia_role_ = ROLE_SYSTEM_SPINBUTTON;
+ break;
+ case ui::AX_ROLE_TIMER:
ia_role_ = ROLE_SYSTEM_CLOCK;
ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleToolbar:
+ case ui::AX_ROLE_TOOLBAR:
ia_role_ = ROLE_SYSTEM_TOOLBAR;
ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleUserInterfaceTooltip:
+ case ui::AX_ROLE_TOOLTIP:
ia_role_ = ROLE_SYSTEM_TOOLTIP;
ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleTree:
+ case ui::AX_ROLE_TREE:
ia_role_ = ROLE_SYSTEM_OUTLINE;
- ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleTreeGrid:
+ case ui::AX_ROLE_TREE_GRID:
ia_role_ = ROLE_SYSTEM_OUTLINE;
- ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleTreeItem:
+ case ui::AX_ROLE_TREE_ITEM:
ia_role_ = ROLE_SYSTEM_OUTLINEITEM;
- ia_state_ |= STATE_SYSTEM_READONLY;
break;
- case WebKit::WebAXRoleWindow:
+ case ui::AX_ROLE_WINDOW:
ia_role_ = ROLE_SYSTEM_WINDOW;
break;
// TODO(dmazzoni): figure out the proper MSAA role for all of these.
- case WebKit::WebAXRoleBrowser:
- case WebKit::WebAXRoleDirectory:
- case WebKit::WebAXRoleDrawer:
- case WebKit::WebAXRoleHelpTag:
- case WebKit::WebAXRoleIgnored:
- case WebKit::WebAXRoleIncrementor:
- case WebKit::WebAXRoleLog:
- case WebKit::WebAXRoleMarquee:
- case WebKit::WebAXRoleMatte:
- case WebKit::WebAXRolePresentational:
- case WebKit::WebAXRoleRulerMarker:
- case WebKit::WebAXRoleSheet:
- case WebKit::WebAXRoleSliderThumb:
- case WebKit::WebAXRoleSystemWide:
- case WebKit::WebAXRoleValueIndicator:
+ case ui::AX_ROLE_BROWSER:
+ case ui::AX_ROLE_DIRECTORY:
+ case ui::AX_ROLE_DRAWER:
+ case ui::AX_ROLE_HELP_TAG:
+ case ui::AX_ROLE_IGNORED:
+ case ui::AX_ROLE_INCREMENTOR:
+ case ui::AX_ROLE_LOG:
+ case ui::AX_ROLE_MATTE:
+ case ui::AX_ROLE_NONE:
+ case ui::AX_ROLE_PRESENTATIONAL:
+ case ui::AX_ROLE_RULER_MARKER:
+ case ui::AX_ROLE_SHEET:
+ case ui::AX_ROLE_SLIDER_THUMB:
+ case ui::AX_ROLE_SYSTEM_WIDE:
+ case ui::AX_ROLE_VALUE_INDICATOR:
default:
ia_role_ = ROLE_SYSTEM_CLIENT;
break;
// aria-readonly attribute and for a few roles (in the switch above).
// We clear the READONLY state on focusable controls and on a document.
// Everything else, the majority of objects, do not have this state set.
- if (HasState(WebKit::WebAXStateFocusable) &&
+ if (HasState(ui::AX_STATE_FOCUSABLE) &&
ia_role_ != ROLE_SYSTEM_DOCUMENT) {
ia_state_ &= ~(STATE_SYSTEM_READONLY);
}
- if (!HasState(WebKit::WebAXStateReadonly))
+ if (!HasState(ui::AX_STATE_READ_ONLY))
ia_state_ &= ~(STATE_SYSTEM_READONLY);
- if (GetBoolAttribute(AccessibilityNodeData::ATTR_ARIA_READONLY))
+ if (GetBoolAttribute(ui::AX_ATTR_ARIA_READONLY))
ia_state_ |= STATE_SYSTEM_READONLY;
// The role should always be set.
projects / platform / framework / web / crosswalk.git / blobdiff