Adding upstream version 4:24.2.0.upstream/4%24.2.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 258 insertions, 0 deletions

diff --git a/winaccessibility/source/UAccCOM/EnumVariant.cxx b/winaccessibility/source/UAccCOM/EnumVariant.cxx
new file mode 100644
index 0000000000..698461ac7a
--- /dev/null
+++ b/winaccessibility/source/UAccCOM/EnumVariant.cxx
@@ -0,0 +1,258 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include "stdafx.h"
+#include  <UAccCOM.h>
+#include "EnumVariant.h"
+#include "MAccessible.h"
+
+#include <sal/log.hxx>
+#include <vcl/svapp.hxx>
+
+using namespace com::sun::star::uno;
+using namespace com::sun::star::accessibility;
+
+
+// CEnumVariant
+
+
+/**
+   * enumerate method,get next element
+   * @param  cElements The number of elements to be returned.
+   * @param  pvar      An array of at least size celt in which the elements are to be returned.
+   * @param  pcElementFetched Pointer to the number of elements returned in rgVar, or Null
+   * @return Result.
+   */
+HRESULT STDMETHODCALLTYPE CEnumVariant::Next(ULONG cElements,VARIANT __RPC_FAR *pvar,ULONG __RPC_FAR *pcElementFetched)
+{
+    SolarMutexGuard g;
+
+    ULONG l2;
+
+    if (pvar == nullptr)
+        return E_INVALIDARG;
+
+    if (pcElementFetched != nullptr)
+        *pcElementFetched = 0;
+
+    sal_Int64 nChildCount = m_pXAccessibleSelection->getSelectedAccessibleChildCount();
+    if (nChildCount > std::numeric_limits<long>::max())
+    {
+        SAL_WARN("iacc2", "CEnumVariant::Next: Child count exceeds maximum long value, "
+                          "using max long.");
+        nChildCount = std::numeric_limits<long>::max();
+    }
+
+    // Retrieve the next cElements.
+    sal_Int64 l1;
+    for (l1 = m_nCurrent, l2 = 0; l1 < nChildCount && l2 < cElements; l1++, l2++)
+    {
+        Reference< XAccessible > pRXAcc = m_pXAccessibleSelection->getSelectedAccessibleChild(l1);
+        IAccessible* pChild = CMAccessible::get_IAccessibleFromXAccessible(pRXAcc.get());
+        if(pChild)
+        {
+            pvar[l2].vt = VT_DISPATCH;
+            pvar[l2].pdispVal = pChild;
+            pChild->AddRef();
+        }
+        else if(pRXAcc.is())
+        {
+            if (CMAccessible::g_pAccObjectManager)
+                CMAccessible::g_pAccObjectManager->InsertAccObj(pRXAcc.get(),pUNOInterface);
+            pChild = CMAccessible::get_IAccessibleFromXAccessible(pRXAcc.get());
+            if(pChild)
+            {
+                pvar[l2].vt = VT_DISPATCH;
+                pvar[l2].pdispVal = pChild;
+                pChild->AddRef();
+            }
+        }
+    }
+    // Set count of elements retrieved.
+    if (pcElementFetched != nullptr)
+        *pcElementFetched = l2;
+    m_nCurrent = l1;
+
+    return (l2 < cElements) ? S_FALSE : NOERROR;
+}
+
+/**
+   * skip the elements in the given range when enumerate elements
+   * @param  cElements The number of elements to skip.
+   * @return Result.
+   */
+HRESULT STDMETHODCALLTYPE CEnumVariant::Skip(ULONG cElements)
+{
+    SolarMutexGuard g;
+
+    m_nCurrent += cElements;
+    sal_Int64 nChildCount = m_pXAccessibleSelection->getSelectedAccessibleChildCount();
+    if (nChildCount > std::numeric_limits<long>::max())
+    {
+        SAL_WARN("iacc2", "CEnumVariant::Skip: Child count exceeds maximum long value, "
+                          "using max long.");
+        nChildCount = std::numeric_limits<long>::max();
+    }
+    if (m_nCurrent > nChildCount)
+    {
+        m_nCurrent = nChildCount;
+        return E_FAIL;
+    }
+    else
+        return NOERROR;
+}
+
+
+/**
+   * reset the enumeration position to initial value
+   * @param
+   * @return Result.
+   */
+HRESULT STDMETHODCALLTYPE CEnumVariant::Reset()
+{
+    SolarMutexGuard g;
+
+    m_nCurrent = 0;
+    return NOERROR;
+}
+
+
+/**
+   *create a new IEnumVariant object,
+   *copy current enumeration container and its state to
+   *the new object
+   *AT will use the copy object to get elements
+   * @param ppenum On return, pointer to the location of the clone enumerator
+   * @return Result.
+   */
+HRESULT STDMETHODCALLTYPE CEnumVariant::Clone(IEnumVARIANT __RPC_FAR *__RPC_FAR *ppenum)
+{
+    SolarMutexGuard g;
+
+    CEnumVariant * penum = nullptr;
+    HRESULT hr;
+    if (ppenum == nullptr)
+        return E_INVALIDARG;
+
+    *ppenum = nullptr;
+
+    hr = Create(&penum);
+    if( hr == S_OK )
+    {
+        penum->PutSelection(reinterpret_cast<hyper>(pUNOInterface));
+        *ppenum = penum;
+    }
+    else
+    {
+        if (penum)
+            penum->Release();
+    }
+    return hr;
+}
+
+/**
+   *Static public method to create a CLSID_EnumVariant com object.
+   * @param ppenum Pointer to accept com object.
+   * @return Result.
+   */
+HRESULT STDMETHODCALLTYPE CEnumVariant::Create(CEnumVariant __RPC_FAR *__RPC_FAR *ppenum)
+{
+    SolarMutexGuard g;
+
+    HRESULT hr = createInstance<CEnumVariant>(IID_IEnumVariant, ppenum);
+    if (S_OK != hr)
+    {
+        return E_FAIL;
+    }
+
+    return S_OK;
+}
+
+/**
+   *Return count of elements in current container
+   * @param.
+   * @return count of elements in current container.
+   */
+long CEnumVariant::GetCountOfElements()
+{
+    if(m_pXAccessibleSelection.is())
+    {
+        sal_Int64 nCount = m_pXAccessibleSelection->getSelectedAccessibleChildCount();
+        if (nCount > std::numeric_limits<long>::max())
+        {
+            SAL_WARN("iacc2", "CEnumVariant::GetCountOfElements: Count exceeds maximum long value, "
+                              "using max long.");
+            nCount = std::numeric_limits<long>::max();
+        }
+        return nCount;
+    }
+    return 0;
+}
+
+/**
+   * Set member m_pXAccessibleSelection to NULL and m_nCurrent to 0.
+   * @param.
+   * @return Result
+   */
+COM_DECLSPEC_NOTHROW STDMETHODIMP CEnumVariant::ClearEnumeration()
+{
+    // internal IEnumVariant - no mutex meeded
+
+    pUNOInterface = nullptr;
+    m_pXAccessibleSelection = nullptr;
+    m_nCurrent = 0;
+    return S_OK;
+}
+
+/**
+   *Static method to fetch XAccessibleSelection
+   * @param pXAcc XAccessible interface.
+   * @return XAccessibleSelection interface.
+   */
+static Reference<XAccessibleSelection> GetXAccessibleSelection(XAccessible* pXAcc)
+{
+    if( pXAcc == nullptr)
+        return nullptr;
+
+    Reference< XAccessibleContext > pRContext = pXAcc->getAccessibleContext();
+    if( !pRContext.is() )
+        return nullptr;
+
+    Reference< XAccessibleSelection > pRSelection(pRContext,UNO_QUERY);
+    if( !pRSelection.is() )
+        return nullptr;
+
+    return pRSelection;
+}
+
+/**
+   * Put valid UNO XAccessible interface.
+   * @param pXSelection XAccessible interface.
+   * @return Result...
+   */
+STDMETHODIMP CEnumVariant::PutSelection(hyper pXSelection)
+{
+    // internal IEnumVariant - no mutex meeded
+
+    pUNOInterface = reinterpret_cast<XAccessible*>(pXSelection);
+    m_pXAccessibleSelection = GetXAccessibleSelection(pUNOInterface);
+    return S_OK;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */