// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ui/accessibility/ax_enums.h"

#include "base/logging.h"

namespace ui {

std::string ToString(AXEvent enum_param) {
  switch (enum_param) {
    case AX_EVENT_ACTIVEDESCENDANTCHANGED:
      return "activedescendantchanged";
    case AX_EVENT_ALERT:
      return "alert";
    case AX_EVENT_ARIA_ATTRIBUTE_CHANGED:
      return "ariaAttributeChanged";
    case AX_EVENT_AUTOCORRECTION_OCCURED:
      return "autocorrectionOccured";
    case AX_EVENT_BLUR:
      return "blur";
    case AX_EVENT_CHECKED_STATE_CHANGED:
      return "checkedStateChanged";
    case AX_EVENT_CHILDREN_CHANGED:
      return "childrenChanged";
    case AX_EVENT_FOCUS:
      return "focus";
    case AX_EVENT_HIDE:
      return "hide";
    case AX_EVENT_HOVER:
      return "hover";
    case AX_EVENT_INVALID_STATUS_CHANGED:
      return "invalidStatusChanged";
    case AX_EVENT_LAYOUT_COMPLETE:
      return "layoutComplete";
    case AX_EVENT_LIVE_REGION_CHANGED:
      return "liveRegionChanged";
    case AX_EVENT_LOAD_COMPLETE:
      return "loadComplete";
    case AX_EVENT_LOCATION_CHANGED:
      return "locationChanged";
    case AX_EVENT_MENU_END:
      return "menuEnd";
    case AX_EVENT_MENU_LIST_ITEM_SELECTED:
      return "menuListItemSelected";
    case AX_EVENT_MENU_LIST_VALUE_CHANGED:
      return "menuListValueChanged";
    case AX_EVENT_MENU_POPUP_END:
      return "menuPopupEnd";
    case AX_EVENT_MENU_POPUP_START:
      return "menuPopupStart";
    case AX_EVENT_MENU_START:
      return "menuStart";
    case AX_EVENT_ROW_COLLAPSED:
      return "rowCollapsed";
    case AX_EVENT_ROW_COUNT_CHANGED:
      return "rowCountChanged";
    case AX_EVENT_ROW_EXPANDED:
      return "rowExpanded";
    case AX_EVENT_SCROLL_POSITION_CHANGED:
      return "scrollPositionChanged";
    case AX_EVENT_SCROLLED_TO_ANCHOR:
      return "scrolledToAnchor";
    case AX_EVENT_SELECTED_CHILDREN_CHANGED:
      return "selectedChildrenChanged";
    case AX_EVENT_SELECTION:
      return "selection";
    case AX_EVENT_SELECTION_ADD:
      return "selectionAdd";
    case AX_EVENT_SELECTION_REMOVE:
      return "selectionRemove";
    case AX_EVENT_SHOW:
      return "show";
    case AX_EVENT_TEXT_CHANGED:
      return "textChanged";
    case AX_EVENT_TEXT_SELECTION_CHANGED:
      return "textSelectionChanged";
    case AX_EVENT_VALUE_CHANGED:
      return "valueChanged";
    case AX_EVENT_NONE:
      return "";
  }
  NOTREACHED();
  return "";
}

AXEvent ParseAXEvent(const std::string& enum_string) {
  if (enum_string == "activedescendantchanged")
    return AX_EVENT_ACTIVEDESCENDANTCHANGED;
  if (enum_string == "alert") return AX_EVENT_ALERT;
  if (enum_string == "aria_attribute_changed")
    return AX_EVENT_ARIA_ATTRIBUTE_CHANGED;
  if (enum_string == "autocorrection_occured")
    return AX_EVENT_AUTOCORRECTION_OCCURED;
  if (enum_string == "blur") return AX_EVENT_BLUR;
  if (enum_string == "checked_state_changed")
    return AX_EVENT_CHECKED_STATE_CHANGED;
  if (enum_string == "children_changed") return AX_EVENT_CHILDREN_CHANGED;
  if (enum_string == "focus") return AX_EVENT_FOCUS;
  if (enum_string == "hide") return AX_EVENT_HIDE;
  if (enum_string == "hover") return AX_EVENT_HOVER;
  if (enum_string == "invalid_status_changed")
    return AX_EVENT_INVALID_STATUS_CHANGED;
  if (enum_string == "layout_complete") return AX_EVENT_LAYOUT_COMPLETE;
  if (enum_string == "live_region_changed") return AX_EVENT_LIVE_REGION_CHANGED;
  if (enum_string == "load_complete") return AX_EVENT_LOAD_COMPLETE;
  if (enum_string == "location_changed") return AX_EVENT_LOCATION_CHANGED;
  if (enum_string == "menu_end") return AX_EVENT_MENU_END;
  if (enum_string == "menu_list_item_selected")
    return AX_EVENT_MENU_LIST_ITEM_SELECTED;
  if (enum_string == "menu_list_value_changed")
    return AX_EVENT_MENU_LIST_VALUE_CHANGED;
  if (enum_string == "menu_popup_end") return AX_EVENT_MENU_POPUP_END;
  if (enum_string == "menu_popup_start") return AX_EVENT_MENU_POPUP_START;
  if (enum_string == "menu_start") return AX_EVENT_MENU_START;
  if (enum_string == "row_collapsed") return AX_EVENT_ROW_COLLAPSED;
  if (enum_string == "row_count_changed") return AX_EVENT_ROW_COUNT_CHANGED;
  if (enum_string == "row_expanded") return AX_EVENT_ROW_EXPANDED;
  if (enum_string == "scroll_position_changed")
    return AX_EVENT_SCROLL_POSITION_CHANGED;
  if (enum_string == "scrolled_to_anchor") return AX_EVENT_SCROLLED_TO_ANCHOR;
  if (enum_string == "selected_children_changed")
    return AX_EVENT_SELECTED_CHILDREN_CHANGED;
  if (enum_string == "selection") return AX_EVENT_SELECTION;
  if (enum_string == "selection_add") return AX_EVENT_SELECTION_ADD;
  if (enum_string == "selection_remove") return AX_EVENT_SELECTION_REMOVE;
  if (enum_string == "show") return AX_EVENT_SHOW;
  if (enum_string == "text_changed") return AX_EVENT_TEXT_CHANGED;
  if (enum_string == "text_selection_changed")
    return AX_EVENT_TEXT_SELECTION_CHANGED;
  if (enum_string == "value_changed") return AX_EVENT_VALUE_CHANGED;
  return AX_EVENT_NONE;
}

std::string ToString(AXRole enum_param) {
  switch (enum_param) {
    case AX_ROLE_ALERT_DIALOG:
      return "alertDialog";
    case AX_ROLE_ALERT:
      return "alert";
    case AX_ROLE_ANNOTATION:
      return "annotation";
    case AX_ROLE_APPLICATION:
      return "application";
    case AX_ROLE_ARTICLE:
      return "article";
    case AX_ROLE_BANNER:
      return "banner";
    case AX_ROLE_BROWSER:
      return "browser";
    case AX_ROLE_BUSY_INDICATOR:
      return "busyIndicator";
    case AX_ROLE_BUTTON:
      return "button";
    case AX_ROLE_BUTTON_DROP_DOWN:
      return "buttonDropDown";
    case AX_ROLE_CANVAS:
      return "canvas";
    case AX_ROLE_CELL:
      return "cell";
    case AX_ROLE_CHECK_BOX:
      return "checkBox";
    case AX_ROLE_CLIENT:
      return "client";
    case AX_ROLE_COLOR_WELL:
      return "colorWell";
    case AX_ROLE_COLUMN_HEADER:
      return "columnHeader";
    case AX_ROLE_COLUMN:
      return "column";
    case AX_ROLE_COMBO_BOX:
      return "comboBox";
    case AX_ROLE_COMPLEMENTARY:
      return "complementary";
    case AX_ROLE_CONTENT_INFO:
      return "contentInfo";
    case AX_ROLE_DATE:
      return "date";
    case AX_ROLE_DATE_TIME:
      return "dateTime";
    case AX_ROLE_DEFINITION:
      return "definition";
    case AX_ROLE_DESCRIPTION_LIST_DETAIL:
      return "descriptionListDetail";
    case AX_ROLE_DESCRIPTION_LIST:
      return "descriptionList";
    case AX_ROLE_DESCRIPTION_LIST_TERM:
      return "descriptionListTerm";
    case AX_ROLE_DESKTOP:
      return "desktop";
    case AX_ROLE_DETAILS:
      return "details";
    case AX_ROLE_DIALOG:
      return "dialog";
    case AX_ROLE_DIRECTORY:
      return "directory";
    case AX_ROLE_DISCLOSURE_TRIANGLE:
      return "disclosureTriangle";
    case AX_ROLE_DIV:
      return "div";
    case AX_ROLE_DOCUMENT:
      return "document";
    case AX_ROLE_DRAWER:
      return "drawer";
    case AX_ROLE_EDITABLE_TEXT:
      return "editableText";
    case AX_ROLE_EMBEDDED_OBJECT:
      return "embeddedObject";
    case AX_ROLE_FIGCAPTION:
      return "figcaption";
    case AX_ROLE_FIGURE:
      return "figure";
    case AX_ROLE_FOOTER:
      return "footer";
    case AX_ROLE_FORM:
      return "form";
    case AX_ROLE_GRID:
      return "grid";
    case AX_ROLE_GROUP:
      return "group";
    case AX_ROLE_GROW_AREA:
      return "growArea";
    case AX_ROLE_HEADING:
      return "heading";
    case AX_ROLE_HELP_TAG:
      return "helpTag";
    case AX_ROLE_HORIZONTAL_RULE:
      return "horizontalRule";
    case AX_ROLE_IFRAME:
      return "iframe";
    case AX_ROLE_IGNORED:
      return "ignored";
    case AX_ROLE_IMAGE_MAP_LINK:
      return "imageMapLink";
    case AX_ROLE_IMAGE_MAP:
      return "imageMap";
    case AX_ROLE_IMAGE:
      return "image";
    case AX_ROLE_INCREMENTOR:
      return "incrementor";
    case AX_ROLE_INLINE_TEXT_BOX:
      return "inlineTextBox";
    case AX_ROLE_LABEL_TEXT:
      return "labelText";
    case AX_ROLE_LEGEND:
      return "legend";
    case AX_ROLE_LINK:
      return "link";
    case AX_ROLE_LIST_BOX_OPTION:
      return "listBoxOption";
    case AX_ROLE_LIST_BOX:
      return "listBox";
    case AX_ROLE_LIST_ITEM:
      return "listItem";
    case AX_ROLE_LIST_MARKER:
      return "listMarker";
    case AX_ROLE_LIST:
      return "list";
    case AX_ROLE_LOCATION_BAR:
      return "locationBar";
    case AX_ROLE_LOG:
      return "log";
    case AX_ROLE_MAIN:
      return "main";
    case AX_ROLE_MARQUEE:
      return "marquee";
    case AX_ROLE_MATH_ELEMENT:
      return "mathElement";
    case AX_ROLE_MATH:
      return "math";
    case AX_ROLE_MATTE:
      return "matte";
    case AX_ROLE_MENU_BAR:
      return "menuBar";
    case AX_ROLE_MENU_BUTTON:
      return "menuButton";
    case AX_ROLE_MENU_ITEM:
      return "menuItem";
    case AX_ROLE_MENU_ITEM_CHECK_BOX:
      return "menuItemCheckBox";
    case AX_ROLE_MENU_ITEM_RADIO:
      return "menuItemRadio";
    case AX_ROLE_MENU_LIST_OPTION:
      return "menuListOption";
    case AX_ROLE_MENU_LIST_POPUP:
      return "menuListPopup";
    case AX_ROLE_MENU:
      return "menu";
    case AX_ROLE_METER:
      return "meter";
    case AX_ROLE_NAVIGATION:
      return "navigation";
    case AX_ROLE_NOTE:
      return "note";
    case AX_ROLE_OUTLINE:
      return "outline";
    case AX_ROLE_PANE:
      return "pane";
    case AX_ROLE_PARAGRAPH:
      return "paragraph";
    case AX_ROLE_POP_UP_BUTTON:
      return "popUpButton";
    case AX_ROLE_PRESENTATIONAL:
      return "presentational";
    case AX_ROLE_PROGRESS_INDICATOR:
      return "progressIndicator";
    case AX_ROLE_RADIO_BUTTON:
      return "radioButton";
    case AX_ROLE_RADIO_GROUP:
      return "radioGroup";
    case AX_ROLE_REGION:
      return "region";
    case AX_ROLE_ROOT_WEB_AREA:
      return "rootWebArea";
    case AX_ROLE_ROW_HEADER:
      return "rowHeader";
    case AX_ROLE_ROW:
      return "row";
    case AX_ROLE_RULER_MARKER:
      return "rulerMarker";
    case AX_ROLE_RULER:
      return "ruler";
    case AX_ROLE_SVG_ROOT:
      return "svgRoot";
    case AX_ROLE_SCROLL_AREA:
      return "scrollArea";
    case AX_ROLE_SCROLL_BAR:
      return "scrollBar";
    case AX_ROLE_SEAMLESS_WEB_AREA:
      return "seamlessWebArea";
    case AX_ROLE_SEARCH:
      return "search";
    case AX_ROLE_SHEET:
      return "sheet";
    case AX_ROLE_SLIDER:
      return "slider";
    case AX_ROLE_SLIDER_THUMB:
      return "sliderThumb";
    case AX_ROLE_SPIN_BUTTON_PART:
      return "spinButtonPart";
    case AX_ROLE_SPIN_BUTTON:
      return "spinButton";
    case AX_ROLE_SPLIT_GROUP:
      return "splitGroup";
    case AX_ROLE_SPLITTER:
      return "splitter";
    case AX_ROLE_STATIC_TEXT:
      return "staticText";
    case AX_ROLE_STATUS:
      return "status";
    case AX_ROLE_SYSTEM_WIDE:
      return "systemWide";
    case AX_ROLE_TAB_GROUP:
      return "tabGroup";
    case AX_ROLE_TAB_LIST:
      return "tabList";
    case AX_ROLE_TAB_PANEL:
      return "tabPanel";
    case AX_ROLE_TAB:
      return "tab";
    case AX_ROLE_TABLE_HEADER_CONTAINER:
      return "tableHeaderContainer";
    case AX_ROLE_TABLE:
      return "table";
    case AX_ROLE_TEXT_AREA:
      return "textArea";
    case AX_ROLE_TEXT_FIELD:
      return "textField";
    case AX_ROLE_TIME:
      return "time";
    case AX_ROLE_TIMER:
      return "timer";
    case AX_ROLE_TITLE_BAR:
      return "titleBar";
    case AX_ROLE_TOGGLE_BUTTON:
      return "toggleButton";
    case AX_ROLE_TOOLBAR:
      return "toolbar";
    case AX_ROLE_TREE_GRID:
      return "treeGrid";
    case AX_ROLE_TREE_ITEM:
      return "treeItem";
    case AX_ROLE_TREE:
      return "tree";
    case AX_ROLE_UNKNOWN:
      return "unknown";
    case AX_ROLE_TOOLTIP:
      return "tooltip";
    case AX_ROLE_VALUE_INDICATOR:
      return "valueIndicator";
    case AX_ROLE_WEB_AREA:
      return "webArea";
    case AX_ROLE_WINDOW:
      return "window";
    case AX_ROLE_NONE:
      return "";
  }
  NOTREACHED();
  return "";
}

AXRole ParseAXRole(const std::string& enum_string) {
  if (enum_string == "alert_dialog") return AX_ROLE_ALERT_DIALOG;
  if (enum_string == "alert") return AX_ROLE_ALERT;
  if (enum_string == "annotation") return AX_ROLE_ANNOTATION;
  if (enum_string == "application") return AX_ROLE_APPLICATION;
  if (enum_string == "article") return AX_ROLE_ARTICLE;
  if (enum_string == "banner") return AX_ROLE_BANNER;
  if (enum_string == "browser") return AX_ROLE_BROWSER;
  if (enum_string == "busy_indicator") return AX_ROLE_BUSY_INDICATOR;
  if (enum_string == "button") return AX_ROLE_BUTTON;
  if (enum_string == "button_drop_down") return AX_ROLE_BUTTON_DROP_DOWN;
  if (enum_string == "canvas") return AX_ROLE_CANVAS;
  if (enum_string == "cell") return AX_ROLE_CELL;
  if (enum_string == "check_box") return AX_ROLE_CHECK_BOX;
  if (enum_string == "client") return AX_ROLE_CLIENT;
  if (enum_string == "color_well") return AX_ROLE_COLOR_WELL;
  if (enum_string == "column_header") return AX_ROLE_COLUMN_HEADER;
  if (enum_string == "column") return AX_ROLE_COLUMN;
  if (enum_string == "combo_box") return AX_ROLE_COMBO_BOX;
  if (enum_string == "complementary") return AX_ROLE_COMPLEMENTARY;
  if (enum_string == "content_info") return AX_ROLE_CONTENT_INFO;
  if (enum_string == "date") return AX_ROLE_DATE;
  if (enum_string == "date_time") return AX_ROLE_DATE_TIME;
  if (enum_string == "definition") return AX_ROLE_DEFINITION;
  if (enum_string == "description_list_detail")
    return AX_ROLE_DESCRIPTION_LIST_DETAIL;
  if (enum_string == "description_list") return AX_ROLE_DESCRIPTION_LIST;
  if (enum_string == "description_list_term")
    return AX_ROLE_DESCRIPTION_LIST_TERM;
  if (enum_string == "desktop") return AX_ROLE_DESKTOP;
  if (enum_string == "details") return AX_ROLE_DETAILS;
  if (enum_string == "dialog") return AX_ROLE_DIALOG;
  if (enum_string == "directory") return AX_ROLE_DIRECTORY;
  if (enum_string == "disclosure_triangle") return AX_ROLE_DISCLOSURE_TRIANGLE;
  if (enum_string == "div") return AX_ROLE_DIV;
  if (enum_string == "document") return AX_ROLE_DOCUMENT;
  if (enum_string == "drawer") return AX_ROLE_DRAWER;
  if (enum_string == "editable_text") return AX_ROLE_EDITABLE_TEXT;
  if (enum_string == "embedded_object") return AX_ROLE_EMBEDDED_OBJECT;
  if (enum_string == "figcaption") return AX_ROLE_FIGCAPTION;
  if (enum_string == "figure") return AX_ROLE_FIGURE;
  if (enum_string == "footer") return AX_ROLE_FOOTER;
  if (enum_string == "form") return AX_ROLE_FORM;
  if (enum_string == "grid") return AX_ROLE_GRID;
  if (enum_string == "group") return AX_ROLE_GROUP;
  if (enum_string == "grow_area") return AX_ROLE_GROW_AREA;
  if (enum_string == "heading") return AX_ROLE_HEADING;
  if (enum_string == "help_tag") return AX_ROLE_HELP_TAG;
  if (enum_string == "horizontal_rule") return AX_ROLE_HORIZONTAL_RULE;
  if (enum_string == "iframe") return AX_ROLE_IFRAME;
  if (enum_string == "ignored") return AX_ROLE_IGNORED;
  if (enum_string == "image_map_link") return AX_ROLE_IMAGE_MAP_LINK;
  if (enum_string == "image_map") return AX_ROLE_IMAGE_MAP;
  if (enum_string == "image") return AX_ROLE_IMAGE;
  if (enum_string == "incrementor") return AX_ROLE_INCREMENTOR;
  if (enum_string == "inline_text_box") return AX_ROLE_INLINE_TEXT_BOX;
  if (enum_string == "label_text") return AX_ROLE_LABEL_TEXT;
  if (enum_string == "legend") return AX_ROLE_LEGEND;
  if (enum_string == "link") return AX_ROLE_LINK;
  if (enum_string == "list_box_option") return AX_ROLE_LIST_BOX_OPTION;
  if (enum_string == "list_box") return AX_ROLE_LIST_BOX;
  if (enum_string == "list_item") return AX_ROLE_LIST_ITEM;
  if (enum_string == "list_marker") return AX_ROLE_LIST_MARKER;
  if (enum_string == "list") return AX_ROLE_LIST;
  if (enum_string == "location_bar") return AX_ROLE_LOCATION_BAR;
  if (enum_string == "log") return AX_ROLE_LOG;
  if (enum_string == "main") return AX_ROLE_MAIN;
  if (enum_string == "marquee") return AX_ROLE_MARQUEE;
  if (enum_string == "math_element") return AX_ROLE_MATH_ELEMENT;
  if (enum_string == "math") return AX_ROLE_MATH;
  if (enum_string == "matte") return AX_ROLE_MATTE;
  if (enum_string == "menu_bar") return AX_ROLE_MENU_BAR;
  if (enum_string == "menu_button") return AX_ROLE_MENU_BUTTON;
  if (enum_string == "menu_item") return AX_ROLE_MENU_ITEM;
  if (enum_string == "menu_item_check_box") return AX_ROLE_MENU_ITEM_CHECK_BOX;
  if (enum_string == "menu_item_radio") return AX_ROLE_MENU_ITEM_RADIO;
  if (enum_string == "menu_list_option") return AX_ROLE_MENU_LIST_OPTION;
  if (enum_string == "menu_list_popup") return AX_ROLE_MENU_LIST_POPUP;
  if (enum_string == "menu") return AX_ROLE_MENU;
  if (enum_string == "meter") return AX_ROLE_METER;
  if (enum_string == "navigation") return AX_ROLE_NAVIGATION;
  if (enum_string == "note") return AX_ROLE_NOTE;
  if (enum_string == "outline") return AX_ROLE_OUTLINE;
  if (enum_string == "pane") return AX_ROLE_PANE;
  if (enum_string == "paragraph") return AX_ROLE_PARAGRAPH;
  if (enum_string == "pop_up_button") return AX_ROLE_POP_UP_BUTTON;
  if (enum_string == "presentational") return AX_ROLE_PRESENTATIONAL;
  if (enum_string == "progress_indicator") return AX_ROLE_PROGRESS_INDICATOR;
  if (enum_string == "radio_button") return AX_ROLE_RADIO_BUTTON;
  if (enum_string == "radio_group") return AX_ROLE_RADIO_GROUP;
  if (enum_string == "region") return AX_ROLE_REGION;
  if (enum_string == "root_web_area") return AX_ROLE_ROOT_WEB_AREA;
  if (enum_string == "row_header") return AX_ROLE_ROW_HEADER;
  if (enum_string == "row") return AX_ROLE_ROW;
  if (enum_string == "ruler_marker") return AX_ROLE_RULER_MARKER;
  if (enum_string == "ruler") return AX_ROLE_RULER;
  if (enum_string == "svg_root") return AX_ROLE_SVG_ROOT;
  if (enum_string == "scroll_area") return AX_ROLE_SCROLL_AREA;
  if (enum_string == "scroll_bar") return AX_ROLE_SCROLL_BAR;
  if (enum_string == "seamless_web_area") return AX_ROLE_SEAMLESS_WEB_AREA;
  if (enum_string == "search") return AX_ROLE_SEARCH;
  if (enum_string == "sheet") return AX_ROLE_SHEET;
  if (enum_string == "slider") return AX_ROLE_SLIDER;
  if (enum_string == "slider_thumb") return AX_ROLE_SLIDER_THUMB;
  if (enum_string == "spin_button_part") return AX_ROLE_SPIN_BUTTON_PART;
  if (enum_string == "spin_button") return AX_ROLE_SPIN_BUTTON;
  if (enum_string == "split_group") return AX_ROLE_SPLIT_GROUP;
  if (enum_string == "splitter") return AX_ROLE_SPLITTER;
  if (enum_string == "static_text") return AX_ROLE_STATIC_TEXT;
  if (enum_string == "status") return AX_ROLE_STATUS;
  if (enum_string == "system_wide") return AX_ROLE_SYSTEM_WIDE;
  if (enum_string == "tab_group") return AX_ROLE_TAB_GROUP;
  if (enum_string == "tab_list") return AX_ROLE_TAB_LIST;
  if (enum_string == "tab_panel") return AX_ROLE_TAB_PANEL;
  if (enum_string == "tab") return AX_ROLE_TAB;
  if (enum_string == "table_header_container")
    return AX_ROLE_TABLE_HEADER_CONTAINER;
  if (enum_string == "table") return AX_ROLE_TABLE;
  if (enum_string == "text_area") return AX_ROLE_TEXT_AREA;
  if (enum_string == "text_field") return AX_ROLE_TEXT_FIELD;
  if (enum_string == "time") return AX_ROLE_TIME;
  if (enum_string == "timer") return AX_ROLE_TIMER;
  if (enum_string == "title_bar") return AX_ROLE_TITLE_BAR;
  if (enum_string == "toggle_button") return AX_ROLE_TOGGLE_BUTTON;
  if (enum_string == "toolbar") return AX_ROLE_TOOLBAR;
  if (enum_string == "tree_grid") return AX_ROLE_TREE_GRID;
  if (enum_string == "tree_item") return AX_ROLE_TREE_ITEM;
  if (enum_string == "tree") return AX_ROLE_TREE;
  if (enum_string == "unknown") return AX_ROLE_UNKNOWN;
  if (enum_string == "tooltip") return AX_ROLE_TOOLTIP;
  if (enum_string == "value_indicator") return AX_ROLE_VALUE_INDICATOR;
  if (enum_string == "web_area") return AX_ROLE_WEB_AREA;
  if (enum_string == "window") return AX_ROLE_WINDOW;
  return AX_ROLE_NONE;
}

std::string ToString(AXState enum_param) {
  switch (enum_param) {
    case AX_STATE_BUSY:
      return "busy";
    case AX_STATE_CHECKED:
      return "checked";
    case AX_STATE_COLLAPSED:
      return "collapsed";
    case AX_STATE_DEFAULT:
      return "default";
    case AX_STATE_DISABLED:
      return "disabled";
    case AX_STATE_EDITABLE:
      return "editable";
    case AX_STATE_ENABLED:
      return "enabled";
    case AX_STATE_EXPANDED:
      return "expanded";
    case AX_STATE_FOCUSABLE:
      return "focusable";
    case AX_STATE_FOCUSED:
      return "focused";
    case AX_STATE_HASPOPUP:
      return "haspopup";
    case AX_STATE_HOVERED:
      return "hovered";
    case AX_STATE_INDETERMINATE:
      return "indeterminate";
    case AX_STATE_INVISIBLE:
      return "invisible";
    case AX_STATE_LINKED:
      return "linked";
    case AX_STATE_MULTISELECTABLE:
      return "multiselectable";
    case AX_STATE_OFFSCREEN:
      return "offscreen";
    case AX_STATE_PRESSED:
      return "pressed";
    case AX_STATE_PROTECTED:
      return "protected";
    case AX_STATE_READ_ONLY:
      return "readOnly";
    case AX_STATE_REQUIRED:
      return "required";
    case AX_STATE_SELECTABLE:
      return "selectable";
    case AX_STATE_SELECTED:
      return "selected";
    case AX_STATE_VERTICAL:
      return "vertical";
    case AX_STATE_VISITED:
      return "visited";
    case AX_STATE_NONE:
      return "";
  }
  NOTREACHED();
  return "";
}

AXState ParseAXState(const std::string& enum_string) {
  if (enum_string == "busy") return AX_STATE_BUSY;
  if (enum_string == "checked") return AX_STATE_CHECKED;
  if (enum_string == "collapsed") return AX_STATE_COLLAPSED;
  if (enum_string == "default") return AX_STATE_DEFAULT;
  if (enum_string == "disabled") return AX_STATE_DISABLED;
  if (enum_string == "editable") return AX_STATE_EDITABLE;
  if (enum_string == "enabled") return AX_STATE_ENABLED;
  if (enum_string == "expanded") return AX_STATE_EXPANDED;
  if (enum_string == "focusable") return AX_STATE_FOCUSABLE;
  if (enum_string == "focused") return AX_STATE_FOCUSED;
  if (enum_string == "haspopup") return AX_STATE_HASPOPUP;
  if (enum_string == "hovered") return AX_STATE_HOVERED;
  if (enum_string == "indeterminate") return AX_STATE_INDETERMINATE;
  if (enum_string == "invisible") return AX_STATE_INVISIBLE;
  if (enum_string == "linked") return AX_STATE_LINKED;
  if (enum_string == "multiselectable") return AX_STATE_MULTISELECTABLE;
  if (enum_string == "offscreen") return AX_STATE_OFFSCREEN;
  if (enum_string == "pressed") return AX_STATE_PRESSED;
  if (enum_string == "protected") return AX_STATE_PROTECTED;
  if (enum_string == "read_only") return AX_STATE_READ_ONLY;
  if (enum_string == "required") return AX_STATE_REQUIRED;
  if (enum_string == "selectable") return AX_STATE_SELECTABLE;
  if (enum_string == "selected") return AX_STATE_SELECTED;
  if (enum_string == "vertical") return AX_STATE_VERTICAL;
  if (enum_string == "visited") return AX_STATE_VISITED;
  return AX_STATE_NONE;
}

std::string ToString(AXStringAttribute enum_param) {
  switch (enum_param) {
    case AX_ATTR_DOC_URL:
      return "docUrl";
    case AX_ATTR_DOC_TITLE:
      return "docTitle";
    case AX_ATTR_DOC_MIMETYPE:
      return "docMimetype";
    case AX_ATTR_DOC_DOCTYPE:
      return "docDoctype";
    case AX_ATTR_ACCESS_KEY:
      return "accessKey";
    case AX_ATTR_ACTION:
      return "action";
    case AX_ATTR_CONTAINER_LIVE_RELEVANT:
      return "containerLiveRelevant";
    case AX_ATTR_CONTAINER_LIVE_STATUS:
      return "containerLiveStatus";
    case AX_ATTR_DESCRIPTION:
      return "description";
    case AX_ATTR_DISPLAY:
      return "display";
    case AX_ATTR_HELP:
      return "help";
    case AX_ATTR_HTML_TAG:
      return "htmlTag";
    case AX_ATTR_NAME:
      return "name";
    case AX_ATTR_LIVE_RELEVANT:
      return "liveRelevant";
    case AX_ATTR_LIVE_STATUS:
      return "liveStatus";
    case AX_ATTR_ROLE:
      return "role";
    case AX_ATTR_SHORTCUT:
      return "shortcut";
    case AX_ATTR_TEXT_INPUT_TYPE:
      return "textInputType";
    case AX_ATTR_URL:
      return "url";
    case AX_ATTR_VALUE:
      return "value";
    case AX_STRING_ATTRIBUTE_NONE:
      return "";
  }
  NOTREACHED();
  return "";
}

AXStringAttribute ParseAXStringAttribute(const std::string& enum_string) {
  if (enum_string == "doc_url") return AX_ATTR_DOC_URL;
  if (enum_string == "doc_title") return AX_ATTR_DOC_TITLE;
  if (enum_string == "doc_mimetype") return AX_ATTR_DOC_MIMETYPE;
  if (enum_string == "doc_doctype") return AX_ATTR_DOC_DOCTYPE;
  if (enum_string == "access_key") return AX_ATTR_ACCESS_KEY;
  if (enum_string == "action") return AX_ATTR_ACTION;
  if (enum_string == "container_live_relevant")
    return AX_ATTR_CONTAINER_LIVE_RELEVANT;
  if (enum_string == "container_live_status")
    return AX_ATTR_CONTAINER_LIVE_STATUS;
  if (enum_string == "description") return AX_ATTR_DESCRIPTION;
  if (enum_string == "display") return AX_ATTR_DISPLAY;
  if (enum_string == "help") return AX_ATTR_HELP;
  if (enum_string == "html_tag") return AX_ATTR_HTML_TAG;
  if (enum_string == "name") return AX_ATTR_NAME;
  if (enum_string == "live_relevant") return AX_ATTR_LIVE_RELEVANT;
  if (enum_string == "live_status") return AX_ATTR_LIVE_STATUS;
  if (enum_string == "role") return AX_ATTR_ROLE;
  if (enum_string == "shortcut") return AX_ATTR_SHORTCUT;
  if (enum_string == "text_input_type") return AX_ATTR_TEXT_INPUT_TYPE;
  if (enum_string == "url") return AX_ATTR_URL;
  if (enum_string == "value") return AX_ATTR_VALUE;
  return AX_STRING_ATTRIBUTE_NONE;
}

std::string ToString(AXIntAttribute enum_param) {
  switch (enum_param) {
    case AX_ATTR_SCROLL_X:
      return "scrollX";
    case AX_ATTR_SCROLL_X_MIN:
      return "scrollXMin";
    case AX_ATTR_SCROLL_X_MAX:
      return "scrollXMax";
    case AX_ATTR_SCROLL_Y:
      return "scrollY";
    case AX_ATTR_SCROLL_Y_MIN:
      return "scrollYMin";
    case AX_ATTR_SCROLL_Y_MAX:
      return "scrollYMax";
    case AX_ATTR_TEXT_SEL_START:
      return "textSelStart";
    case AX_ATTR_TEXT_SEL_END:
      return "textSelEnd";
    case AX_ATTR_TABLE_ROW_COUNT:
      return "tableRowCount";
    case AX_ATTR_TABLE_COLUMN_COUNT:
      return "tableColumnCount";
    case AX_ATTR_TABLE_HEADER_ID:
      return "tableHeaderId";
    case AX_ATTR_TABLE_ROW_INDEX:
      return "tableRowIndex";
    case AX_ATTR_TABLE_ROW_HEADER_ID:
      return "tableRowHeaderId";
    case AX_ATTR_TABLE_COLUMN_INDEX:
      return "tableColumnIndex";
    case AX_ATTR_TABLE_COLUMN_HEADER_ID:
      return "tableColumnHeaderId";
    case AX_ATTR_TABLE_CELL_COLUMN_INDEX:
      return "tableCellColumnIndex";
    case AX_ATTR_TABLE_CELL_COLUMN_SPAN:
      return "tableCellColumnSpan";
    case AX_ATTR_TABLE_CELL_ROW_INDEX:
      return "tableCellRowIndex";
    case AX_ATTR_TABLE_CELL_ROW_SPAN:
      return "tableCellRowSpan";
    case AX_ATTR_HIERARCHICAL_LEVEL:
      return "hierarchicalLevel";
    case AX_ATTR_TITLE_UI_ELEMENT:
      return "titleUiElement";
    case AX_ATTR_ACTIVEDESCENDANT_ID:
      return "activedescendantId";
    case AX_ATTR_COLOR_VALUE_RED:
      return "colorValueRed";
    case AX_ATTR_COLOR_VALUE_GREEN:
      return "colorValueGreen";
    case AX_ATTR_COLOR_VALUE_BLUE:
      return "colorValueBlue";
    case AX_ATTR_TEXT_DIRECTION:
      return "textDirection";
    case AX_INT_ATTRIBUTE_NONE:
      return "";
  }
  NOTREACHED();
  return "";
}

AXIntAttribute ParseAXIntAttribute(const std::string& enum_string) {
  if (enum_string == "scroll_x") return AX_ATTR_SCROLL_X;
  if (enum_string == "scroll_x_min") return AX_ATTR_SCROLL_X_MIN;
  if (enum_string == "scroll_x_max") return AX_ATTR_SCROLL_X_MAX;
  if (enum_string == "scroll_y") return AX_ATTR_SCROLL_Y;
  if (enum_string == "scroll_y_min") return AX_ATTR_SCROLL_Y_MIN;
  if (enum_string == "scroll_y_max") return AX_ATTR_SCROLL_Y_MAX;
  if (enum_string == "text_sel_start") return AX_ATTR_TEXT_SEL_START;
  if (enum_string == "text_sel_end") return AX_ATTR_TEXT_SEL_END;
  if (enum_string == "table_row_count") return AX_ATTR_TABLE_ROW_COUNT;
  if (enum_string == "table_column_count") return AX_ATTR_TABLE_COLUMN_COUNT;
  if (enum_string == "table_header_id") return AX_ATTR_TABLE_HEADER_ID;
  if (enum_string == "table_row_index") return AX_ATTR_TABLE_ROW_INDEX;
  if (enum_string == "table_row_header_id") return AX_ATTR_TABLE_ROW_HEADER_ID;
  if (enum_string == "table_column_index") return AX_ATTR_TABLE_COLUMN_INDEX;
  if (enum_string == "table_column_header_id")
    return AX_ATTR_TABLE_COLUMN_HEADER_ID;
  if (enum_string == "table_cell_column_index")
    return AX_ATTR_TABLE_CELL_COLUMN_INDEX;
  if (enum_string == "table_cell_column_span")
    return AX_ATTR_TABLE_CELL_COLUMN_SPAN;
  if (enum_string == "table_cell_row_index")
    return AX_ATTR_TABLE_CELL_ROW_INDEX;
  if (enum_string == "table_cell_row_span") return AX_ATTR_TABLE_CELL_ROW_SPAN;
  if (enum_string == "hierarchical_level") return AX_ATTR_HIERARCHICAL_LEVEL;
  if (enum_string == "title_ui_element") return AX_ATTR_TITLE_UI_ELEMENT;
  if (enum_string == "activedescendant_id") return AX_ATTR_ACTIVEDESCENDANT_ID;
  if (enum_string == "color_value_red") return AX_ATTR_COLOR_VALUE_RED;
  if (enum_string == "color_value_green") return AX_ATTR_COLOR_VALUE_GREEN;
  if (enum_string == "color_value_blue") return AX_ATTR_COLOR_VALUE_BLUE;
  if (enum_string == "text_direction") return AX_ATTR_TEXT_DIRECTION;
  return AX_INT_ATTRIBUTE_NONE;
}

std::string ToString(AXFloatAttribute enum_param) {
  switch (enum_param) {
    case AX_ATTR_DOC_LOADING_PROGRESS:
      return "docLoadingProgress";
    case AX_ATTR_VALUE_FOR_RANGE:
      return "valueForRange";
    case AX_ATTR_MIN_VALUE_FOR_RANGE:
      return "minValueForRange";
    case AX_ATTR_MAX_VALUE_FOR_RANGE:
      return "maxValueForRange";
    case AX_FLOAT_ATTRIBUTE_NONE:
      return "";
  }
  NOTREACHED();
  return "";
}

AXFloatAttribute ParseAXFloatAttribute(const std::string& enum_string) {
  if (enum_string == "doc_loading_progress")
    return AX_ATTR_DOC_LOADING_PROGRESS;
  if (enum_string == "value_for_range") return AX_ATTR_VALUE_FOR_RANGE;
  if (enum_string == "min_value_for_range") return AX_ATTR_MIN_VALUE_FOR_RANGE;
  if (enum_string == "max_value_for_range") return AX_ATTR_MAX_VALUE_FOR_RANGE;
  return AX_FLOAT_ATTRIBUTE_NONE;
}

std::string ToString(AXBoolAttribute enum_param) {
  switch (enum_param) {
    case AX_ATTR_DOC_LOADED:
      return "docLoaded";
    case AX_ATTR_BUTTON_MIXED:
      return "buttonMixed";
    case AX_ATTR_CONTAINER_LIVE_ATOMIC:
      return "containerLiveAtomic";
    case AX_ATTR_CONTAINER_LIVE_BUSY:
      return "containerLiveBusy";
    case AX_ATTR_LIVE_ATOMIC:
      return "liveAtomic";
    case AX_ATTR_LIVE_BUSY:
      return "liveBusy";
    case AX_ATTR_ARIA_READONLY:
      return "ariaReadonly";
    case AX_ATTR_CAN_SET_VALUE:
      return "canSetValue";
    case AX_ATTR_UPDATE_LOCATION_ONLY:
      return "updateLocationOnly";
    case AX_ATTR_CANVAS_HAS_FALLBACK:
      return "canvasHasFallback";
    case AX_ATTR_IS_AX_TREE_HOST:
      return "isAxTreeHost";
    case AX_BOOL_ATTRIBUTE_NONE:
      return "";
  }
  NOTREACHED();
  return "";
}

AXBoolAttribute ParseAXBoolAttribute(const std::string& enum_string) {
  if (enum_string == "doc_loaded") return AX_ATTR_DOC_LOADED;
  if (enum_string == "button_mixed") return AX_ATTR_BUTTON_MIXED;
  if (enum_string == "container_live_atomic")
    return AX_ATTR_CONTAINER_LIVE_ATOMIC;
  if (enum_string == "container_live_busy") return AX_ATTR_CONTAINER_LIVE_BUSY;
  if (enum_string == "live_atomic") return AX_ATTR_LIVE_ATOMIC;
  if (enum_string == "live_busy") return AX_ATTR_LIVE_BUSY;
  if (enum_string == "aria_readonly") return AX_ATTR_ARIA_READONLY;
  if (enum_string == "can_set_value") return AX_ATTR_CAN_SET_VALUE;
  if (enum_string == "update_location_only")
    return AX_ATTR_UPDATE_LOCATION_ONLY;
  if (enum_string == "canvas_has_fallback") return AX_ATTR_CANVAS_HAS_FALLBACK;
  if (enum_string == "is_ax_tree_host") return AX_ATTR_IS_AX_TREE_HOST;
  return AX_BOOL_ATTRIBUTE_NONE;
}

std::string ToString(AXIntListAttribute enum_param) {
  switch (enum_param) {
    case AX_ATTR_INDIRECT_CHILD_IDS:
      return "indirectChildIds";
    case AX_ATTR_CONTROLS_IDS:
      return "controlsIds";
    case AX_ATTR_DESCRIBEDBY_IDS:
      return "describedbyIds";
    case AX_ATTR_FLOWTO_IDS:
      return "flowtoIds";
    case AX_ATTR_LABELLEDBY_IDS:
      return "labelledbyIds";
    case AX_ATTR_OWNS_IDS:
      return "ownsIds";
    case AX_ATTR_LINE_BREAKS:
      return "lineBreaks";
    case AX_ATTR_CELL_IDS:
      return "cellIds";
    case AX_ATTR_UNIQUE_CELL_IDS:
      return "uniqueCellIds";
    case AX_ATTR_CHARACTER_OFFSETS:
      return "characterOffsets";
    case AX_ATTR_WORD_STARTS:
      return "wordStarts";
    case AX_ATTR_WORD_ENDS:
      return "wordEnds";
    case AX_INT_LIST_ATTRIBUTE_NONE:
      return "";
  }
  NOTREACHED();
  return "";
}

AXIntListAttribute ParseAXIntListAttribute(const std::string& enum_string) {
  if (enum_string == "indirect_child_ids") return AX_ATTR_INDIRECT_CHILD_IDS;
  if (enum_string == "controls_ids") return AX_ATTR_CONTROLS_IDS;
  if (enum_string == "describedby_ids") return AX_ATTR_DESCRIBEDBY_IDS;
  if (enum_string == "flowto_ids") return AX_ATTR_FLOWTO_IDS;
  if (enum_string == "labelledby_ids") return AX_ATTR_LABELLEDBY_IDS;
  if (enum_string == "owns_ids") return AX_ATTR_OWNS_IDS;
  if (enum_string == "line_breaks") return AX_ATTR_LINE_BREAKS;
  if (enum_string == "cell_ids") return AX_ATTR_CELL_IDS;
  if (enum_string == "unique_cell_ids") return AX_ATTR_UNIQUE_CELL_IDS;
  if (enum_string == "character_offsets") return AX_ATTR_CHARACTER_OFFSETS;
  if (enum_string == "word_starts") return AX_ATTR_WORD_STARTS;
  if (enum_string == "word_ends") return AX_ATTR_WORD_ENDS;
  return AX_INT_LIST_ATTRIBUTE_NONE;
}

std::string ToString(AXTextDirection enum_param) {
  switch (enum_param) {
    case AX_TEXT_DIRECTION_LR:
      return "textDirectionLr";
    case AX_TEXT_DIRECTION_RL:
      return "textDirectionRl";
    case AX_TEXT_DIRECTION_TB:
      return "textDirectionTb";
    case AX_TEXT_DIRECTION_BT:
      return "textDirectionBt";
    case AX_TEXT_DIRECTION_NONE:
      return "";
  }
  NOTREACHED();
  return "";
}

AXTextDirection ParseAXTextDirection(const std::string& enum_string) {
  if (enum_string == "text_direction_lr") return AX_TEXT_DIRECTION_LR;
  if (enum_string == "text_direction_rl") return AX_TEXT_DIRECTION_RL;
  if (enum_string == "text_direction_tb") return AX_TEXT_DIRECTION_TB;
  if (enum_string == "text_direction_bt") return AX_TEXT_DIRECTION_BT;
  return AX_TEXT_DIRECTION_NONE;
}

}  // namespace ui