Back to index

lightning-sunbird  0.9+nobinonly
Public Member Functions | Public Attributes | Static Public Attributes | Protected Member Functions | Static Protected Member Functions | Protected Attributes | Friends
nsAccessibleText Class Reference

#include <nsAccessibleText.h>

Inheritance diagram for nsAccessibleText:
Inheritance graph
[legend]
Collaboration diagram for nsAccessibleText:
Collaboration graph
[legend]

List of all members.

Public Member Functions

NS_DECL_ISUPPORTS
NS_DECL_NSIACCESSIBLETEXT 
nsAccessibleText (nsIDOMNode *aNode)
 nsAccessibleText implements the nsIAccessibleText interface for static text which mTextNode has nsITextContent interface
virtual ~nsAccessibleText ()
AString getText (in long startOffset, in long endOffset)
 String methods may need to return multibyte-encoded strings, since some locales can't be encoded using 16-bit chars.
AString getTextAfterOffset (in long offset, in nsAccessibleTextBoundary boundaryType, out long startOffset, out long endOffset)
AString getTextAtOffset (in long offset, in nsAccessibleTextBoundary boundaryType, out long startOffset, out long endOffset)
AString getTextBeforeOffset (in long offset, in nsAccessibleTextBoundary boundaryType, out long startOffset, out long endOffset)
wchar getCharacterAtOffset (in long offset)
 It would be better to return an unsigned long here, to allow unicode chars > 16 bits.
nsISupports getAttributeRange (in long offset, out long rangeStartOffset, out long rangeEndOffset)
void getCharacterExtents (in long offset, out long x, out long y, out long width, out long height, in nsAccessibleCoordType coordType)
long getOffsetAtPoint (in long x, in long y, in nsAccessibleCoordType coordType)
void getSelectionBounds (in long selectionNum, out long startOffset, out long endOffset)
void setSelectionBounds (in long selectionNum, in long startOffset, in long endOffset)
void addSelection (in long startOffset, in long endOffset)
void removeSelection (in long selectionNum)

Public Attributes

const nsAccessibleTextBoundary BOUNDARY_CHAR = 0
const nsAccessibleTextBoundary BOUNDARY_WORD_START = 1
const nsAccessibleTextBoundary BOUNDARY_WORD_END = 2
const nsAccessibleTextBoundary BOUNDARY_SENTENCE_START = 3
const nsAccessibleTextBoundary BOUNDARY_SENTENCE_END = 4
const nsAccessibleTextBoundary BOUNDARY_LINE_START = 5
const nsAccessibleTextBoundary BOUNDARY_LINE_END = 6
const nsAccessibleTextBoundary BOUNDARY_ATTRIBUTE_RANGE = 7
const nsAccessibleCoordType COORD_TYPE_SCREEN = 0
const nsAccessibleCoordType COORD_TYPE_WINDOW = 1
attribute long caretOffset
readonly attribute long characterCount
readonly attribute long selectionCount

Static Public Attributes

static PRBool gSuppressedNotifySelectionChanged = PR_FALSE

Protected Member Functions

virtual nsresult GetSelections (nsISelectionController **aSelCon, nsISelection **aDomSel)
 nsIAccessibleText helpers
nsresult GetTextHelperCore (EGetTextType aType, nsAccessibleTextBoundary aBoundaryType, PRInt32 aOffset, PRInt32 *aStartOffset, PRInt32 *aEndOffset, nsISelectionController *aSelCon, nsISelection *aDomSel, nsISupports *aClosure, nsAString &aText)
nsresult GetTextHelper (EGetTextType aType, nsAccessibleTextBoundary aBoundaryType, PRInt32 aOffset, PRInt32 *aStartOffset, PRInt32 *aEndOffset, nsISupports *aClosure, nsAString &aText)

Static Protected Member Functions

static nsresult DOMPointToOffset (nsISupports *aClosure, nsIDOMNode *aNode, PRInt32 aNodeOffset, PRInt32 *aResult)
static nsresult OffsetToDOMPoint (nsISupports *aClosure, PRInt32 aOffset, nsIDOMNode **aResult, PRInt32 *aPosition)
static nsresult GetCurrentOffset (nsISupports *aClosure, nsISelection *aDomSel, PRInt32 *aOffset)

Protected Attributes

nsCOMPtr< nsIDOMNodemTextNode

Friends

class nsAccessibleHyperText

Detailed Description

Definition at line 56 of file nsAccessibleText.h.


Constructor & Destructor Documentation

nsAccessibleText implements the nsIAccessibleText interface for static text which mTextNode has nsITextContent interface

Definition at line 82 of file nsAccessibleText.cpp.

{
  mTextNode = aNode;
}
virtual nsAccessibleText::~nsAccessibleText ( ) [inline, virtual]

Definition at line 63 of file nsAccessibleText.h.

{};

Member Function Documentation

void nsIAccessibleText::addSelection ( in long  startOffset,
in long  endOffset 
) [inherited]
nsresult nsAccessibleText::DOMPointToOffset ( nsISupports *  aClosure,
nsIDOMNode aNode,
PRInt32  aNodeOffset,
PRInt32 aResult 
) [static, protected]

Definition at line 133 of file nsAccessibleText.cpp.

{
  NS_ENSURE_ARG_POINTER(aNode && aResult);

  *aResult = aNodeOffset;

  nsCOMPtr<nsIArray> domNodeArray(do_QueryInterface(aClosure));
  if (domNodeArray) {
    // Static text, calculate the offset from a given set of (text) node
    PRUint32 textLength, totalLength = 0;
    PRUint32 index, count;
    domNodeArray->GetLength(&count);
    for (index = 0; index < count; index++) {
      nsCOMPtr<nsIDOMNode> domNode(do_QueryElementAt(domNodeArray, index));
      if (aNode == domNode) {
        *aResult = aNodeOffset + totalLength;
        break;
      }
      nsCOMPtr<nsIDOMText> domText(do_QueryInterface(domNode));
      if (domText) {
        domText->GetLength(&textLength);
        totalLength += textLength;
      }
    }

    return NS_OK;
  }

  nsCOMPtr<nsIEditor> editor(do_QueryInterface(aClosure));
  if (editor) { // revised according to nsTextControlFrame::DOMPointToOffset
    // Editable text, calculate the offset from the editor
    nsCOMPtr<nsIDOMElement> rootElement;
    editor->GetRootElement(getter_AddRefs(rootElement));
    nsCOMPtr<nsIDOMNode> rootNode(do_QueryInterface(rootElement));

    NS_ENSURE_TRUE(rootNode, NS_ERROR_FAILURE);

    nsCOMPtr<nsIDOMNodeList> nodeList;

    nsresult rv = rootNode->GetChildNodes(getter_AddRefs(nodeList));
    NS_ENSURE_SUCCESS(rv, rv);
    NS_ENSURE_TRUE(nodeList, NS_ERROR_FAILURE);

    PRUint32 length = 0;
    rv = nodeList->GetLength(&length);
    NS_ENSURE_SUCCESS(rv, rv);

    if (!length || aNodeOffset < 0)
      return NS_OK;

    PRInt32 i, textOffset = 0;
    PRInt32 lastIndex = (PRInt32)length - 1;

    for (i = 0; i < (PRInt32)length; i++) {
      if (rootNode == aNode && i == aNodeOffset) {
        *aResult = textOffset;
        return NS_OK;
      }

      nsCOMPtr<nsIDOMNode> item;
      rv = nodeList->Item(i, getter_AddRefs(item));
      NS_ENSURE_SUCCESS(rv, rv);
      NS_ENSURE_TRUE(item, NS_ERROR_FAILURE);

      if (item == aNode) {
        *aResult = textOffset + aNodeOffset;
        return NS_OK;
      }

      nsCOMPtr<nsIDOMText> domText(do_QueryInterface(item));

      if (domText) {
        PRUint32 textLength = 0;

        rv = domText->GetLength(&textLength);
        NS_ENSURE_SUCCESS(rv, rv);

        textOffset += textLength;
      }
      else {
        // Must be a BR node. If it's not the last BR node
        // under the root, count it as a newline.
        if (i != lastIndex)
          ++textOffset;
      }
    }

    NS_ASSERTION((aNode == rootNode && aNodeOffset == (PRInt32)length),
                 "Invalid node offset!");

    *aResult = textOffset;
  }

  return NS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nsISupports nsIAccessibleText::getAttributeRange ( in long  offset,
out long  rangeStartOffset,
out long  rangeEndOffset 
) [inherited]
wchar nsIAccessibleText::getCharacterAtOffset ( in long  offset) [inherited]

It would be better to return an unsigned long here, to allow unicode chars > 16 bits.

void nsIAccessibleText::getCharacterExtents ( in long  offset,
out long  x,
out long  y,
out long  width,
out long  height,
in nsAccessibleCoordType  coordType 
) [inherited]
nsresult nsAccessibleText::GetCurrentOffset ( nsISupports *  aClosure,
nsISelection aDomSel,
PRInt32 aOffset 
) [static, protected]

Definition at line 321 of file nsAccessibleText.cpp.

{
  nsCOMPtr<nsIDOMNode> focusNode;
  aDomSel->GetFocusNode(getter_AddRefs(focusNode));
  aDomSel->GetFocusOffset(aOffset);
  return DOMPointToOffset(aClosure, focusNode, *aOffset, aOffset);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void nsIAccessibleText::getSelectionBounds ( in long  selectionNum,
out long  startOffset,
out long  endOffset 
) [inherited]
nsresult nsAccessibleText::GetSelections ( nsISelectionController **  aSelCon,
nsISelection **  aDomSel 
) [protected, virtual]

nsIAccessibleText helpers

Reimplemented in nsAccessibleEditableText.

Definition at line 90 of file nsAccessibleText.cpp.

{
  nsCOMPtr<nsIDOMDocument> domDoc;
  mTextNode->GetOwnerDocument(getter_AddRefs(domDoc));
  nsCOMPtr<nsIDocument> doc(do_QueryInterface(domDoc));
  NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);

  nsIPresShell *shell = doc->GetShellAt(0);
  NS_ENSURE_TRUE(shell, NS_ERROR_FAILURE);

  nsCOMPtr<nsIContent> content(do_QueryInterface(mTextNode));
  nsIFrame *frame = nsnull;
  shell->GetPrimaryFrameFor(content, &frame);
  NS_ENSURE_TRUE(frame, NS_ERROR_FAILURE);

  // Get the selection and selection controller
  nsCOMPtr<nsISelectionController> selCon;
  nsCOMPtr<nsISelection> domSel;
  frame->GetSelectionController(shell->GetPresContext(),
                                getter_AddRefs(selCon));
  if (selCon)
    selCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(domSel));

  NS_ENSURE_TRUE(selCon && domSel, NS_ERROR_FAILURE);

  PRBool isSelectionCollapsed;
  domSel->GetIsCollapsed(&isSelectionCollapsed);
  // Don't perform any actions when the selection is not collapsed
  NS_ENSURE_TRUE(isSelectionCollapsed, NS_ERROR_FAILURE);

  if (aSelCon) {
    *aSelCon = selCon;
    NS_ADDREF(*aSelCon);
  }

  if (aDomSel) {
    *aDomSel = domSel;
    NS_ADDREF(*aDomSel);
  }

  return NS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

AString nsIAccessibleText::getText ( in long  startOffset,
in long  endOffset 
) [inherited]

String methods may need to return multibyte-encoded strings, since some locales can't be encoded using 16-bit chars.

So the methods below might return UTF-16 strings, or they could return "string" values which are UTF-8.

AString nsIAccessibleText::getTextAfterOffset ( in long  offset,
in nsAccessibleTextBoundary  boundaryType,
out long  startOffset,
out long  endOffset 
) [inherited]
AString nsIAccessibleText::getTextAtOffset ( in long  offset,
in nsAccessibleTextBoundary  boundaryType,
out long  startOffset,
out long  endOffset 
) [inherited]
AString nsIAccessibleText::getTextBeforeOffset ( in long  offset,
in nsAccessibleTextBoundary  boundaryType,
out long  startOffset,
out long  endOffset 
) [inherited]
nsresult nsAccessibleText::GetTextHelper ( EGetTextType  aType,
nsAccessibleTextBoundary  aBoundaryType,
PRInt32  aOffset,
PRInt32 aStartOffset,
PRInt32 aEndOffset,
nsISupports *  aClosure,
nsAString &  aText 
) [protected]

Definition at line 522 of file nsAccessibleText.cpp.

{
  NS_ENSURE_TRUE((aOffset >= 0), NS_ERROR_INVALID_ARG);
  
  nsCOMPtr<nsISelectionController> selCon;
  nsCOMPtr<nsISelection> domSel;

  nsresult rv = GetSelections(getter_AddRefs(selCon), getter_AddRefs(domSel));
  NS_ENSURE_SUCCESS(rv, rv);

  //backup old settings
  PRInt16 displaySelection;
  selCon->GetDisplaySelection(&displaySelection);
  PRBool caretEnable;
  selCon->GetCaretEnabled(&caretEnable);

  //turn off display and caret
  selCon->SetDisplaySelection(nsISelectionController::SELECTION_HIDDEN);
  selCon->SetCaretEnabled(PR_FALSE);

  //turn off nsCaretAccessible::NotifySelectionChanged
  gSuppressedNotifySelectionChanged = PR_TRUE;

  PRInt32 caretOffset = -1;
  if (NS_SUCCEEDED(GetCaretOffset(&caretOffset))) {
    if (caretOffset != aOffset)
      SetCaretOffset(aOffset);
  }

  *aStartOffset = *aEndOffset = aOffset;
  rv = GetTextHelperCore(aType, aBoundaryType, aOffset, aStartOffset, aEndOffset, selCon, domSel, aClosure, aText);

  //restore caret offset
  if (caretOffset >= 0) {
    SetCaretOffset(caretOffset);
  }

  //turn on nsCaretAccessible::NotifySelectionChanged
  gSuppressedNotifySelectionChanged = PR_FALSE;

  //restore old settings
  selCon->SetDisplaySelection(displaySelection);
  selCon->SetCaretEnabled(caretEnable);

  return rv;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nsresult nsAccessibleText::GetTextHelperCore ( EGetTextType  aType,
nsAccessibleTextBoundary  aBoundaryType,
PRInt32  aOffset,
PRInt32 aStartOffset,
PRInt32 aEndOffset,
nsISelectionController aSelCon,
nsISelection aDomSel,
nsISupports *  aClosure,
nsAString &  aText 
) [protected]

Definition at line 355 of file nsAccessibleText.cpp.

{
  PRInt32 rangeCount;
  nsCOMPtr<nsIDOMRange> range, oldRange;
  aDomSel->GetRangeCount(&rangeCount);

  if (rangeCount == 0) { // ever happen?
    SetCaretOffset(aOffset); // a new range will be added here
    rangeCount++;
  }
  aDomSel->GetRangeAt(rangeCount - 1, getter_AddRefs(range));
  NS_ENSURE_TRUE(range, NS_ERROR_FAILURE);

  // backup the original selection range to restore the selection status later
  range->CloneRange(getter_AddRefs(oldRange));

  // Step1: move caret to an appropriate start position
  // Step2: move caret to end postion and select the text
  PRBool isStep1Forward, isStep2Forward;  // Moving directions for two steps
  switch (aType)
  {
  case eGetBefore:
    isStep1Forward = PR_FALSE;
    isStep2Forward = PR_FALSE;
    break;
  case eGetAt:
    isStep1Forward = PR_FALSE;
    isStep2Forward = PR_TRUE;
    break;
  case eGetAfter:
    isStep1Forward = PR_TRUE;
    isStep2Forward = PR_TRUE;
    break;
  default:
    return NS_ERROR_INVALID_ARG;
  }

  // The start/end focus node may be not our mTextNode
  nsCOMPtr<nsIDOMNode> startFocusNode, endFocusNode;
  switch (aBoundaryType)
  {
  case BOUNDARY_CHAR:
    if (aType == eGetAfter) { // We need the character next to current position
      aSelCon->CharacterMove(isStep1Forward, PR_FALSE);
      GetCurrentOffset(aClosure, aDomSel, aStartOffset);
    }
    aSelCon->CharacterMove(isStep2Forward, PR_TRUE);
    GetCurrentOffset(aClosure, aDomSel, aEndOffset);
    break;
  case BOUNDARY_WORD_START:
    {
    PRBool dontMove = PR_FALSE;
    // If we are at the word boundary, don't move the caret in the first step
    if (aOffset == 0)
      dontMove = PR_TRUE;
    else {
      PRUnichar prevChar;
      GetCharacterAtOffset(aOffset - 1, &prevChar);
      if (prevChar == ' ' || prevChar == '\t' || prevChar == '\n')
        dontMove = PR_TRUE;
    }
    if (!dontMove) {
      aSelCon->WordMove(isStep1Forward, PR_FALSE); // Move caret to previous/next word start boundary
      GetCurrentOffset(aClosure, aDomSel, aStartOffset);
    }
    aSelCon->WordMove(isStep2Forward, PR_TRUE);  // Select previous/next word
    GetCurrentOffset(aClosure, aDomSel, aEndOffset);
    }
    break;
  case BOUNDARY_LINE_START:
    if (aType != eGetAt) {
      // XXX, don't support yet
      return NS_ERROR_NOT_IMPLEMENTED;
    }
    aSelCon->IntraLineMove(PR_FALSE, PR_FALSE);  // Move caret to the line start
    GetCurrentOffset(aClosure, aDomSel, aStartOffset);
    aSelCon->IntraLineMove(PR_TRUE, PR_TRUE);    // Move caret to the line end and select the whole line
    GetCurrentOffset(aClosure, aDomSel, aEndOffset);
    break;
  case BOUNDARY_WORD_END:
    {
    // please refer to atk implementation (atktext.c)
    // for specification of ATK_TEXT_BOUNDARY_WORD_END when before/at/after offset
    // XXX, need to follow exact definition of ATK_TEXT_BOUNDARY_WORD_END

    if (aType != eGetAt) {
      // XXX, don't support yet
      return NS_ERROR_NOT_IMPLEMENTED;
    }

    // Example of current code: _AB_CD_E_ ("_" is space)
    // offset      return string   startOffset endOffset
    //      0      AB_             1           4
    //      1      AB_             1           4
    //      2      AB_             1           4
    //      3      AB_             1           4
    //      4      CD_             4           7
    //      5      CD_             4           7
    //      6      CD_             4           7
    //      7      E_              7           9
    //      8      E_              7           9

    PRUnichar offsetChar;
    nsresult rv = GetCharacterAtOffset(aOffset, &offsetChar);
    NS_ENSURE_SUCCESS(rv, rv);
    PRBool isOffsetEmpty =  offsetChar == ' ' || offsetChar == '\t' || offsetChar == '\n';

    PRInt32 stepBackwardCount = 0; // Times of move backward to find the word(e.g. "AB_") start boundary
    if (aOffset == 0) {
      if (isOffsetEmpty)
        aSelCon->WordMove(PR_TRUE, PR_FALSE); // Move caret to the first word start boundary
    }
    else {
      PRUnichar prevChar;
      GetCharacterAtOffset(aOffset - 1, &prevChar);
      PRBool isPrevEmpty =  prevChar == ' ' || prevChar == '\t' || prevChar == '\n';
      if (!isPrevEmpty)
        stepBackwardCount = 1;
      else if (isOffsetEmpty)
        stepBackwardCount = 2;
      else
        stepBackwardCount = 0;

      PRInt32 step;
      for (step = 0; step < stepBackwardCount; step++)
        aSelCon->WordMove(PR_FALSE, PR_FALSE); // Move caret to current word start boundary
    }

    GetCurrentOffset(aClosure, aDomSel, aStartOffset);
    // Move twice to select a "word"
    aSelCon->WordMove(PR_TRUE, PR_TRUE);
    aSelCon->WordMove(PR_TRUE, PR_TRUE);
    GetCurrentOffset(aClosure, aDomSel, aEndOffset);
    }
    break;
  case BOUNDARY_LINE_END:
  case BOUNDARY_SENTENCE_START:
  case BOUNDARY_SENTENCE_END:
  case BOUNDARY_ATTRIBUTE_RANGE:
    return NS_ERROR_NOT_IMPLEMENTED;
  default:
    return NS_ERROR_INVALID_ARG;
  }

  nsXPIDLString text;
  // Get text from selection
  nsresult rv = aDomSel->ToString(getter_Copies(text));
  aDomSel->RemoveAllRanges();
  // restore the original selection range
  aDomSel->AddRange(oldRange);
  NS_ENSURE_SUCCESS(rv, rv);

  aText = text;

  // Ensure aStartOffset <= aEndOffset
  if (*aStartOffset > *aEndOffset) {
    PRInt32 tmp = *aStartOffset;
    *aStartOffset = *aEndOffset;
    *aEndOffset = tmp;
  }

  return NS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nsresult nsAccessibleText::OffsetToDOMPoint ( nsISupports *  aClosure,
PRInt32  aOffset,
nsIDOMNode **  aResult,
PRInt32 aPosition 
) [static, protected]

Definition at line 229 of file nsAccessibleText.cpp.

{
  NS_ENSURE_ARG_POINTER(aResult && aPosition);

  *aResult = nsnull;
  *aPosition = 0;

  nsCOMPtr<nsIEditor> editor(do_QueryInterface(aClosure));
  if (editor) { // revised according to nsTextControlFrame::OffsetToDOMPoint
    nsCOMPtr<nsIDOMElement> rootElement;
    editor->GetRootElement(getter_AddRefs(rootElement));
    nsCOMPtr<nsIDOMNode> rootNode(do_QueryInterface(rootElement));

    NS_ENSURE_TRUE(rootNode, NS_ERROR_FAILURE);

    nsCOMPtr<nsIDOMNodeList> nodeList;

    nsresult rv = rootNode->GetChildNodes(getter_AddRefs(nodeList));
    NS_ENSURE_SUCCESS(rv, rv);
    NS_ENSURE_TRUE(nodeList, NS_ERROR_FAILURE);

    PRUint32 length = 0;

    rv = nodeList->GetLength(&length);
    NS_ENSURE_SUCCESS(rv, rv);

    if (!length || aOffset < 0) {
      *aPosition = 0;
      *aResult = rootNode;
      NS_ADDREF(*aResult);
      return NS_OK;
    }

    PRInt32 textOffset = 0;
    PRUint32 lastIndex = length - 1;

    for (PRUint32 i=0; i<length; i++) {
      nsCOMPtr<nsIDOMNode> item;
      rv = nodeList->Item(i, getter_AddRefs(item));
      NS_ENSURE_SUCCESS(rv, rv);
      NS_ENSURE_TRUE(item, NS_ERROR_FAILURE);

      nsCOMPtr<nsIDOMText> domText(do_QueryInterface(item));

      if (domText) {
        PRUint32 textLength = 0;

        rv = domText->GetLength(&textLength);
        NS_ENSURE_SUCCESS(rv, rv);

        // Check if aOffset falls within this range.
        if (aOffset >= textOffset && aOffset <= textOffset+(PRInt32)textLength) {
          *aPosition = aOffset - textOffset;
          *aResult = item;
          NS_ADDREF(*aResult);
          return NS_OK;
        }

        textOffset += textLength;

        // If there aren't any more siblings after this text node,
        // return the point at the end of this text node!

        if (i == lastIndex) {
          *aPosition = textLength;
          *aResult = item;
          NS_ADDREF(*aResult);
          return NS_OK;
        }
      }
      else {
        // Must be a BR node, count it as a newline.

        if (aOffset == textOffset || i == lastIndex) {
          // We've found the correct position, or aOffset takes us
          // beyond the last child under rootNode, just return the point
          // under rootNode that is in front of this br.

          *aPosition = i;
          *aResult = rootNode;
          NS_ADDREF(*aResult);
          return NS_OK;
        }

        ++textOffset;
      }
    }
  }

  return NS_ERROR_FAILURE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void nsIAccessibleText::removeSelection ( in long  selectionNum) [inherited]
void nsIAccessibleText::setSelectionBounds ( in long  selectionNum,
in long  startOffset,
in long  endOffset 
) [inherited]

Friends And Related Function Documentation

friend class nsAccessibleHyperText [friend]

Definition at line 83 of file nsAccessibleText.h.


Member Data Documentation

Definition at line 57 of file nsIAccessibleText.idl.

Definition at line 50 of file nsIAccessibleText.idl.

Definition at line 56 of file nsIAccessibleText.idl.

Definition at line 55 of file nsIAccessibleText.idl.

Definition at line 54 of file nsIAccessibleText.idl.

Definition at line 53 of file nsIAccessibleText.idl.

Definition at line 52 of file nsIAccessibleText.idl.

Definition at line 51 of file nsIAccessibleText.idl.

Definition at line 62 of file nsIAccessibleText.idl.

Definition at line 64 of file nsIAccessibleText.idl.

Definition at line 59 of file nsIAccessibleText.idl.

Definition at line 60 of file nsIAccessibleText.idl.

Definition at line 63 of file nsAccessibleText.h.

Definition at line 68 of file nsAccessibleText.h.

Definition at line 65 of file nsIAccessibleText.idl.


The documentation for this class was generated from the following files: