accessible/src/msaa/CAccessibleAction.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim:expandtab:shiftwidth=2:tabstop=2:
   3  */
   4 /* ***** BEGIN LICENSE BLOCK *****
   5  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   6  *
   7  * The contents of this file are subject to the Mozilla Public License Version
   8  * 1.1 (the "License"); you may not use this file except in compliance with
   9  * the License. You may obtain a copy of the License at
  10  * http://www.mozilla.org/MPL/
  11  *
  12  * Software distributed under the License is distributed on an "AS IS" basis,
  13  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  14  * for the specific language governing rights and limitations under the
  15  * License.
  16  *
  17  * The Original Code is mozilla.org code.
  18  *
  19  * The Initial Developer of the Original Code is
  20  * Mozilla Foundation.
  21  * Portions created by the Initial Developer are Copyright (C) 2007
  22  * the Initial Developer. All Rights Reserved.
  23  *
  24  * Contributor(s):
  25  *   Alexander Surkov <surkov.alexander@gmail.com> (original author)
  26  *
  27  * Alternatively, the contents of this file may be used under the terms of
  28  * either the GNU General Public License Version 2 or later (the "GPL"), or
  29  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  30  * in which case the provisions of the GPL or the LGPL are applicable instead
  31  * of those above. If you wish to allow use of your version of this file only
  32  * under the terms of either the GPL or the LGPL, and not to allow others to
  33  * use your version of this file under the terms of the MPL, indicate your
  34  * decision by deleting the provisions above and replace them with the notice
  35  * and other provisions required by the GPL or the LGPL. If you do not delete
  36  * the provisions above, a recipient may use your version of this file under
  37  * the terms of any one of the MPL, the GPL or the LGPL.
  38  *
  39  * ***** END LICENSE BLOCK ***** */
  40
  41 #include "CAccessibleAction.h"
  42
  43 #include "AccessibleAction_i.c"
  44
  45 #include "nsIAccessible.h"
  46 #include "nsAccessNodeWrap.h"
  47 #include "nsCOMPtr.h"
  48 #include "nsString.h"
  49 #include "nsIDOMDOMStringList.h"
  50
  51 // IUnknown
  52
  53 STDMETHODIMP
  54 CAccessibleAction::QueryInterface(REFIID iid, void** ppv)
  55 {
  56   *ppv = NULL;
  57
  58   if (IID_IAccessibleAction == iid) {
  59     *ppv = static_cast<IAccessibleAction*>(this);
  60     (reinterpret_cast<IUnknown*>(*ppv))->AddRef();
  61     return S_OK;
  62   }
  63
  64   return E_NOINTERFACE;
  65 }
  66
  67 // IAccessibleAction
  68
  69 STDMETHODIMP
  70 CAccessibleAction::nActions(long *aNumActions)
  71 {
  72 __try {
  73   *aNumActions = 0;
  74
  75   nsCOMPtr<nsIAccessible> acc(do_QueryInterface(this));
  76   if (!acc)
  77     return E_FAIL;
  78
  79   PRUint8 count = 0;
  80   nsresult rv = acc->GetNumActions(&count);
  81   if (NS_FAILED(rv))
  82     return GetHRESULT(rv);
  83
  84   *aNumActions = count;
  85   return S_OK;
  86
  87 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
  88   return E_FAIL;
  89 }
  90
  91 STDMETHODIMP
  92 CAccessibleAction::doAction(long aActionIndex)
  93 {
  94 __try {
  95   nsCOMPtr<nsIAccessible> acc(do_QueryInterface(this));
  96   if (!acc)
  97     return E_FAIL;
  98
  99   PRUint8 index = static_cast<PRUint8>(aActionIndex);
 100   nsresult rv = acc->DoAction(index);
 101   return GetHRESULT(rv);
 102
 103 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 104   return E_FAIL;
 105 }
 106
 107 STDMETHODIMP
 108 CAccessibleAction::get_description(long aActionIndex, BSTR *aDescription)
 109 {
 110 __try {
 111   *aDescription = NULL;
 112
 113   nsCOMPtr<nsIAccessible> acc(do_QueryInterface(this));
 114   if (!acc)
 115     return E_FAIL;
 116
 117   nsAutoString description;
 118   PRUint8 index = static_cast<PRUint8>(aActionIndex);
 119   nsresult rv = acc->GetActionDescription(index, description);
 120   if (NS_FAILED(rv))
 121     return GetHRESULT(rv);
 122
 123   if (description.IsEmpty())
 124     return S_FALSE;
 125
 126   *aDescription = ::SysAllocStringLen(description.get(),
 127                                       description.Length());
 128   return *aDescription ? S_OK : E_OUTOFMEMORY;
 129
 130 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 131   return E_FAIL;
 132 }
 133
 134 STDMETHODIMP
 135 CAccessibleAction::get_keyBinding(long aActionIndex, long aNumMaxBinding,
 136                                   BSTR **aKeyBinding,
 137                                   long *aNumBinding)
 138 {
 139 __try {
 140   *aKeyBinding = NULL;
 141   *aNumBinding = 0;
 142
 143   nsCOMPtr<nsIAccessible> acc(do_QueryInterface(this));
 144   if (!acc)
 145     return E_FAIL;
 146
 147   nsCOMPtr<nsIDOMDOMStringList> keys;
 148   PRUint8 index = static_cast<PRUint8>(aActionIndex);
 149   nsresult rv = acc->GetKeyBindings(index, getter_AddRefs(keys));
 150   if (NS_FAILED(rv))
 151     return GetHRESULT(rv);
 152
 153   PRUint32 length = 0;
 154   keys->GetLength(&length);
 155   if (length == 0)
 156     return S_FALSE;
 157
 158   PRUint32 maxBinding = static_cast<PRUint32>(aNumMaxBinding);
 159   PRUint32 numBinding = length > maxBinding ? maxBinding : length;
 160   *aNumBinding = numBinding;
 161
 162   *aKeyBinding = static_cast<BSTR*>(nsMemory::Alloc((numBinding) * sizeof(BSTR*)));
 163   if (!*aKeyBinding)
 164     return E_OUTOFMEMORY;
 165
 166   PRBool outOfMemory = PR_FALSE;
 167   PRUint32 i = 0;
 168   for (; i < numBinding; i++) {
 169     nsAutoString key;
 170     keys->Item(i, key);
 171     *(aKeyBinding[i]) = ::SysAllocStringLen(key.get(), key.Length());
 172
 173     if (!*(aKeyBinding[i])) {
 174       outOfMemory = PR_TRUE;
 175       break;
 176     }
 177   }
 178
 179   if (outOfMemory) {
 180     for (PRUint32 j = 0; j < i; j++)
 181       ::SysFreeString(*(aKeyBinding[j]));
 182
 183     nsMemory::Free(*aKeyBinding);
 184     *aKeyBinding = NULL;
 185
 186     return E_OUTOFMEMORY;
 187   }
 188   return S_OK;
 189
 190 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 191   return E_FAIL;
 192 }
 193
 194 STDMETHODIMP
 195 CAccessibleAction::get_name(long aActionIndex, BSTR *aName)
 196 {
 197 __try {
 198   *aName = NULL;
 199
 200   nsCOMPtr<nsIAccessible> acc(do_QueryInterface(this));
 201   if (!acc)
 202     return E_FAIL;
 203
 204   nsAutoString name;
 205   PRUint8 index = static_cast<PRUint8>(aActionIndex);
 206   nsresult rv = acc->GetActionName(index, name);
 207   if (NS_FAILED(rv))
 208     return GetHRESULT(rv);
 209
 210   if (name.IsEmpty())
 211     return S_FALSE;
 212
 213   *aName = ::SysAllocStringLen(name.get(), name.Length());
 214   return *aName ? S_OK : E_OUTOFMEMORY;
 215
 216 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 217   return E_FAIL;
 218 }
 219
 220 STDMETHODIMP
 221 CAccessibleAction::get_localizedName(long aActionIndex, BSTR *aLocalizedName)
 222 {
 223 __try {
 224   *aLocalizedName = NULL;
 225 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 226
 227   return E_NOTIMPL;
 228 }
 229