Line data    Source code

       1             : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
       2             : /* vim: set ts=2 et sw=2 tw=80: */
       3             : /* This Source Code Form is subject to the terms of the Mozilla Public
       4             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       5             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
       6             : 
       7             : #include "InterfaceInitFuncs.h"
       8             : 
       9             : #include "AccessibleWrap.h"
      10             : #include "nsMai.h"
      11             : #include "ProxyAccessible.h"
      12             : #include "mozilla/FloatingPoint.h"
      13             : #include "mozilla/Likely.h"
      14             : 
      15             : using namespace mozilla;
      16             : using namespace mozilla::a11y;
      17             : 
      18             : extern "C" {
      19             : 
      20             : static void
      21           0 : getCurrentValueCB(AtkValue *obj, GValue *value)
      22             : {
      23           0 :   ProxyAccessible* proxy = nullptr;
      24           0 :   AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(obj));
      25           0 :   if (!accWrap) {
      26           0 :     proxy = GetProxy(ATK_OBJECT(obj));
      27           0 :     if (!proxy) {
      28           0 :       return;
      29             :     }
      30             :   }
      31             : 
      32           0 :   memset (value,  0, sizeof (GValue));
      33           0 :   double accValue = accWrap ? accWrap->CurValue() : proxy->CurValue();
      34           0 :   if (IsNaN(accValue))
      35           0 :     return;
      36             : 
      37           0 :   g_value_init (value, G_TYPE_DOUBLE);
      38           0 :   g_value_set_double (value, accValue);
      39             : }
      40             : 
      41             : static void
      42           0 : getMaximumValueCB(AtkValue *obj, GValue *value)
      43             : {
      44           0 :   ProxyAccessible* proxy = nullptr;
      45           0 :   AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(obj));
      46           0 :   if (!accWrap) {
      47           0 :     proxy = GetProxy(ATK_OBJECT(obj));
      48           0 :     if (!proxy) {
      49           0 :       return;
      50             :     }
      51             :   }
      52             : 
      53           0 :   memset(value,  0, sizeof (GValue));
      54           0 :   double accValue = accWrap ? accWrap->MaxValue() : proxy->MaxValue();
      55           0 :   if (IsNaN(accValue))
      56           0 :     return;
      57             : 
      58           0 :   g_value_init(value, G_TYPE_DOUBLE);
      59           0 :   g_value_set_double(value, accValue);
      60             : }
      61             : 
      62             : static void
      63           0 : getMinimumValueCB(AtkValue *obj, GValue *value)
      64             : {
      65           0 :   ProxyAccessible* proxy = nullptr;
      66           0 :   AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(obj));
      67           0 :   if (!accWrap) {
      68           0 :     proxy = GetProxy(ATK_OBJECT(obj));
      69           0 :     if (!proxy) {
      70           0 :       return;
      71             :     }
      72             :   }
      73             : 
      74           0 :   memset(value,  0, sizeof (GValue));
      75           0 :   double accValue = accWrap ? accWrap->MinValue() : proxy->MinValue();
      76           0 :   if (IsNaN(accValue))
      77           0 :     return;
      78             : 
      79           0 :   g_value_init(value, G_TYPE_DOUBLE);
      80           0 :   g_value_set_double(value, accValue);
      81             : }
      82             : 
      83             : static void
      84           0 : getMinimumIncrementCB(AtkValue *obj, GValue *minimumIncrement)
      85             : {
      86           0 :   ProxyAccessible* proxy = nullptr;
      87           0 :   AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(obj));
      88           0 :   if (!accWrap) {
      89           0 :     proxy = GetProxy(ATK_OBJECT(obj));
      90           0 :     if (!proxy) {
      91           0 :       return;
      92             :     }
      93             :   }
      94             : 
      95           0 :   memset(minimumIncrement,  0, sizeof (GValue));
      96           0 :   double accValue = accWrap ? accWrap->Step() : proxy->Step();
      97           0 :   if (IsNaN(accValue))
      98           0 :     accValue = 0; // zero if the minimum increment is undefined
      99             : 
     100           0 :   g_value_init(minimumIncrement, G_TYPE_DOUBLE);
     101           0 :   g_value_set_double(minimumIncrement, accValue);
     102             : }
     103             : 
     104             : static gboolean
     105           0 : setCurrentValueCB(AtkValue *obj, const GValue *value)
     106             : {
     107           0 :   ProxyAccessible* proxy = nullptr;
     108           0 :   AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(obj));
     109           0 :   if (!accWrap) {
     110           0 :     proxy = GetProxy(ATK_OBJECT(obj));
     111           0 :     if (!proxy) {
     112           0 :       return FALSE;
     113             :     }
     114             :   }
     115             : 
     116           0 :   double accValue =g_value_get_double(value);
     117           0 :   return accWrap ? accWrap->SetCurValue(accValue) : proxy->SetCurValue(accValue);
     118             : }
     119             : }
     120             : 
     121             : void
     122           0 : valueInterfaceInitCB(AtkValueIface* aIface)
     123             : {
     124           0 :   NS_ASSERTION(aIface, "Invalid aIface");
     125           0 :   if (MOZ_UNLIKELY(!aIface))
     126           0 :     return;
     127             : 
     128           0 :   aIface->get_current_value = getCurrentValueCB;
     129           0 :   aIface->get_maximum_value = getMaximumValueCB;
     130           0 :   aIface->get_minimum_value = getMinimumValueCB;
     131           0 :   aIface->get_minimum_increment = getMinimumIncrementCB;
     132           0 :   aIface->set_current_value = setCurrentValueCB;
     133             : }