LCOV - code coverage report
Current view: top level - accessible/xpcom - xpcAccessibleTextRange.cpp (source / functions) Hit Total Coverage
Test: output.info Lines: 0 87 0.0 %
Date: 2017-07-14 16:53:18 Functions: 0 27 0.0 %
Legend: Lines: hit not hit

          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 file,
       5             :  * You can obtain one at http://mozilla.org/MPL/2.0/. */
       6             : 
       7             : #include "xpcAccessibleTextRange.h"
       8             : 
       9             : #include "TextRange-inl.h"
      10             : #include "xpcAccessibleDocument.h"
      11             : 
      12             : #include "nsIMutableArray.h"
      13             : #include "nsComponentManagerUtils.h"
      14             : #include "nsQueryObject.h"
      15             : 
      16             : using namespace mozilla;
      17             : using namespace mozilla::a11y;
      18             : 
      19             : // nsISupports and cycle collection
      20             : 
      21           0 : NS_IMPL_CYCLE_COLLECTION(xpcAccessibleTextRange,
      22             :                          mRange.mRoot,
      23             :                          mRange.mStartContainer,
      24             :                          mRange.mEndContainer)
      25             : 
      26           0 : NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(xpcAccessibleTextRange)
      27           0 :   NS_INTERFACE_MAP_ENTRY(nsIAccessibleTextRange)
      28           0 :   NS_INTERFACE_MAP_ENTRY(xpcAccessibleTextRange)
      29           0 :   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIAccessibleTextRange)
      30           0 : NS_INTERFACE_MAP_END
      31             : 
      32           0 : NS_IMPL_CYCLE_COLLECTING_ADDREF(xpcAccessibleTextRange)
      33           0 : NS_IMPL_CYCLE_COLLECTING_RELEASE(xpcAccessibleTextRange)
      34             : 
      35             : // nsIAccessibleTextRange
      36             : 
      37             : NS_IMETHODIMP
      38           0 : xpcAccessibleTextRange::GetStartContainer(nsIAccessibleText** aAnchor)
      39             : {
      40           0 :   NS_ENSURE_ARG_POINTER(aAnchor);
      41           0 :   NS_IF_ADDREF(*aAnchor = ToXPCText(mRange.StartContainer()));
      42           0 :   return NS_OK;
      43             : }
      44             : 
      45             : NS_IMETHODIMP
      46           0 : xpcAccessibleTextRange::GetStartOffset(int32_t* aOffset)
      47             : {
      48           0 :   NS_ENSURE_ARG_POINTER(aOffset);
      49           0 :   *aOffset = mRange.StartOffset();
      50           0 :   return NS_OK;
      51             : }
      52             : 
      53             : NS_IMETHODIMP
      54           0 : xpcAccessibleTextRange::GetEndContainer(nsIAccessibleText** aAnchor)
      55             : {
      56           0 :   NS_ENSURE_ARG_POINTER(aAnchor);
      57           0 :   NS_IF_ADDREF(*aAnchor = ToXPCText(mRange.EndContainer()));
      58           0 :   return NS_OK;
      59             : }
      60             : 
      61             : NS_IMETHODIMP
      62           0 : xpcAccessibleTextRange::GetEndOffset(int32_t* aOffset)
      63             : {
      64           0 :   NS_ENSURE_ARG_POINTER(aOffset);
      65           0 :   *aOffset = mRange.EndOffset();
      66           0 :   return NS_OK;
      67             : }
      68             : 
      69             : NS_IMETHODIMP
      70           0 : xpcAccessibleTextRange::GetContainer(nsIAccessible** aContainer)
      71             : {
      72           0 :   NS_ENSURE_ARG_POINTER(aContainer);
      73           0 :   NS_IF_ADDREF(*aContainer = ToXPC(mRange.Container()));
      74           0 :   return NS_OK;
      75             : }
      76             : 
      77             : NS_IMETHODIMP
      78           0 : xpcAccessibleTextRange::GetEmbeddedChildren(nsIArray** aList)
      79             : {
      80           0 :   nsresult rv = NS_OK;
      81             :   nsCOMPtr<nsIMutableArray> xpcList =
      82           0 :     do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
      83           0 :   NS_ENSURE_SUCCESS(rv, rv);
      84             : 
      85           0 :   nsTArray<Accessible*> objects;
      86           0 :   mRange.EmbeddedChildren(&objects);
      87             : 
      88           0 :   uint32_t len = objects.Length();
      89           0 :   for (uint32_t idx = 0; idx < len; idx++)
      90           0 :     xpcList->AppendElement(static_cast<nsIAccessible*>(ToXPC(objects[idx])), false);
      91             : 
      92           0 :   xpcList.forget(aList);
      93             : 
      94           0 :   return NS_OK;
      95             : }
      96             : 
      97             : NS_IMETHODIMP
      98           0 : xpcAccessibleTextRange::Compare(nsIAccessibleTextRange* aOtherRange,
      99             :                                 bool* aResult)
     100             : {
     101             : 
     102           0 :   RefPtr<xpcAccessibleTextRange> xpcRange(do_QueryObject(aOtherRange));
     103           0 :   if (!xpcRange || !aResult)
     104           0 :     return NS_ERROR_INVALID_ARG;
     105             : 
     106           0 :   *aResult = (mRange == xpcRange->mRange);
     107           0 :   return NS_OK;
     108             : }
     109             : 
     110             : NS_IMETHODIMP
     111           0 : xpcAccessibleTextRange::CompareEndPoints(uint32_t aEndPoint,
     112             :                                          nsIAccessibleTextRange* aOtherRange,
     113             :                                          uint32_t aOtherRangeEndPoint,
     114             :                                          int32_t* aResult)
     115             : {
     116           0 :   RefPtr<xpcAccessibleTextRange> xpcRange(do_QueryObject(aOtherRange));
     117           0 :   if (!xpcRange || !aResult)
     118           0 :     return NS_ERROR_INVALID_ARG;
     119             : 
     120             :   TextPoint p = (aEndPoint == EndPoint_Start) ?
     121           0 :     mRange.StartPoint() : mRange.EndPoint();
     122             :   TextPoint otherPoint = (aOtherRangeEndPoint == EndPoint_Start) ?
     123           0 :     xpcRange->mRange.StartPoint() : xpcRange->mRange.EndPoint();
     124             : 
     125           0 :   if (p == otherPoint)
     126           0 :     *aResult = 0;
     127             :   else
     128           0 :     *aResult = p < otherPoint ? -1 : 1;
     129             : 
     130           0 :   return NS_OK;
     131             : }
     132             : 
     133             : NS_IMETHODIMP
     134           0 : xpcAccessibleTextRange::GetText(nsAString& aText)
     135             : {
     136           0 :   nsAutoString text;
     137           0 :   mRange.Text(text);
     138           0 :   aText.Assign(text);
     139             : 
     140           0 :   return NS_OK;
     141             : }
     142             : 
     143             : NS_IMETHODIMP
     144           0 : xpcAccessibleTextRange::GetBounds(nsIArray** aRectList)
     145             : {
     146           0 :   return NS_OK;
     147             : }
     148             : 
     149             : NS_IMETHODIMP
     150           0 : xpcAccessibleTextRange::Move(uint32_t aUnit, int32_t aCount)
     151             : {
     152           0 :   return NS_OK;
     153             : }
     154             : 
     155             : NS_IMETHODIMP
     156           0 : xpcAccessibleTextRange::MoveStart(uint32_t aUnit, int32_t aCount)
     157             : {
     158           0 :   return NS_OK;
     159             : }
     160             : 
     161             : NS_IMETHODIMP
     162           0 : xpcAccessibleTextRange::MoveEnd(uint32_t aUnit, int32_t aCount)
     163             : {
     164           0 :   return NS_OK;
     165             : }
     166             : 
     167             : NS_IMETHODIMP
     168           0 : xpcAccessibleTextRange::Normalize(uint32_t aUnit)
     169             : {
     170           0 :   return NS_OK;
     171             : }
     172             : 
     173             : NS_IMETHODIMP
     174           0 : xpcAccessibleTextRange::Crop(nsIAccessible* aContainer, bool* aSuccess)
     175             : {
     176           0 :   Accessible* container = aContainer->ToInternalAccessible();
     177           0 :   NS_ENSURE_TRUE(container, NS_ERROR_INVALID_ARG);
     178             : 
     179           0 :   *aSuccess = mRange.Crop(container);
     180           0 :   return NS_OK;
     181             : }
     182             : 
     183             : NS_IMETHODIMP
     184           0 : xpcAccessibleTextRange::FindText(const nsAString& aText, bool aIsBackward,
     185             :                                  bool aIsIgnoreCase,
     186             :                                  nsIAccessibleTextRange** aRange)
     187             : {
     188           0 :   return NS_OK;
     189             : }
     190             : 
     191             : NS_IMETHODIMP
     192           0 : xpcAccessibleTextRange::FindAttr(uint32_t aAttr, nsIVariant* aVal,
     193             :                                  bool aIsBackward,
     194             :                                  nsIAccessibleTextRange** aRange)
     195             : {
     196           0 :   return NS_OK;
     197             : }
     198             : 
     199             : NS_IMETHODIMP
     200           0 : xpcAccessibleTextRange::AddToSelection()
     201             : {
     202           0 :   return NS_OK;
     203             : }
     204             : 
     205             : NS_IMETHODIMP
     206           0 : xpcAccessibleTextRange::RemoveFromSelection()
     207             : {
     208           0 :   return NS_OK;
     209             : }
     210             : 
     211             : NS_IMETHODIMP
     212           0 : xpcAccessibleTextRange::Select()
     213             : {
     214           0 :   return NS_OK;
     215             : }
     216             : 
     217             : NS_IMETHODIMP
     218           0 : xpcAccessibleTextRange::ScrollIntoView(uint32_t aHow)
     219             : {
     220           0 :   return NS_OK;
     221             : }

Generated by: LCOV version 1.13