/**************************************************************
*
* 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
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
import com.sun.star.accessibility.AccessibleTextType;
import com.sun.star.accessibility.TextSegment;
import com.sun.star.accessibility.XAccessibleContext;
import com.sun.star.accessibility.XAccessibleText;
import com.sun.star.accessibility.XAccessibleEditableText;
import com.sun.star.awt.Rectangle;
import com.sun.star.awt.Point;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.lang.IndexOutOfBoundsException;
import com.sun.star.beans.PropertyValue;
import java.util.Vector;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Graphics;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import javax.swing.JDialog;
import javax.swing.JButton;
import javax.swing.JPanel;
import javax.swing.JLabel;
import javax.swing.Icon;
import javax.swing.JTextArea;
import javax.swing.JOptionPane;
import javax.swing.JCheckBox;
import javax.swing.JColorChooser;
import javax.swing.BoxLayout;
import javax.swing.text.JTextComponent;
class AccessibleTextHandler extends NodeHandler
{
public NodeHandler createHandler (XAccessibleContext xContext)
{
XAccessibleText xText = (XAccessibleText) UnoRuntime.queryInterface (
XAccessibleText.class, xContext);
if (xText != null)
return new AccessibleTextHandler (xText);
else
return null;
}
public AccessibleTextHandler ()
{
}
public AccessibleTextHandler (XAccessibleText xText)
{
if (xText != null)
maChildList.setSize (8);
}
public AccessibleTreeNode createChild (AccessibleTreeNode aParent, int nIndex)
{
AccessibleTreeNode aChild = null;
XAccessibleText xText = null;
if (aParent instanceof AccTreeNode)
xText = ((AccTreeNode)aParent).getText();
try
{
if( xText != null )
{
switch( nIndex )
{
case 0:
aChild = new StringNode (xText.getText(), aParent);
break;
case 1:
aChild = new StringNode ("# chars: " + xText.getCharacterCount(), aParent);
break;
case 2:
aChild = new StringNode (characters( xText ), aParent);
break;
case 3:
aChild = new StringNode ("selection: "
+ "[" + xText.getSelectionStart()
+ "," + xText.getSelectionEnd()
+ "] \"" + xText.getSelectedText() + "\"",
aParent);
break;
case 4:
aChild = new StringNode ("getCaretPosition: " + xText.getCaretPosition(), aParent);
break;
case 5:
{
VectorNode aVec = new VectorNode("portions", aParent);
aChild = aVec;
aVec.addChild(
textAtIndexNode( xText, "Character",
AccessibleTextType.CHARACTER,
aParent ) );
aVec.addChild(
textAtIndexNode( xText, "Word",
AccessibleTextType.WORD,
aParent ) );
aVec.addChild(
textAtIndexNode( xText, "Sentence",
AccessibleTextType.SENTENCE,
aParent ) );
aVec.addChild(
textAtIndexNode( xText, "Paragraph",
AccessibleTextType.PARAGRAPH,
aParent ) );
aVec.addChild(
textAtIndexNode( xText, "Line",
AccessibleTextType.LINE,
aParent ) );
aVec.addChild(
textAtIndexNode( xText, "Attribute",
AccessibleTextType.ATTRIBUTE_RUN,
aParent ) );
aVec.addChild(
textAtIndexNode( xText, "Glyph",
AccessibleTextType.GLYPH,
aParent ) );
}
break;
case 6:
aChild = new StringNode (bounds( xText ), aParent);
break;
case 7:
aChild = getAttributes( xText, aParent );
break;
default:
aChild = new StringNode ("unknown child index " + nIndex, aParent);
}
}
}
catch (Exception e)
{
// Return empty child.
}
return aChild;
}
private String textAtIndexNodeString(
int nStart, int nEnd,
String sWord, String sBefore, String sBehind)
{
return "[" + nStart + "," + nEnd + "] "
+ "\"" + sWord + "\" \t"
+ "(" + sBefore + ","
+ "" + sBehind + ")";
}
/** Create a text node that lists all strings of a particular text type
*/
private AccessibleTreeNode textAtIndexNode(
XAccessibleText xText,
String sName,
short nTextType,
AccessibleTreeNode aParent)
{
VectorNode aNode = new VectorNode (sName, aParent);
// get word at all positions;
// for nicer display, compare current word to previous one and
// make a new node for every interval, not for every word
int nLength = xText.getCharacterCount();
if( nLength > 0 )
{
try
{
// sWord + nStart mark the current word
// make a node as soon as a new one is found; close the last
// one at the end
TextSegment sWord = xText.getTextAtIndex(0, nTextType);
TextSegment sBefore = xText.getTextBeforeIndex(0, nTextType);
TextSegment sBehind = xText.getTextBehindIndex(0, nTextType);
int nStart = 0;
for(int i = 1; i < nLength; i++)
{
TextSegment sTmp = xText.getTextAtIndex(i, nTextType);
TextSegment sTBef = xText.getTextBeforeIndex(i, nTextType);
TextSegment sTBeh = xText.getTextBehindIndex(i, nTextType);
if( ! ( sTmp.equals( sWord ) && sTBef.equals( sBefore ) &&
sTBeh.equals( sBehind ) ) )
{
aNode.addChild (new StringNode (textAtIndexNodeString(
nStart, i,
sWord.SegmentText, sBefore.SegmentText, sBehind.SegmentText), aNode));
sWord = sTmp;
sBefore = sTBef;
sBehind = sTBeh;
nStart = i;
}
// don't generate more than 50 children.
if (aNode.getChildCount() > 50)
{
sWord.SegmentText = "...";
break;
}
}
aNode.addChild (new StringNode (textAtIndexNodeString(
nStart, nLength,
sWord.SegmentText, sBefore.SegmentText, sBehind.SegmentText), aNode));
}
catch( IndexOutOfBoundsException e )
{
aNode.addChild (new StringNode (e.toString(), aNode));
}
catch (com.sun.star.lang.IllegalArgumentException e)
{
aNode.addChild (new StringNode (e.toString(), aNode));
}
}
return aNode;
}
/** getCharacter (display as array string) */
private String characters(XAccessibleText xText)
{
// get count (max. 30)
int nChars = xText.getCharacterCount();
if( nChars > 30 )
nChars = 30;
// build up string
StringBuffer aChars = new StringBuffer();
try
{
aChars.append( "[" );
for( int i = 0; i < nChars; i++)
{
aChars.append( xText.getCharacter(i) );
aChars.append( "," );
}
if( nChars > 0)
{
if( nChars == xText.getCharacterCount() )
aChars.deleteCharAt( aChars.length() - 1 );
else
aChars.append( "..." );
}
aChars.append( "]" );
}
catch( IndexOutOfBoundsException e )
{
aChars.append( " ERROR " );
}
// return result
return "getCharacters: " + aChars;
}
/** iterate over characters, and translate their positions
* back and forth */
private String bounds( XAccessibleText xText )
{
StringBuffer aBuffer = new StringBuffer( "bounds: " );
try
{
// iterate over characters
int nCount = xText.getCharacterCount();
for(int i = 0; i < nCount; i++ )
{
// get bounds for this character
Rectangle aRect = xText.getCharacterBounds( i );
// get the character by 'clicking' into the middle of
// the bounds
Point aMiddle = new Point();
aMiddle.X = aRect.X + (aRect.Width / 2) - 1;
aMiddle.Y = aRect.Y + (aRect.Height / 2 ) - 1;
int nIndex = xText.getIndexAtPoint( aMiddle );
// get the character, or a '#' for an illegal index
if( (nIndex >= 0) && (nIndex < xText.getCharacter(i)) )
aBuffer.append( xText.getCharacter(nIndex) );
else
aBuffer.append( '#' );
}
}
catch( IndexOutOfBoundsException e )
{ ; } // ignore errors
return aBuffer.toString();
}
private AccessibleTreeNode getAttributes( XAccessibleText xText,
AccessibleTreeNode aParent)
{
String[] aAttributeList = new String[] {
"CharBackColor",
"CharColor",
"CharEscapement",
"CharHeight",
"CharPosture",
"CharStrikeout",
"CharUnderline",
"CharWeight",
"ParaAdjust",
"ParaBottomMargin",
"ParaFirstLineIndent",
"ParaLeftMargin",
"ParaLineSpacing",
"ParaRightMargin",
"ParaTabStops"};
AccessibleTreeNode aRet;
try
{
VectorNode aPortions = new VectorNode ("getAttributes", aParent);
int nIndex = 0;
int nLength = xText.getCharacterCount();
while( nIndex < nLength )
{
// get attribute run
String aPortion = null;
try
{
aPortion = xText.getTextAtIndex(
nIndex, AccessibleTextType.ATTRIBUTE_RUN).SegmentText;
}
catch(com.sun.star.lang.IllegalArgumentException e)
{
aPortion = new String ("");
}
// get attributes and make node with attribute children
PropertyValue[] aValues = xText.getCharacterAttributes(nIndex, aAttributeList);
VectorNode aAttrs = new VectorNode (aPortion, aPortions);
for( int i = 0; i < aValues.length; i++ )
{
new StringNode( aValues[i].Name + ": " + aValues[i].Value,
aAttrs );
}
// get next portion, but advance at least one
nIndex += (aPortion.length() > 0) ? aPortion.length() : 1;
}
aRet = aPortions;
}
catch( IndexOutOfBoundsException e )
{
aRet = new StringNode( "Exception caught:" + e, aParent );
}
return aRet;
}
static String[] aTextActions =
new String[] { "select...", "copy..." };
static String[] aEditableTextActions =
new String[] { "select...", "copy...",
"cut...", "paste...", "edit...", "format..." };
public String[] getActions (AccessibleTreeNode aNode)
{
XAccessibleEditableText xEText = null;
if (aNode instanceof AccTreeNode)
xEText = ((AccTreeNode)aNode).getEditText ();
return (xEText == null) ? aTextActions : aEditableTextActions;
}
public void performAction (AccessibleTreeNode aNode, int nIndex)
{
if ( ! (aNode instanceof AccTreeNode))
return;
AccTreeNode aATNode = (AccTreeNode)aNode;
TextActionDialog aDialog = null;
// create proper dialog
switch( nIndex )
{
case 0:
aDialog = new TextActionDialog( aATNode,
"Select range:",
"select" )
{
boolean action(
JTextComponent aText, AccTreeNode aNode )
throws IndexOutOfBoundsException
{
return aNode.getText().setSelection(
getSelectionStart(),
getSelectionEnd() );
}
};
break;
case 1:
aDialog = new TextActionDialog( aATNode,
"Select range and copy:",
"copy" )
{
boolean action(
JTextComponent aText, AccTreeNode aNode )
throws IndexOutOfBoundsException
{
return aNode.getText().copyText(
getSelectionStart(),
getSelectionEnd() );
}
};
break;
case 2:
aDialog = new TextActionDialog( aATNode,
"Select range and cut:",
"cut" )
{
boolean action(
JTextComponent aText, AccTreeNode aNode )
throws IndexOutOfBoundsException
{
return aNode.getEditText().cutText(
getSelectionStart(),
getSelectionEnd() );
}
};
break;
case 3:
aDialog = new TextActionDialog( aATNode,
"Place Caret and paste:",
"paste" )
{
boolean action(
JTextComponent aText, AccTreeNode aNode )
throws IndexOutOfBoundsException
{
return aNode.getEditText().pasteText(
aText.getCaretPosition() );
}
};
break;
case 4:
aDialog = new TextEditDialog( aATNode, "Edit text:",
"edit" );
break;
case 5:
aDialog = new TextAttributeDialog( aATNode );
break;
}
if( aDialog != null )
aDialog.show();
}
}
/**
* Display a dialog with a text field and a pair of cancel/do-it buttons
*/
class TextActionDialog extends JDialog
implements ActionListener
{
AccTreeNode aNode;
JTextArea aText;
String sName;
JCheckBox aIndexToggle;
public TextActionDialog( AccTreeNode aNd,
String sExplanation,
String sButtonText )
{
super( AccessibilityWorkBench.Instance() );
aNode = aNd;
sName = sButtonText;
init( sExplanation, aNode.getText().getText(), sButtonText );
// setSize( getPreferredSize() );
setSize( 350, 225 );
}
/** build dialog */
protected void init( String sExplanation,
String sText,
String sButtonText )
{
setTitle( sName );
// vertical stacking of the elements
Container aContent = getContentPane();
// aContent.setLayout( new BorderLayout() );
// label with explanation
if( sExplanation.length() > 0 )
aContent.add( new JLabel( sExplanation ), BorderLayout.NORTH );
// the text field
aText = new JTextArea();
aText.setText( sText );
aText.setColumns( Math.min( Math.max( 40, sText.length() ), 20 ) );
aText.setRows( sText.length() / 40 + 1 );
aText.setLineWrap( true );
aText.setEditable( false );
aContent.add( aText, BorderLayout.CENTER );
JPanel aButtons = new JPanel();
aButtons.setLayout( new FlowLayout() );
aIndexToggle = new JCheckBox( "reverse selection" );
aButtons.add( aIndexToggle );
JButton aActionButton = new JButton( sButtonText );
aActionButton.setActionCommand( "Action" );
aActionButton.addActionListener( this );
aButtons.add( aActionButton );
JButton aCancelButton = new JButton( "cancel" );
aCancelButton.setActionCommand( "Cancel" );
aCancelButton.addActionListener( this );
aButtons.add( aCancelButton );
// add Panel with buttons
aContent.add( aButtons, BorderLayout.SOUTH );
}
void cancel()
{
hide();
dispose();
}
void action()
{
String sError = null;
try
{
boolean bSuccess = action( aText, aNode );
if( !bSuccess )
sError = "Can't execute";
}
catch( IndexOutOfBoundsException e )
{
sError = "Index out of bounds";
}
if( sError != null )
JOptionPane.showMessageDialog( AccessibilityWorkBench.Instance(),
sError, sName,
JOptionPane.ERROR_MESSAGE);
cancel();
}
public void actionPerformed(ActionEvent e)
{
String sCommand = e.getActionCommand();
if( "Cancel".equals( sCommand ) )
cancel();
else if( "Action".equals( sCommand ) )
action();
}
int getSelectionStart() { return getSelection(true); }
int getSelectionEnd() { return getSelection(false); }
int getSelection(boolean bStart)
{
return ( bStart ^ aIndexToggle.isSelected() )
? aText.getSelectionStart() : aText.getSelectionEnd();
}
/** override this for dialog-specific action */
boolean action( JTextComponent aText, AccTreeNode aNode )
throws IndexOutOfBoundsException
{
return false;
}
}
class TextEditDialog extends TextActionDialog
{
public TextEditDialog( AccTreeNode aNode,
String sExplanation,
String sButtonText )
{
super( aNode, sExplanation, sButtonText );
}
protected void init( String sExplanation,
String sText,
String sButtonText )
{
super.init( sExplanation, sText, sButtonText );
aText.setEditable( true );
}
/** edit the text */
boolean action( JTextComponent aText, AccTreeNode aNode )
{
// is this text editable? if not, fudge you and return
XAccessibleEditableText xEdit = aNode.getEditText();
return ( xEdit == null ) ? false :
updateText( xEdit, aText.getText() );
}
/** update the text */
boolean updateText( XAccessibleEditableText xEdit, String sNew )
{
String sOld = xEdit.getText();
// false alarm? Early out if no change was done!
if( sOld.equals( sNew ) )
return false;
// get the minimum length of both strings
int nMinLength = sOld.length();
if( sNew.length() < nMinLength )
nMinLength = sNew.length();
// count equal characters from front and end
int nFront = 0;
while( (nFront < nMinLength) &&
(sNew.charAt(nFront) == sOld.charAt(nFront)) )
nFront++;
int nBack = 0;
while( (nBack < nMinLength) &&
( sNew.charAt(sNew.length()-nBack-1) ==
sOld.charAt(sOld.length()-nBack-1) ) )
nBack++;
if( nFront + nBack > nMinLength )
nBack = nMinLength - nFront;
// so... the first nFront and the last nBack characters
// are the same. Change the others!
String sDel = sOld.substring( nFront, sOld.length() - nBack );
String sIns = sNew.substring( nFront, sNew.length() - nBack );
System.out.println("edit text: " +
sOld.substring(0, nFront) +
" [ " + sDel + " -> " + sIns + " ] " +
sOld.substring(sOld.length() - nBack) );
boolean bRet = false;
try
{
// edit the text, and use
// (set|insert|delete|replace)Text as needed
if( nFront+nBack == 0 )
bRet = xEdit.setText( sIns );
else if( sDel.length() == 0 )
bRet = xEdit.insertText( sIns, nFront );
else if( sIns.length() == 0 )
bRet = xEdit.deleteText( nFront, sOld.length()-nBack );
else
bRet = xEdit.replaceText(nFront, sOld.length()-nBack,sIns);
}
catch( IndexOutOfBoundsException e )
{
bRet = false;
}
return bRet;
}
}
class TextAttributeDialog extends TextActionDialog
{
public TextAttributeDialog(
AccTreeNode aNode )
{
super( aNode, "Choose attributes, select text, and press 'Set':",
"set" );
}
private JCheckBox aBold, aUnderline, aItalics;
private Color aForeground, aBackground;
protected void init( String sExplanation,
String sText,
String sButtonText )
{
super.init( sExplanation, sText, sButtonText );
aForeground = Color.black;
aBackground = Color.white;
JPanel aAttr = new JPanel();
aAttr.setLayout( new BoxLayout( aAttr, BoxLayout.Y_AXIS ) );
aBold = new JCheckBox( "bold" );
aUnderline = new JCheckBox( "underline" );
aItalics = new JCheckBox( "italics" );
JButton aForeButton = new JButton("Foreground", new ColorIcon(true));
aForeButton.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent e)
{
aForeground = JColorChooser.showDialog(
TextAttributeDialog.this,
"Select Foreground Color",
aForeground);
}
} );
JButton aBackButton = new JButton("Background", new ColorIcon(false));
aBackButton.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent e)
{
aBackground = JColorChooser.showDialog(
TextAttributeDialog.this,
"Select Background Color",
aBackground);
}
} );
aAttr.add( aBold );
aAttr.add( aUnderline );
aAttr.add( aItalics );
aAttr.add( aForeButton );
aAttr.add( aBackButton );
getContentPane().add( aAttr, BorderLayout.WEST );
}
class ColorIcon implements Icon
{
boolean bForeground;
static final int nHeight = 16;
static final int nWidth = 16;
public ColorIcon(boolean bWhich) { bForeground = bWhich; }
public int getIconHeight() { return nHeight; }
public int getIconWidth() { return nWidth; }
public void paintIcon(Component c, Graphics g, int x, int y)
{
g.setColor( getColor() );
g.fillRect( x, y, nHeight, nWidth );
g.setColor( c.getForeground() );
g.drawRect( x, y, nHeight, nWidth );
}
Color getColor()
{
return bForeground ? aForeground : aBackground;
}
}
/** edit the text */
boolean action( JTextComponent aText, AccTreeNode aNode )
throws IndexOutOfBoundsException
{
// is this text editable? if not, fudge you and return
XAccessibleEditableText xEdit = aNode.getEditText();
boolean bSuccess = false;
if( xEdit != null )
{
PropertyValue[] aSequence = new PropertyValue[6];
aSequence[0] = new PropertyValue();
aSequence[0].Name = "CharWeight";
aSequence[0].Value = new Integer( aBold.isSelected() ? 150 : 100 );
aSequence[1] = new PropertyValue();
aSequence[1].Name = "CharUnderline";
aSequence[1].Value = new Integer( aUnderline.isSelected() ? 1 : 0 );
aSequence[2] = new PropertyValue();
aSequence[2].Name = "CharBackColor";
aSequence[2].Value = new Integer( aBackground.getRGB() );
aSequence[3] = new PropertyValue();
aSequence[3].Name = "CharColor";
aSequence[3].Value = new Integer( aForeground.getRGB() );
aSequence[4] = new PropertyValue();
aSequence[4].Name = "CharPosture";
aSequence[4].Value = new Integer( aItalics.isSelected() ? 1 : 0 );
aSequence[5] = new PropertyValue();
aSequence[5].Name = "CharBackTransparent";
aSequence[5].Value = new Boolean( false );
bSuccess = xEdit.setAttributes( getSelectionStart(),
getSelectionEnd(),
aSequence );
}
return bSuccess;
}
}