Attachment 158035 Details for Bug 298392 – new implementation of Field 3270 functionality based on StyledText

new implementation of Field 3270 functionality based on StyledText

Field3270.java (text/plain), 22.49 KB, created by Ira Fishbein

on 2010-02-03 06:29:57 EST

(hide)

Description:

Filename:

MIME Type:

Creator: Ira Fishbein

Created: 2010-02-03 06:29:57 EST

Size: 22.49 KB

patch

obsolete

>/*******************************************************************************
> * Copyright (c) 2010 IBM Corporation and others.
> * All rights reserved. This program and the accompanying materials
> * are made available under the terms of the Eclipse Public License v1.0
> * which accompanies this distribution, and is available at
> * http://www.eclipse.org/legal/epl-v10.html
> *
> * Contributors:
> *     IBM Corporation - initial API and implementation
> ******************************************************************************/
>
>package org.eclipse.swt.custom;
>
>import org.eclipse.swt.SWT;
>import org.eclipse.swt.events.KeyEvent;
>import org.eclipse.swt.events.KeyListener;
>import org.eclipse.swt.events.ModifyListener;
>import org.eclipse.swt.events.SelectionListener;
>import org.eclipse.swt.events.VerifyListener;
>import org.eclipse.swt.graphics.Color;
>import org.eclipse.swt.graphics.GC;
>import org.eclipse.swt.graphics.Image;
>import org.eclipse.swt.graphics.LineAttributes;
>import org.eclipse.swt.graphics.Point;
>import org.eclipse.swt.graphics.Rectangle;
>import org.eclipse.swt.internal.BidiUtil;
>import org.eclipse.swt.internal.win32.OS;
>import org.eclipse.swt.layout.FillLayout;
>import org.eclipse.swt.layout.GridLayout;
>import org.eclipse.swt.printing.Printer;
>import org.eclipse.swt.widgets.Canvas;
>import org.eclipse.swt.widgets.Caret;
>import org.eclipse.swt.widgets.Composite;
>import org.eclipse.swt.widgets.Event;
>import org.eclipse.swt.widgets.Listener;
>import org.eclipse.swt.widgets.Menu;
>import org.eclipse.swt.widgets.MenuItem;
>
>public class Field3270 extends Canvas {
>    public static final int LANG_ARABIC = 0x01;
>    public static final int LANG_HEBREW = 0x0d;
>    public static final int LANG_ENGLISH = 0x09;
>	
>    public static final char LRO = '\u202d';
>    private static final char RLO = '\u202e';
>    private static final char PDF = '\u202c';
>    private static final String eolStr = "\r\n";
>    
>    Listener listener;
>    StyledText styledText;
>    int bidiLangCode = 0;
>    int nonBidiLangCode = 0;
>    boolean isPushMode;
>    boolean isWidgetReversed;
>    boolean isAutoPush;
>    int indxPushSegmentStart = -1;
>    int lengthPushSegment = 0;
>    Caret defaultCaret = null;
>    MenuItem rtlMenuItem;
>    MenuItem autopushMenuItem;
>    char[] arrOfIgnoredChars = null;
>    private int prevLength = 0;
>	
>    public Field3270(Composite parent, int style){
>		super(parent, 0);
>		this.setLayout(new FillLayout());
>		if ((parent.getLayout() instanceof FillLayout) ||
>			(parent.getLayout() instanceof GridLayout))
>			styledText = new StyledText(this, style);
>		else
>			styledText = new StyledText(parent, style);
>
>		addBidiSegmentListener();
>		styledText.removeListener(SWT.KeyDown, styledText.getListeners(SWT.KeyDown)[0]);
>		addListeners();
>		styledText.setMenu(createContextMenu());
>    }
>	
>    public void setBidiLang (int lang) {
>    	bidiLangCode = lang;
>    }
>    public void setNonBidiLang (int lang) {
>    	nonBidiLangCode = lang;
>    }
>    
>    public void setArrOfIgnoredChars(char[] arr){
>    	arrOfIgnoredChars = (char[])arr.clone();
>    }
>    
>	private void addListeners() {
>		listener = new Listener() {
>			
>			public void handleEvent(Event event) {
>				switch (event.type) {
>				case SWT.MouseDown: handleMouseDown(event); break;
>				case SWT.KeyDown: handleKeyDown(event); break;
>			}
>				
>			}
>		};
>		styledText.addListener(SWT.KeyDown, listener);
>		styledText.addListener(SWT.MouseDown, listener);
>		styledText.addListener(SWT.Show, listener);
>		
>		styledText.addKeyListener(new KeyListener() {
>			public void keyReleased(KeyEvent keyEvent) {
>				if ((keyEvent.keyCode == 'u') &&
>					((keyEvent.stateMask & SWT.CTRL) != 0)){
>					setPush(true);
>					keyEvent.doit = false;
>				}else if ((keyEvent.keyCode == 'o') &&
>					((keyEvent.stateMask & SWT.CTRL) != 0)) {
>					setPush(false);
>					keyEvent.doit = false;
>				} else if ((keyEvent.keyCode == 't') &&
>						((keyEvent.stateMask & SWT.CTRL) != 0)){
>					switchAutoPush();
>					keyEvent.doit = false;
>				} else if (isPushMode && (keyEvent.keyCode == SWT.HOME || keyEvent.keyCode==SWT.END)){
>					int carPos = getCaretOffset();
>					setPush(false);
>					setCaretOffset(carPos);
>				}
>			}
>
>			public void keyPressed(KeyEvent e) {
>			}
>		});
>	}
>
>
>	private Menu createContextMenu(){
>		Menu menu;
>		if (styledText.getMenu() == null)
>			menu = new Menu(styledText);
>		else
>			menu = styledText.getMenu();
>
>		MenuItem copy = new MenuItem(menu, SWT.CASCADE);
>		copy.setText("&Copy"); //$NON-NLS-1$ 
>		copy.setAccelerator(SWT.CTRL+'c');	//$NON-NLS-1$ 
>		copy.addListener(SWT.Selection, new Listener() {
>			public void handleEvent(Event e) {
>				copy();
>				e.doit = false;
>			}
>		});	
>		MenuItem cut = new MenuItem(menu, SWT.CASCADE);
>		cut.setText("Cu&t"); //$NON-NLS-1$ 
>		cut.setAccelerator(SWT.CTRL+'x');  //$NON-NLS-1$ 
>		cut.addListener(SWT.Selection, new Listener() {
>			public void handleEvent(Event e) {
>				cut();
>				e.doit = false;			
>			}
>		});
>		MenuItem paste = new MenuItem(menu, SWT.CASCADE);
>		paste.setText("&Paste"); //$NON-NLS-1$ 
>		paste.setAccelerator(SWT.CTRL+'v'); //$NON-NLS-1$ 
>		paste.addListener(SWT.Selection, new Listener() {
>			public void handleEvent(Event e) {
>				paste();
>				e.doit = false;
>			}
>		});
>
>		rtlMenuItem = new MenuItem(menu, SWT.CHECK);
>		rtlMenuItem.setText("Right to Left Reading Order"); //$NON-NLS-1$ 
>		rtlMenuItem.setAccelerator(SWT.CTRL | SWT.SHIFT); //$NON-NLS-1$
>		rtlMenuItem.setData("#PopupMenu"/*menu.getItem(0).getData()*/);
>		rtlMenuItem.addListener(SWT.Selection, new Listener() {
>			public void handleEvent(Event e) {
>				e = createEventForSwithchDir(e);
>				handleKeyDown(e);
>				styledText.handleKeyUp(e);
>				rtlMenuItem.setSelection(isWidgetReversed);
>			}
>			private Event createEventForSwithchDir(Event e) {
>				e.widget = styledText;
>				e.keyCode = SWT.SHIFT;
>				if (isWidgetReversed)
>					e.keyLocation = SWT.LEFT;
>				else
>					e.keyLocation = SWT.RIGHT;
>				e.stateMask = SWT.CTRL;
>				return e;
>			}
>		});
>
>		new MenuItem(menu, SWT.SEPARATOR);
>	
>		autopushMenuItem = new MenuItem(menu, SWT.CHECK);
>		autopushMenuItem.setText("AutoPush [Ctrl+T]");
>		autopushMenuItem.addListener(SWT.Selection, new Listener() {
>			public void handleEvent(Event e) {
>				switchAutoPush();			
>			}
>		});
>		final MenuItem pushon = new MenuItem(menu, SWT.CASCADE/*SWT.CHECK*/);
>		pushon.setText("Push On [Ctrl+U]");
>		pushon.addListener(SWT.Selection, new Listener() {
>			public void handleEvent(Event e) {
>				setPush(true);			
>			}
>		});
>		
>		final MenuItem pushoff = new MenuItem(menu, SWT.CASCADE/*SWT.CHECK*/);
>		pushoff.setText("Push Off [Ctrl+O]");
>		pushoff.addListener(SWT.Selection, new Listener() {
>			public void handleEvent(Event e) {
>				setPush(false);			
>			}
>		});
>		
>		return menu;
>	}
>	
>	public void copy() {
>		styledText.copy();
>	}
>	
>	public void cut() {
>		styledText.cut();
>	}
>	public void paste() {
>		styledText.paste();
>	}
>	protected void handleMouseDown (Event event){
>		styledText.handleMouseDown(event);
>		if (isPushMode && !isCaretInsidePushSegment()){
>			int caretPos = styledText.getCaretOffset();
>			setPush(false);
>			styledText.setCaretOffset(getUpdatedCaret(caretPos));
>		}
>	}
>	protected void handleKeyDown(Event event) {
>		if (event.keyCode == SWT.ARROW_RIGHT && isPushMode){
>			if (!isWidgetReversed && isCursorAtStartPushSegemet())
>				setPush(false);
>			else if (isWidgetReversed && isCursorAtEndPushSegemet()){
>				int newCaretPos = indxPushSegmentStart;
>				setPush(false);
>				styledText.setCaretOffset (newCaretPos);
>			} else
>				if (!isWidgetReversed)
>					styledText.invokeAction(ST.COLUMN_PREVIOUS);
>				else
>					styledText.invokeAction(ST.COLUMN_NEXT);
>		} else if (event.keyCode == SWT.ARROW_LEFT && isPushMode){
>			if (!isWidgetReversed && isCursorAtEndPushSegemet()){
>				int newCaretPos = indxPushSegmentStart;
>				setPush(false);
>				styledText.setCaretOffset (newCaretPos);
>			} else if (isWidgetReversed && isCursorAtStartPushSegemet()){
>				setPush(false);
>			} else
>				if (!isWidgetReversed)
>					styledText.invokeAction(ST.COLUMN_NEXT);
>				else
>					styledText.invokeAction(ST.COLUMN_PREVIOUS);
>		}else if (isPushMode && (event.keyCode == SWT.HOME || event.keyCode==SWT.END)){
>			setPush(false);
>			styledText.handleKeyDown(event);
>		} else if (event.keyCode == SWT.DEL && isPushMode){
>			if (!isCursorAtEndPushSegemet()){
>				styledText.handleKeyDown(event);
>				lengthPushSegment--;
>			}
>		}else if (event.keyCode == SWT.BS && isPushMode){
>			if (!isCursorAtStartPushSegemet()){ 
>				styledText.handleKeyDown(event);
>				lengthPushSegment --;
>			}else {
>				setPush(false);
>				styledText.handleKeyDown(event);
>			}
>		}else if ((event.stateMask & SWT.MODIFIER_MASK) == SWT.CTRL && event.keyCode == SWT.SHIFT && BidiUtil.isBidiPlatform()){
>			if ((!isWidgetReversed && event.keyLocation == SWT.RIGHT) ||
>					(isWidgetReversed && event.keyLocation == SWT.LEFT)){
>				switchWidgetDir();
>				styledText.handleKeyDown(event);
>			}
>		} else if (isPushMode && (event.character == SWT.CR) ) { 
>			setPush(false);
>			styledText.handleKeyDown(event);
>		} else {
>			if (isAutoPush && event.character >= ' ' && event.character != SWT.DEL){
>				handleAutoPush();
>			}
>			if ((arrOfIgnoredChars != null) && ((new String(arrOfIgnoredChars)).indexOf(event.character) != -1))
>				return;
>			styledText.handleKeyDown(event);
>		}
>		
>	}
>	
>	private boolean isCursorAtStartPushSegemet() {
>		int caretOffset = styledText.getCaretOffset();
>		if (isCaretAtTheLAstLine()) //it is the last line of string
>			caretOffset --;
>		//pushSegmentStart was stored when string had similar to widget orientation, therefore it needs to be 'mirrored' for comparison
>		int mirroredBoundPosition = calculateMirroredPushSegmentStart();
>		if (mirroredBoundPosition == (caretOffset-1))
>			return true;
>		return false;
>	}
>	private boolean isCursorAtEndPushSegemet() {
>		int caretOffset = styledText.getCaretOffset();
>		if (isCaretAtTheLAstLine())
>			caretOffset --;
>		//pushSegmentStart was stored when string had similar to widget orientation, therefore it needs to be 'mirrored' for comparison
>		int mirroredBoundPosition = calculateMirroredPushSegmentEnd();
>		
>		if (mirroredBoundPosition == caretOffset)
>			return true;
>		return false;
>	}
>	private int calculateMirroredCaretPosition(int caretPos) {
>		LineIndx lineIndx = new LineIndx(styledText.getText(),styledText.getCaretOffset());
>		return lineIndx.getEndIndx() - (caretPos - lineIndx.getStartIndx());
>	}
>	private int calculateMirroredPushSegmentEnd() {
>		return calculateMirroredCaretPosition(indxPushSegmentStart);
>	}
>	private int calculateMirroredPushSegmentStart() {
>		return calculateMirroredPushSegmentEnd() - lengthPushSegment;
>	}
>	
>	private boolean isCaretAtTheLAstLine(){
>		LineIndx lineIndx = new LineIndx(styledText.getText(),styledText.getCaretOffset());
>		if (lineIndx.getEndIndx() == styledText.getText().length()-1)
>			return true;
>		return false;
>	}
>	
>	private boolean isCaretInsidePushSegment(){
>		int mirroredPushSegmentEnd = calculateMirroredPushSegmentEnd();
>		int mirroredPushSegmentStart = calculateMirroredPushSegmentStart();
>		int caretPos = styledText.getCaretOffset();
>		if ((caretPos >= mirroredPushSegmentStart) && (caretPos <= mirroredPushSegmentEnd))
>			return true;
>		return false;
>	}
>	
>	protected void switchAutoPush() {
>		isAutoPush = !isAutoPush;
>		autopushMenuItem.setSelection(isAutoPush);
>	}
>	public boolean isPushMode(){
>		return isPushMode;
>	}
>	private void switchWidgetDir() {
>		isWidgetReversed = !isWidgetReversed;
>		int carPos = styledText.getCaretOffset();
>		styledText.setText(reverseStr(styledText.getText()));
>		styledText.setCaretOffset (carPos);
>		rtlMenuItem.setSelection(isWidgetReversed);
>		if (isPushMode)
>			setPush(false);
>		if (isWidgetReversed)
>			setBidiKeyboardLanguage();
>		else 
>			setNonBidiKeyboardLanguage();
>	}
>
>	public void setPush(boolean pushOn) {
>		if (isPushMode == pushOn)
>			return;
>		isPushMode = pushOn;
>		if (pushOn) {
>			startPushMode();
>		}
>		else {
>			endPushMode();
>			indxPushSegmentStart = -1;
>			lengthPushSegment = 0;
>		}
>	}
>	
>	private void endPushMode() {
>		styledText.setCaret(defaultCaret);
>		styledText.defaultCaret = defaultCaret;
>		styledText.caretDirection = SWT.NULL;
>		styledText.setText(reverseStr(styledText.getText()));
>		styledText.setCaretOffset (indxPushSegmentStart + lengthPushSegment);
>		if (!isWidgetReversed)
>			setNonBidiKeyboardLanguage();
>		else
>			setBidiKeyboardLanguage();
>		
>	}
>	
>	public static String reverseStr (String str) {
>		String resultStr = "";
>		String orgStr = new String(str);
>		int i=-1;
>		while ((i = orgStr.indexOf(eolStr)) != -1){
>			StringBuffer sb = new StringBuffer(orgStr.substring(0,i));
>			resultStr += sb.reverse() + eolStr;
>			orgStr = orgStr.substring(i + eolStr.length());
>		}
>		if (orgStr.length()>0){
>			StringBuffer sb = new StringBuffer(orgStr);
>			resultStr += sb.reverse();
>		}
>		return resultStr;
>	}
>	
>	public void addBidiSegmentListener() {
>		styledText.addBidiSegmentListener(new BidiSegmentListener() {
>			public void lineGetSegments(BidiSegmentEvent event) {
>				int length = event.lineText.length();
>				if ((isPushMode && !isWidgetReversed) ||
>					(!isPushMode && isWidgetReversed)){
>					event.segments = new int[] { 0};
>					event.segmentsChars = new char[] { RLO};
>				} else {
>					event.segments = new int[] { 0, length };
>					event.segmentsChars = new char[] { LRO, PDF };
>				}
>				if (isPushMode && (indxPushSegmentStart != -1) && (prevLength< length))
>					lengthPushSegment++;
>				prevLength  = length;
>			}
>		});
>	
>	}
>	protected void startPushMode() {
>		final Image image = new Image (styledText.getDisplay(), 20, 20);
>		GC gc = new GC (image);
>		gc.setBackground (styledText.getDisplay().getSystemColor(SWT.COLOR_BLACK));
>		gc.fillRectangle (0, 0, 20, 20);
>		gc.setForeground (styledText.getDisplay().getSystemColor(SWT.COLOR_WHITE));
>		gc.setLineAttributes(new LineAttributes(2));
>		gc.drawLine (0, 13, gc.getFontMetrics().getAverageCharWidth(), 13);
>		gc.dispose ();
>		defaultCaret = styledText.defaultCaret;
>		styledText.getCaret().setImage (image);
>		styledText.defaultCaret = null;
>		int carOffset = styledText.getCaretOffset();
>		
>
>		String str = reverseStr(styledText.getText());
>		styledText.setText(str);
>		indxPushSegmentStart = carOffset;
>		styledText.setCaretOffset(getUpdatedCaret(carOffset));
>		if (!isWidgetReversed)
>			setBidiKeyboardLanguage();
>		else
>			setNonBidiKeyboardLanguage();
>	}
>	private int getUpdatedCaret(int carOffset) {
>		String str = styledText.getText();
>		LineIndx lineIndx = new LineIndx(str, carOffset);
>		int starIndx = lineIndx.getStartIndx();
>		int endIndx = lineIndx.getEndIndx();
>		if (endIndx == str.length()-1) //it is the last line of string
>			carOffset --;
>		return starIndx + (endIndx - carOffset);
>	}
>	private void handleAutoPush(){
>		if ((isPushMode && !isWidgetReversed && (BidiUtil.getKeyboardLanguage() == BidiUtil.KEYBOARD_NON_BIDI))||
>			(isPushMode && isWidgetReversed && (BidiUtil.getKeyboardLanguage() == BidiUtil.KEYBOARD_BIDI)))
>			setPush(false);
>		else if ((!isPushMode && !isWidgetReversed && (BidiUtil.getKeyboardLanguage() == BidiUtil.KEYBOARD_BIDI)) ||
>				 (!isPushMode && isWidgetReversed && (BidiUtil.getKeyboardLanguage() == BidiUtil.KEYBOARD_NON_BIDI)))
>			setPush(true);
>	}
>	
>	public boolean isWidgetReversed() {
>		return isWidgetReversed;
>	}
>
>	
>	private void setBidiKeyboardLanguage(){
>		if (bidiLangCode == 0)
>			BidiUtil.setKeyboardLanguage(BidiUtil.KEYBOARD_BIDI);
>		else
>			setSpecificKeyboardLanguage(bidiLangCode);
>	}
>	
>	private void setNonBidiKeyboardLanguage(){
>		if (nonBidiLangCode == 0)
>			BidiUtil.setKeyboardLanguage(BidiUtil.KEYBOARD_NON_BIDI);
>		else
>			setSpecificKeyboardLanguage(nonBidiLangCode);
>	}
>	
>	public static boolean setSpecificKeyboardLanguage(int langCode){
>		int currentLang = OS.PRIMARYLANGID(OS.LOWORD(OS.GetKeyboardLayout(0)));
>		if (currentLang == langCode)
>			return true;
>		int [] list = getKeyboardLanguageList();
>		for (int i=0; i<list.length; i++) {
>			if (langCode == OS.PRIMARYLANGID(OS.LOWORD(list[i]))) {
>				OS.ActivateKeyboardLayout(list[i], 0);
>				return true;
>			}
>		}
>		return false;
>	}
>	
>	public void setText(String text){
>		styledText.setText(text);
>	}
>	
>	public String getText(){
>		return styledText.getText();
>	}
>	public void addSelectionListener(SelectionListener listener) {
>		styledText.addSelectionListener(listener);
>	}
>	public void removeSelectionListener(SelectionListener listener) {
>		styledText.removeSelectionListener(listener);
>	}
>	public void addLineBackgroundListener(LineBackgroundListener listener) {
>		styledText.addLineBackgroundListener(listener);
>	}
>	public void removeLineBackgroundListener(LineBackgroundListener listener) {
>		styledText.removeLineBackgroundListener(listener);
>	}
>	public void addVerifyListener(VerifyListener listener){
>		styledText.addVerifyListener(listener);
>	}
>	public void removeVerifyListener(VerifyListener listener){
>		styledText.removeVerifyListener(listener);
>	}
>	public void addWordMovementListener(MovementListener listener){
>		styledText.addWordMovementListener(listener);
>	}
>	public void removeWordMovementListener(MovementListener listener){
>		styledText.removeWordMovementListener(listener);
>	}
>	public void addModifyListener(ModifyListener modifyListener) {
>		styledText.addModifyListener(modifyListener);
>	}
>	public void removeModifyListener(ModifyListener modifyListener) {
>		styledText.removeModifyListener(modifyListener);
>	}
>	public void redraw() {
>		styledText.redraw();
>	}
>	public int getCharCount() {
>		return styledText.getCharCount();
>	}
>	public Point getLocationAtOffset(int offset){
>		return styledText.getLocationAtOffset(offset);
>	}
>	public int getLineHeight(){
>		return styledText.getLineHeight();
>	}
>	public int getLineHeight(int lineIndex) {
>		return styledText.getLineHeight(lineIndex);
>	}
>	public void redraw(int x, int y, int width, int height, boolean all){
>		styledText.redraw(x,y,width,height,all);
>	}
>	public void redrawRange(int start, int length, boolean clearBackground) {
>		styledText.redrawRange(start, length, clearBackground);
>	}
>	public int getTopIndex(){
>		return styledText.getTopIndex();
>	}
>	public StyledText getStyledText (){
>		return styledText;
>	}
>	public boolean getBlockSelection() {
>		return styledText.getBlockSelection();
>	}
>	public Rectangle getBlockSelectionBounds() {
>		return styledText.getBlockSelectionBounds();
>	}
>	public void setTopIndex(int topIndex) {
>		styledText.setTopIndex(topIndex);
>	}
>	public boolean getEditable(){
>		return styledText.getEditable();
>	}
>	public int styledText(){
>		return styledText.getHorizontalPixel();
>	}
>	public int getLineAtOffset(int offset){
>		return styledText.getLineAtOffset(offset);
>	}
>	public int getHorizontalPixel(){
>		return styledText.getHorizontalPixel();
>	}
>	public int getHorizontalIndex(){
>		return styledText.getHorizontalIndex();
>	}
>	public void setHorizontalIndex(int offset) {
>		styledText.setHorizontalIndex(offset);
>	}
>	public Point getSelection(){
>		return styledText.getSelection();
>	}
>	public void setSelection(int start) {
>		styledText.setSelection(start);
>	}
>	public void setSelection(int start, int end) {
>		styledText.setSelection(start, end);
>	}
>	public void setSelectionRange(int start, int length) {
>		styledText.setSelectionRange(start, length);
>	}
>	public void selectAll(){
>		styledText.selectAll();
>	}
>	public void setStyleRange(StyleRange range) {
>		styledText.setStyleRange(range);
>	}
>	public void setStyleRanges(StyleRange[] ranges) {
>		styledText.setStyleRanges(ranges);
>	}
>	public void showSelection() {
>		styledText.showSelection();
>	}
>	public int getSelectionCount() {
>		return styledText.getSelectionCount();
>	}
>	public Point getSelectionRange(){
>		return styledText.getSelectionRange();
>	}
>	public int[] getSelectionRanges() {
>		return styledText.getSelectionRanges();
>	}
>	public int getTabs() {
>		return styledText.getTabs();
>	}
>	public Rectangle getTextBounds(int start, int end) {
>		return styledText.getTextBounds(start, end);
>	}
>	public int getTopPixel() {
>		return styledText.getTopPixel();
>	}
>	public int getCaretOffset() {
>		return styledText.getCaretOffset();
>	}
>	public void invokeAction(int action){
>		styledText.invokeAction(action);
>	}
>	public Runnable print(Printer printer, StyledTextPrintOptions options) {
>		return styledText.print(printer, options);
>	}
>	public void replaceStyleRanges(int start, int length, StyleRange[] ranges) {
>		styledText.replaceStyleRanges(start, length, ranges);
>	}
>	public void setBlockSelectionBounds(int x, int y, int width, int height) {
>		styledText.setBlockSelectionBounds(x, y, width, height);
>	}
>	public void setBlockSelectionBounds(Rectangle rect) {
>		styledText.setBlockSelectionBounds(rect);
>	}
>	public void setCaretOffset(int offset) {
>		styledText.setCaretOffset(offset);
>	}
>	public void setContent(StyledTextContent newContent) {
>		styledText.setContent(newContent);
>	}
>	public void setDoubleClickEnabled(boolean enable) {
>		styledText.setDoubleClickEnabled(enable);
>	}
>	public void setEditable(boolean editable) {
>		if (editable)
>			styledText.setBackground(null);
>		else
>			styledText.setBackground(styledText.getParent().getBackground());
>		styledText.setEditable(editable);
>	}
>	public void setEnabled (boolean enabled){
>		if (enabled)
>			styledText.setBackground(null);
>		else
>			styledText.setBackground(styledText.getParent().getBackground());
>		styledText.setEnabled(enabled);
>		super.setEnabled(enabled);
>	}
>
>	public void setBackground (Color color) {
>		styledText.setBackground(color);
>	}
>	//this method was copied from BidiUtil (since it isn't public)
>	static int [] getKeyboardLanguageList() {
>		int maxSize = 10;
>		int [] tempList = new int [maxSize];
>		int size = OS.GetKeyboardLayoutList(maxSize, tempList);
>		int [] list = new int [size];
>		System.arraycopy(tempList, 0, list, 0, size);
>		return list;
>	}
>	
>	private class LineIndx {
>		private int startIndx = -1;
>		private int endIndx = -1;
>		
>		LineIndx (String str, int indx){
>			startIndx = str.substring(0, indx).lastIndexOf(eolStr);
>			if (startIndx == -1)
>				startIndx = 0;
>			else
>				startIndx += eolStr.length();
>			endIndx = str.substring(startIndx).indexOf(eolStr);
>			if (endIndx == -1)
>				endIndx = str.substring(startIndx).length()-1;
>			endIndx += startIndx;
>		}
>		
>	    public int getStartIndx(){
>			return startIndx;
>		}
>		
>		public int getEndIndx(){
>			return endIndx;
>		}
>
>	}
>}

Actions: View

Attachments on bug 298392: 155320 | 158035 | 158036 | 158038 | 158040 | 158041 | 158042