| /************************************************************** | |
| * | |
| * 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.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 = 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 | |
| StringBuilder aChars = new StringBuilder(); | |
| 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 ) | |
| { | |
| StringBuilder aBuffer = new StringBuilder( "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; | |
| } | |
| } |