1 /*

     2  * Copyright (C) 2008 Apple Inc. All Rights Reserved.

     3  * Copyright (C) 2009 Jan Michael Alonzo

     4  *

     5  * Redistribution and use in source and binary forms, with or without

     6  * modification, are permitted provided that the following conditions

     7  * are met:

     8  * 1. Redistributions of source code must retain the above copyright

     9  *    notice, this list of conditions and the following disclaimer.

    10  * 2. Redistributions in binary form must reproduce the above copyright

    11  *    notice, this list of conditions and the following disclaimer in the

    12  *    documentation and/or other materials provided with the distribution.

    13  *

    14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

    15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

    17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

    18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

    19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

    20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

    21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

    22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

    24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

    25  */

    26 

    27 #include "config.h"

    28 #include "AccessibilityUIElement.h"

    29 #include "GOwnPtr.h"

    30 #include "GRefPtr.h"

    31 

    32 #include <JavaScriptCore/JSStringRef.h>

    33 #include <wtf/Assertions.h>

    34 

    35 #include <atk/atk.h>

    36 #include <gtk/gtk.h>

    37 

    38 

    39 AccessibilityUIElement::AccessibilityUIElement(PlatformUIElement element)

    40     : m_element(element)

    41 {

    42 }

    43 

    44 AccessibilityUIElement::AccessibilityUIElement(const AccessibilityUIElement& other)

    45     : m_element(other.m_element)

    46 {

    47 }

    48 

    49 AccessibilityUIElement::~AccessibilityUIElement()

    50 {

    51 }

    52 

    53 void AccessibilityUIElement::getLinkedUIElements(Vector<AccessibilityUIElement>& elements)

    54 {

    55     // FIXME: implement

    56 }

    57 

    58 void AccessibilityUIElement::getDocumentLinks(Vector<AccessibilityUIElement>&)

    59 {

    60     // FIXME: implement

    61 }

    62 

    63 void AccessibilityUIElement::getChildren(Vector<AccessibilityUIElement>& children)

    64 {

    65     int count = childrenCount();

    66     for (int i = 0; i < count; i++) {

    67         AtkObject* child = atk_object_ref_accessible_child(ATK_OBJECT(m_element), i);

    68         children.append(AccessibilityUIElement(child));

    69     }

    70 }

    71 

    72 void AccessibilityUIElement::getChildrenWithRange(Vector<AccessibilityUIElement>& elementVector, unsigned start, unsigned end)

    73 {

    74     for (unsigned i = start; i < end; i++) {

    75         AtkObject* child = atk_object_ref_accessible_child(ATK_OBJECT(m_element), i);

    76         elementVector.append(AccessibilityUIElement(child));

    77     }

    78 }

    79 

    80 int AccessibilityUIElement::rowCount()

    81 {

    82     if (!m_element)

    83         return 0;

    84 

    85     ASSERT(ATK_IS_TABLE(m_element));

    86 

    87     return atk_table_get_n_rows(ATK_TABLE(m_element));

    88 }

    89 

    90 int AccessibilityUIElement::columnCount()

    91 {

    92     if (!m_element)

    93         return 0;

    94 

    95     ASSERT(ATK_IS_TABLE(m_element));

    96 

    97     return atk_table_get_n_columns(ATK_TABLE(m_element));

    98 }

    99 

   100 int AccessibilityUIElement::childrenCount()

   101 {

   102     if (!m_element)

   103         return 0;

   104 

   105     ASSERT(ATK_IS_OBJECT(m_element));

   106 

   107     return atk_object_get_n_accessible_children(ATK_OBJECT(m_element));

   108 }

   109 

   110 AccessibilityUIElement AccessibilityUIElement::elementAtPoint(int x, int y)

   111 {

   112     // FIXME: implement

   113     return 0;

   114 }

   115 

   116 AccessibilityUIElement AccessibilityUIElement::linkedUIElementAtIndex(unsigned index)

   117 {

   118     // FIXME: implement

   119     return 0;

   120 }

   121 

   122 AccessibilityUIElement AccessibilityUIElement::getChildAtIndex(unsigned index)

   123 {

   124     Vector<AccessibilityUIElement> children;

   125     getChildrenWithRange(children, index, index + 1);

   126 

   127     if (children.size() == 1)

   128         return children.at(0);

   129 

   130     return 0;

   131 }

   132 

   133 unsigned AccessibilityUIElement::indexOfChild(AccessibilityUIElement* element)

   134 { 

   135     // FIXME: implement

   136     return 0;

   137 }

   138 

   139 gchar* attributeSetToString(AtkAttributeSet* attributeSet)

   140 {

   141     GString* str = g_string_new(0);

   142     for (GSList* attributes = attributeSet; attributes; attributes = attributes->next) {

   143         AtkAttribute* attribute = static_cast<AtkAttribute*>(attributes->data);

   144         g_string_append(str, g_strconcat(attribute->name, ":", attribute->value, NULL));

   145         if (attributes->next)

   146             g_string_append(str, ", ");

   147     }

   148 

   149     return g_string_free(str, FALSE);

   150 }

   151 

   152 JSStringRef AccessibilityUIElement::allAttributes()

   153 {

   154     return JSStringCreateWithUTF8CString(attributeSetToString(atk_object_get_attributes(ATK_OBJECT(m_element))));

   155 }

   156 

   157 JSStringRef AccessibilityUIElement::attributesOfLinkedUIElements()

   158 {

   159     // FIXME: implement

   160     return JSStringCreateWithCharacters(0, 0);

   161 }

   162 

   163 JSStringRef AccessibilityUIElement::attributesOfDocumentLinks()

   164 {

   165     // FIXME: implement

   166     return JSStringCreateWithCharacters(0, 0);

   167 }

   168 

   169 AccessibilityUIElement AccessibilityUIElement::titleUIElement()

   170 {

   171     // FIXME: implement

   172     return 0;

   173 }

   174 

   175 AccessibilityUIElement AccessibilityUIElement::parentElement()

   176 {

   177     ASSERT(m_element);

   178     AtkObject* parent =  atk_object_get_parent(ATK_OBJECT(m_element));

   179 

   180     return parent ? AccessibilityUIElement(parent) : 0;

   181 }

   182 

   183 JSStringRef AccessibilityUIElement::attributesOfChildren()

   184 {

   185     // FIXME: implement

   186     return JSStringCreateWithCharacters(0, 0);

   187 }

   188 

   189 JSStringRef AccessibilityUIElement::parameterizedAttributeNames()

   190 {

   191     // FIXME: implement

   192     return JSStringCreateWithCharacters(0, 0);

   193 }

   194 

   195 JSStringRef AccessibilityUIElement::role()

   196 {

   197     AtkRole role = atk_object_get_role(ATK_OBJECT(m_element));

   198 

   199     if (!role)

   200         return JSStringCreateWithCharacters(0, 0);

   201 

   202     const gchar* roleName = atk_role_get_name(role);

   203     GOwnPtr<gchar> axRole(g_strdup_printf("AXRole: %s", roleName));

   204 

   205     return JSStringCreateWithUTF8CString(axRole.get());

   206 }

   207 

   208 JSStringRef AccessibilityUIElement::subrole()

   209 {

   210     return 0;

   211 }

   212 

   213 JSStringRef AccessibilityUIElement::roleDescription()

   214 {

   215     return 0;

   216 }

   217 

   218 JSStringRef AccessibilityUIElement::title()

   219 {

   220     const gchar* name = atk_object_get_name(ATK_OBJECT(m_element));

   221 

   222     if (!name)

   223         return JSStringCreateWithCharacters(0, 0);

   224 

   225     GOwnPtr<gchar> axTitle(g_strdup_printf("AXTitle: %s", name));

   226 

   227     return JSStringCreateWithUTF8CString(axTitle.get());

   228 }

   229 

   230 JSStringRef AccessibilityUIElement::description()

   231 {

   232     const gchar* description = atk_object_get_description(ATK_OBJECT(m_element));

   233 

   234     if (!description)

   235         return JSStringCreateWithCharacters(0, 0);

   236 

   237     GOwnPtr<gchar> axDesc(g_strdup_printf("AXDescription: %s", description));

   238 

   239     return JSStringCreateWithUTF8CString(axDesc.get());

   240 }

   241 

   242 JSStringRef AccessibilityUIElement::stringValue()

   243 {

   244     // FIXME: implement

   245     return JSStringCreateWithCharacters(0, 0);

   246 }

   247 

   248 JSStringRef AccessibilityUIElement::language()

   249 {

   250     // FIXME: implement

   251     return JSStringCreateWithCharacters(0, 0);

   252 }

   253 

   254 JSStringRef AccessibilityUIElement::helpText() const

   255 {

   256     return 0;

   257 }

   258 

   259 double AccessibilityUIElement::x()

   260 {

   261     int x, y;

   262 

   263     atk_component_get_position(ATK_COMPONENT(m_element), &x, &y, ATK_XY_SCREEN);

   264 

   265     return x;

   266 }

   267 

   268 double AccessibilityUIElement::y()

   269 {

   270     int x, y;

   271 

   272     atk_component_get_position(ATK_COMPONENT(m_element), &x, &y, ATK_XY_SCREEN);

   273 

   274     return y;

   275 }

   276 

   277 double AccessibilityUIElement::width()

   278 {

   279     int width, height;

   280 

   281     atk_component_get_size(ATK_COMPONENT(m_element), &width, &height);

   282 

   283     return width;

   284 }

   285 

   286 double AccessibilityUIElement::height()

   287 {

   288     int width, height;

   289 

   290     atk_component_get_size(ATK_COMPONENT(m_element), &width, &height);

   291 

   292     return height;

   293 }

   294 

   295 double AccessibilityUIElement::clickPointX()

   296 {

   297     return 0.f;

   298 }

   299 

   300 double AccessibilityUIElement::clickPointY()

   301 {

   302     return 0.f;

   303 }

   304 

   305 JSStringRef AccessibilityUIElement::orientation() const

   306 {

   307     return 0;

   308 }

   309 

   310 double AccessibilityUIElement::intValue() const

   311 {

   312     GValue value = { 0, { { 0 } } };

   313 

   314     if (!ATK_IS_VALUE(m_element))

   315         return 0.0f;

   316 

   317     atk_value_get_current_value(ATK_VALUE(m_element), &value);

   318 

   319     if (G_VALUE_HOLDS_DOUBLE(&value))

   320         return g_value_get_double(&value);

   321     else if (G_VALUE_HOLDS_INT(&value))

   322         return static_cast<double>(g_value_get_int(&value));

   323     else

   324         return 0.0f;

   325 }

   326 

   327 double AccessibilityUIElement::minValue()

   328 {

   329     GValue value = { 0, { { 0 } } };

   330 

   331     if (!ATK_IS_VALUE(m_element))

   332         return 0.0f;

   333 

   334     atk_value_get_minimum_value(ATK_VALUE(m_element), &value);

   335 

   336     if (G_VALUE_HOLDS_DOUBLE(&value))

   337         return g_value_get_double(&value);

   338     else if (G_VALUE_HOLDS_INT(&value))

   339         return static_cast<double>(g_value_get_int(&value));

   340     else

   341         return 0.0f;

   342 }

   343 

   344 double AccessibilityUIElement::maxValue()

   345 {

   346     GValue value = { 0, { { 0 } } };

   347 

   348     if (!ATK_IS_VALUE(m_element))

   349         return 0.0f;

   350 

   351     atk_value_get_maximum_value(ATK_VALUE(m_element), &value);

   352 

   353     if (G_VALUE_HOLDS_DOUBLE(&value))

   354         return g_value_get_double(&value);

   355     else if (G_VALUE_HOLDS_INT(&value))

   356         return static_cast<double>(g_value_get_int(&value));

   357     else

   358         return 0.0f;

   359 }

   360 

   361 JSStringRef AccessibilityUIElement::valueDescription()

   362 {

   363     // FIXME: implement

   364     return JSStringCreateWithCharacters(0, 0);

   365 }

   366 

   367 bool AccessibilityUIElement::isEnabled()

   368 {

   369     // FIXME: implement

   370     return false;

   371 }

   372 

   373 

   374 int AccessibilityUIElement::insertionPointLineNumber()

   375 {

   376     // FIXME: implement

   377     return 0;

   378 }

   379 

   380 bool AccessibilityUIElement::isActionSupported(JSStringRef action)

   381 {

   382     // FIXME: implement

   383     return false;

   384 }

   385 

   386 bool AccessibilityUIElement::isRequired() const

   387 {

   388     // FIXME: implement

   389     return false;

   390 }

   391 

   392 bool AccessibilityUIElement::isSelected() const

   393 {

   394     if (!ATK_IS_OBJECT(m_element))

   395         return false;

   396 

   397     GRefPtr<AtkStateSet> stateSet = adoptGRef(atk_object_ref_state_set(ATK_OBJECT(m_element)));

   398     gboolean isSelected = atk_state_set_contains_state(stateSet.get(), ATK_STATE_SELECTED);

   399 

   400     return isSelected;

   401 }

   402 

   403 int AccessibilityUIElement::hierarchicalLevel() const

   404 {

   405     // FIXME: implement

   406     return 0;

   407 }

   408 

   409 bool AccessibilityUIElement::ariaIsGrabbed() const

   410 {

   411     return false;

   412 }

   413  

   414 JSStringRef AccessibilityUIElement::ariaDropEffects() const

   415 {   

   416     return 0; 

   417 }

   418 

   419 bool AccessibilityUIElement::isExpanded() const

   420 {

   421     // FIXME: implement

   422     return false;

   423 }

   424 

   425 bool AccessibilityUIElement::isChecked() const

   426 {

   427     return intValue();

   428 }

   429 

   430 JSStringRef AccessibilityUIElement::attributesOfColumnHeaders()

   431 {

   432     // FIXME: implement

   433     return JSStringCreateWithCharacters(0, 0);

   434 }

   435 

   436 JSStringRef AccessibilityUIElement::attributesOfRowHeaders()

   437 {

   438     // FIXME: implement

   439     return JSStringCreateWithCharacters(0, 0);

   440 }

   441 

   442 JSStringRef AccessibilityUIElement::attributesOfColumns()

   443 {

   444     // FIXME: implement

   445     return JSStringCreateWithCharacters(0, 0);

   446 }

   447 

   448 JSStringRef AccessibilityUIElement::attributesOfRows()

   449 {

   450     // FIXME: implement

   451     return JSStringCreateWithCharacters(0, 0);

   452 }

   453 

   454 JSStringRef AccessibilityUIElement::attributesOfVisibleCells()

   455 {

   456     // FIXME: implement

   457     return JSStringCreateWithCharacters(0, 0);

   458 }

   459 

   460 JSStringRef AccessibilityUIElement::attributesOfHeader()

   461 {

   462     // FIXME: implement

   463     return JSStringCreateWithCharacters(0, 0);

   464 }

   465 

   466 int AccessibilityUIElement::indexInTable()

   467 {

   468     // FIXME: implement

   469     return 0;

   470 }

   471 

   472 JSStringRef AccessibilityUIElement::rowIndexRange()

   473 {

   474     // FIXME: implement

   475     return JSStringCreateWithCharacters(0, 0);

   476 }

   477 

   478 JSStringRef AccessibilityUIElement::columnIndexRange()

   479 {

   480     // FIXME: implement

   481     return JSStringCreateWithCharacters(0, 0);

   482 }

   483 

   484 int AccessibilityUIElement::lineForIndex(int)

   485 {

   486     // FIXME: implement

   487     return 0;

   488 }

   489 

   490 JSStringRef AccessibilityUIElement::boundsForRange(unsigned location, unsigned length)

   491 {

   492     // FIXME: implement

   493     return JSStringCreateWithCharacters(0, 0);

   494 }

   495 

   496 JSStringRef AccessibilityUIElement::stringForRange(unsigned, unsigned) 

   497 {

   498     // FIXME: implement

   499     return JSStringCreateWithCharacters(0, 0);

   500 } 

   501 

   502 AccessibilityUIElement AccessibilityUIElement::cellForColumnAndRow(unsigned column, unsigned row)

   503 {

   504     // FIXME: implement

   505     return 0;

   506 }

   507 

   508 JSStringRef AccessibilityUIElement::selectedTextRange()

   509 {

   510     // FIXME: implement

   511     return JSStringCreateWithCharacters(0, 0);

   512 }

   513 

   514 void AccessibilityUIElement::setSelectedTextRange(unsigned location, unsigned length)

   515 {

   516     // FIXME: implement

   517 }

   518 

   519 JSStringRef AccessibilityUIElement::stringAttributeValue(JSStringRef attribute)

   520 {

   521     // FIXME: implement

   522     return JSStringCreateWithCharacters(0, 0);

   523 }

   524 

   525 bool AccessibilityUIElement::boolAttributeValue(JSStringRef attribute)

   526 {

   527     // FIXME: implement

   528     return false;

   529 }

   530 

   531 bool AccessibilityUIElement::isAttributeSettable(JSStringRef attribute)

   532 {

   533     // FIXME: implement

   534     return false;

   535 }

   536 

   537 bool AccessibilityUIElement::isAttributeSupported(JSStringRef attribute)

   538 {

   539     return false;

   540 }

   541 

   542 void AccessibilityUIElement::increment()

   543 {

   544     // FIXME: implement

   545 }

   546 

   547 void AccessibilityUIElement::decrement()

   548 {

   549     // FIXME: implement

   550 }

   551 

   552 void AccessibilityUIElement::press()

   553 {

   554     // FIXME: implement

   555 }

   556 

   557 void AccessibilityUIElement::showMenu()

   558 {

   559     // FIXME: implement

   560 }

   561 

   562 AccessibilityUIElement AccessibilityUIElement::disclosedRowAtIndex(unsigned index)

   563 {

   564     return 0;

   565 }

   566 

   567 AccessibilityUIElement AccessibilityUIElement::ariaOwnsElementAtIndex(unsigned index)

   568 {

   569     return 0;

   570 }

   571 

   572 AccessibilityUIElement AccessibilityUIElement::ariaFlowToElementAtIndex(unsigned index)

   573 {

   574     return 0;

   575 }

   576 

   577 AccessibilityUIElement AccessibilityUIElement::selectedRowAtIndex(unsigned index)

   578 {

   579     return 0;

   580 }

   581 

   582 AccessibilityUIElement AccessibilityUIElement::disclosedByRow()

   583 {

   584     return 0;

   585 }

   586 

   587 JSStringRef AccessibilityUIElement::accessibilityValue() const

   588 {

   589     // FIXME: implement

   590     return JSStringCreateWithCharacters(0, 0);

   591 }

   592 

   593 JSStringRef AccessibilityUIElement::documentEncoding()

   594 {

   595     AtkRole role = atk_object_get_role(ATK_OBJECT(m_element));

   596     if (role != ATK_ROLE_DOCUMENT_FRAME)

   597         return JSStringCreateWithCharacters(0, 0);

   598 

   599     return JSStringCreateWithUTF8CString(atk_document_get_attribute_value(ATK_DOCUMENT(m_element), "Encoding"));

   600 }

   601 

   602 JSStringRef AccessibilityUIElement::documentURI()

   603 {

   604     AtkRole role = atk_object_get_role(ATK_OBJECT(m_element));

   605     if (role != ATK_ROLE_DOCUMENT_FRAME)

   606         return JSStringCreateWithCharacters(0, 0);

   607 

   608     return JSStringCreateWithUTF8CString(atk_document_get_attribute_value(ATK_DOCUMENT(m_element), "URI"));

   609 }

   610 

   611 JSStringRef AccessibilityUIElement::url()

   612 {

   613     // FIXME: implement

   614     return JSStringCreateWithCharacters(0, 0);

   615 }

   616 

   617 bool AccessibilityUIElement::addNotificationListener(JSObjectRef functionCallback)

   618 {

   619     // FIXME: implement

   620     return false;

   621 }

   622 

   623 void AccessibilityUIElement::removeNotificationListener()

   624 {

   625     // FIXME: implement

   626 }

   627 

   628 bool AccessibilityUIElement::isSelectable() const

   629 {

   630     // FIXME: implement

   631     return false;

   632 }

   633 

   634 bool AccessibilityUIElement::isMultiSelectable() const

   635 {

   636     // FIXME: implement

   637     return false;

   638 }

   639 

   640 bool AccessibilityUIElement::isVisible() const

   641 {

   642     // FIXME: implement

   643     return false;

   644 }

   645 

   646 bool AccessibilityUIElement::isOffScreen() const

   647 {

   648     // FIXME: implement

   649     return false;

   650 }

   651 

   652 bool AccessibilityUIElement::isCollapsed() const

   653 {

   654     // FIXME: implement

   655     return false;

   656 }

   657 

   658 bool AccessibilityUIElement::hasPopup() const

   659 {

   660     // FIXME: implement

   661     return false;

   662 }

   663 

   664 void AccessibilityUIElement::takeFocus()

   665 {

   666     // FIXME: implement

   667 }

   668 

   669 void AccessibilityUIElement::takeSelection()

   670 {

   671     // FIXME: implement

   672 }

   673 

   674 void AccessibilityUIElement::addSelection()

   675 {

   676     // FIXME: implement

   677 }

   678 

   679 void AccessibilityUIElement::removeSelection()

   680 {

   681     // FIXME: implement

   682 }