| /* |
| * (C) Copyright IBM Corp. 1998-2005. All Rights Reserved. |
| * |
| * The program is provided "as is" without any warranty express or |
| * implied, including the warranty of non-infringement and the implied |
| * warranties of merchantibility and fitness for a particular purpose. |
| * IBM will not be liable for any damages suffered by you as a result |
| * of using the Program. In no event will IBM be liable for any |
| * special, indirect or consequential damages or lost profits even if |
| * IBM has been advised of the possibility of their occurrence. IBM |
| * will not be liable for any third party claims against you. |
| */ |
| package com.ibm.richtext.textpanel; |
| |
| import java.awt.Color; |
| import java.awt.Component; |
| import java.awt.Graphics; |
| import java.awt.Image; |
| import java.awt.Point; |
| import java.awt.Rectangle; |
| |
| import java.awt.event.ComponentAdapter; |
| import java.awt.event.FocusListener; |
| import java.awt.event.KeyListener; |
| import java.awt.event.MouseListener; |
| import java.awt.event.MouseMotionListener; |
| |
| import java.awt.event.ComponentEvent; |
| import java.awt.event.FocusEvent; |
| import java.awt.event.KeyEvent; |
| import java.awt.event.MouseEvent; |
| |
| import com.ibm.richtext.styledtext.MConstText; |
| import com.ibm.richtext.styledtext.MText; |
| import com.ibm.richtext.textformat.TextOffset; |
| |
| import com.ibm.richtext.textformat.MFormatter; |
| |
| import com.ibm.richtext.textlayout.attributes.AttributeMap; |
| |
| class TextComponent extends FakeComponent |
| implements BehaviorOwner, |
| FocusListener, |
| KeyListener, |
| MouseListener, |
| MouseMotionListener, |
| Scroller.Client { |
| |
| static final String COPYRIGHT = |
| "(C) Copyright IBM Corp. 1998-1999 - All Rights Reserved"; |
| |
| public static final int WINDOW_WIDTH = -10; |
| public static final int DEFAULT_INSET = 10; |
| |
| private static final Color STRONG_CARET_COLOR = Color.black; |
| private static final Color WEAK_CARET_COLOR = Color.darkGray; |
| |
| private Behavior fBehavior; |
| private MText fText; |
| private StyledTextClipboard fClipboard; |
| private boolean fScrolls; |
| private Scroller fScroller; |
| |
| private DocumentView fDocumentView = null; |
| |
| // sigh - can't create DocumentView until addNotify() is called. |
| // These values hold DocumentView ctor args |
| private AttributeMap fDefaultValues; |
| private boolean fViewWraps; |
| private int fViewWrapWidth; |
| private int fViewInsetAmount; |
| |
| private PanelEventBroadcaster fListener; |
| |
| /** |
| * Create a new TextComponent. |
| * @param text the text model. This model will be used for |
| * the life of the component, even if setText is called |
| * @param wraps if true, the text is wrapped to the specified |
| * wrapping width. If false, the text wraps only at paragraph breaks. |
| * @param wrapWidth ignored if wraps is false. Text wraps to this width |
| * unless the width is WINDOW_WIDTH, in which case text wraps to width |
| * of this component. Should not be negative (unless it is WINDOW_WIDTH). |
| * @param insetAmount the size of the margins around the text |
| * @param clipboard the clipboard to use for cut/copy/paste operations. |
| * If null, the component will use its own clipboard. |
| */ |
| public TextComponent(MText text, |
| AttributeMap defaultValues, |
| boolean wraps, |
| int wrapWidth, |
| int insetAmount, |
| StyledTextClipboard clipboard, |
| boolean scrolls, |
| Scroller scroller, |
| PanelEventBroadcaster listener) { |
| |
| fBehavior = null; |
| |
| if (text == null) { |
| throw new IllegalArgumentException("Text is null."); |
| } |
| |
| fText = text; |
| fDefaultValues = defaultValues; |
| |
| if (clipboard == null) { |
| throw new IllegalArgumentException("Clipboard is null."); |
| } |
| fClipboard = clipboard; |
| |
| fScrolls = scrolls; |
| |
| fScroller = scroller; |
| |
| fDocumentView = null; |
| |
| fViewWrapWidth = wrapWidth; |
| fViewWraps = wraps; |
| fViewInsetAmount = insetAmount; |
| fListener = listener; |
| } |
| |
| AttributeMap getDefaultValues() { |
| |
| return fDefaultValues; |
| } |
| |
| void setHost(Component component) { |
| |
| super.setHost(component); |
| |
| component.addFocusListener(this); |
| component.addKeyListener(this); |
| component.addMouseListener(this); |
| component.addMouseMotionListener(this); |
| |
| component.addComponentListener(new ComponentAdapter() { |
| public void componentResized(ComponentEvent e) { |
| if (fDocumentView != null) { |
| fDocumentView.hostSizeChanged(); |
| scrollToShow(fDocumentView.getDocumentBounds()); |
| } |
| } |
| }); |
| } |
| |
| /** |
| * ATextPanelImpl's use only! |
| */ |
| Component getHost() { |
| |
| return fHost; |
| } |
| |
| // Create document view here. TextComponent isn't fully constructed |
| // until this is called. |
| // This must be called by host component! |
| void addNotify() { |
| |
| Graphics g = getGraphics(); |
| if (g == null) { |
| throw new Error("Graphics should be valid here but isn't."); |
| } |
| |
| fDocumentView = new DocumentView(this, |
| fText, |
| fDefaultValues, |
| fViewWraps, |
| fViewWrapWidth, |
| fViewInsetAmount, |
| fListener); |
| documentSizeChanged(); |
| fListener.textStateChanged(TextPanelEvent.FORMAT_WIDTH_CHANGED); |
| } |
| |
| public Rectangle getBounds() { |
| |
| if (fHost != null) { |
| return fHost.getBounds(); |
| } |
| return new Rectangle(0, 0, 0, 0); |
| } |
| |
| Graphics getGraphics() { |
| |
| return (fHost==null)? null : fHost.getGraphics(); |
| } |
| |
| void requestFocus() { |
| |
| if (fHost != null) { |
| fHost.requestFocus(); |
| } |
| } |
| |
| // *** Behavior management *** |
| public Behavior getBehavior() { |
| return fBehavior; |
| } |
| |
| public void setBehavior(Behavior b) { |
| fBehavior = b; |
| } |
| |
| |
| // *** Events - just forward to behavior *** |
| public void focusGained(FocusEvent event) { |
| if (fBehavior != null) |
| fBehavior.focusGained(event); |
| } |
| |
| public void focusLost(FocusEvent event) { |
| if (fBehavior != null) |
| fBehavior.focusLost(event); |
| } |
| |
| public void keyPressed(KeyEvent event) { |
| if (fBehavior != null) |
| fBehavior.keyPressed(event); |
| } |
| |
| public void keyTyped(KeyEvent event) { |
| |
| if (fBehavior != null) { |
| fBehavior.keyTyped(event); |
| } |
| } |
| |
| public void keyReleased(KeyEvent event) { |
| if (fBehavior != null) |
| fBehavior.keyReleased(event); |
| } |
| |
| public void mouseClicked(MouseEvent event) { |
| // no behavior method for this |
| } |
| |
| public void mouseDragged(MouseEvent event) { |
| if (fBehavior != null) |
| fBehavior.mouseDragged(event); |
| } |
| |
| public void mouseEntered(MouseEvent event) { |
| if (fBehavior != null) |
| fBehavior.mouseEntered(event); |
| } |
| |
| public void mouseExited(MouseEvent event) { |
| if (fBehavior != null) |
| fBehavior.mouseExited(event); |
| } |
| |
| public void mouseMoved(MouseEvent event) { |
| if (fBehavior != null) |
| fBehavior.mouseMoved(event); |
| } |
| |
| public void mousePressed(MouseEvent event) { |
| if (fBehavior != null) |
| fBehavior.mousePressed(event); |
| } |
| |
| public void mouseReleased(MouseEvent event) { |
| if (fBehavior != null) |
| fBehavior.mouseReleased(event); |
| } |
| |
| public boolean textControlEventOccurred(Behavior.EventType event, Object what) { |
| |
| boolean handled = false; |
| |
| if (fBehavior != null) { |
| handled = fBehavior.textControlEventOccurred(event, what); |
| } |
| return handled; |
| } |
| |
| |
| // *** Scroll methods - called by Behaviors |
| |
| // viewStart, viewLimit is visible bounds of window |
| // targetStart, targetLimit is the region to scroll into view |
| private static int getScrollDifference(int viewStart, |
| int viewLimit, |
| int targetStart, |
| int targetLimit) { |
| |
| if (viewStart <= targetStart) { |
| if (viewLimit >= targetLimit) { |
| return 0; |
| } |
| return Math.max(viewStart-targetStart, viewLimit-targetLimit); |
| } |
| else if (viewLimit > targetLimit) { |
| |
| return viewLimit - targetLimit; |
| } |
| else { |
| return 0; |
| } |
| } |
| |
| void scrollToShow(Rectangle showRect) { |
| |
| if (fDocumentView != null) { |
| Rectangle bounds = getBounds(); |
| |
| int dx = getScrollDifference(showRect.x, showRect.x + showRect.width, |
| bounds.x, bounds.x + bounds.width); |
| int dy = getScrollDifference(showRect.y, showRect.y + showRect.height, |
| bounds.y, bounds.y + bounds.height); |
| |
| scrollSelf(dx, dy); |
| } |
| } |
| |
| void scrollToShow(int showX, int showY) { |
| |
| if (fDocumentView != null) { |
| int dx = 0, dy = 0; |
| |
| Rectangle bounds = getBounds(); |
| if (showX < bounds.x) { |
| dx = showX - bounds.x; |
| } |
| else if (showX > bounds.x + bounds.width) { |
| dx = showX - (bounds.x + bounds.width); |
| } |
| |
| if (showY < bounds.y) { |
| dy = showY - bounds.y; |
| } |
| else if (showY > bounds.y + bounds.height) { |
| dy = showY - (bounds.y + bounds.height); |
| } |
| |
| scrollSelf(dx, dy); |
| } |
| } |
| |
| private int pinScrollOffset(int delta, |
| int contentStart, |
| int contentLength, |
| int viewStart, |
| int viewLength) { |
| |
| if (delta > 0) { |
| int viewLimit = viewStart + viewLength; |
| int contentLimit = contentStart + contentLength; |
| |
| if (viewLimit + delta > contentLimit) { |
| delta = Math.max(0, contentLimit-viewLimit); |
| } |
| } |
| else { |
| if (viewStart + delta < contentStart) { |
| delta = Math.min(0, contentStart-viewStart); |
| } |
| } |
| |
| return delta; |
| } |
| |
| private void scrollSelf(int dx, int dy) { |
| |
| boolean scrolled = scrollBy(dx, dy); |
| |
| if (scrolled && fScroller != null) { |
| Rectangle documentBounds = fDocumentView.getDocumentBounds(); |
| fScroller.setPosition(-documentBounds.x, |
| -documentBounds.y); |
| } |
| } |
| |
| private synchronized boolean scrollBy(int dx, int dy) { |
| |
| boolean scrolled = false; |
| |
| if (fScrolls) { |
| Rectangle documentBounds = fDocumentView.getDocumentBounds(); |
| Rectangle viewBounds = getBounds(); |
| |
| // variable not used int oldDx = dx; |
| dx = pinScrollOffset(dx, |
| documentBounds.x, |
| documentBounds.width, |
| viewBounds.x, |
| viewBounds.width); |
| dy = pinScrollOffset(dy, |
| documentBounds.y, |
| documentBounds.height, |
| viewBounds.y, |
| viewBounds.height); |
| |
| if (dx != 0 || dy != 0) { |
| scrolled = true; |
| fDocumentView.moveBy(-dx, -dy); |
| } |
| } |
| |
| return scrolled; |
| } |
| |
| // implementation of Scroller.Client - called by Scroller |
| // they have to be public since they're in an interface |
| // no one else should call these methods |
| public Rectangle getScrollSize() { |
| |
| if (fDocumentView != null) { |
| return fDocumentView.getScrollableArea(); |
| } |
| return new Rectangle(0, 0, 0, 0); |
| } |
| |
| public void scrollTo(int x, int y) { |
| |
| if (fDocumentView != null) { |
| scrollBy(x + fDocumentView.getDocX(), y + fDocumentView.getDocY()); |
| } |
| } |
| |
| // *** Text access *** |
| MConstText getText() { |
| return fText; |
| } |
| |
| MText getModifiableText() { |
| return fText; |
| } |
| |
| StyledTextClipboard getClipboard() { |
| return fClipboard; |
| } |
| |
| public synchronized void paint(Graphics g) { |
| |
| if (fDocumentView != null) { |
| fDocumentView.paint(g); |
| } |
| } |
| |
| |
| // *** Metric info - used by Behaviors |
| Rectangle getCaretRect(TextOffset offset) { |
| |
| if (fDocumentView != null) { |
| return fDocumentView.getCaretRect(offset); |
| } |
| return new Rectangle(0, 0); |
| } |
| |
| TextOffset pointToTextOffset(TextOffset result, |
| int x, |
| int y, |
| TextOffset anchor, |
| boolean infiniteMode) { |
| |
| if (fDocumentView != null) { |
| return fDocumentView.pointToTextOffset(result, x, y, anchor, infiniteMode); |
| } |
| return new TextOffset(); |
| } |
| |
| // *** Other stuff used by Behaviors - mostly formatter exports |
| int lineContaining(TextOffset offset) { |
| |
| if (fDocumentView != null) { |
| return fDocumentView.lineContaining(offset); |
| } |
| return 0; |
| } |
| |
| int lineRangeLow(int lineNumber) { |
| |
| if (fDocumentView != null) { |
| return fDocumentView.lineRangeLow(lineNumber); |
| } |
| return 0; |
| } |
| |
| int lineRangeLimit(int lineNumber) { |
| |
| if (fDocumentView != null) { |
| return fDocumentView.lineRangeLimit(lineNumber); |
| } |
| return 0; |
| } |
| |
| void stopBackgroundFormatting() { |
| |
| if (fDocumentView != null) { |
| fDocumentView.stopBackgroundFormatting(); |
| } |
| } |
| |
| Rectangle getBoundingRect(TextOffset offset1, TextOffset offset2) { |
| |
| if (fDocumentView != null) { |
| return fDocumentView.getBoundingRect(offset1, offset2); |
| } |
| return new Rectangle(0, 0, 0, 0); |
| } |
| |
| synchronized void reformatAndDrawText(int reformatStart, |
| int reformatLength, |
| TextOffset selStart, |
| TextOffset selEnd, |
| Rectangle additionalUpdateRect, |
| Color hiliteColor) { |
| |
| if (fDocumentView != null) { |
| fDocumentView.reformatAndDrawText(reformatStart, |
| reformatLength, |
| selStart, |
| selEnd, |
| additionalUpdateRect, |
| hiliteColor); |
| } |
| } |
| |
| TextOffset findNewInsertionOffset(TextOffset result, |
| TextOffset initialOffset, |
| TextOffset previousOffset, |
| short direction) { |
| |
| if (fDocumentView != null) { |
| return fDocumentView.findNewInsertionOffset(result, initialOffset, previousOffset, direction); |
| } |
| return new TextOffset(initialOffset); |
| } |
| |
| synchronized void drawText(Graphics g, |
| Rectangle damagedRect, |
| boolean selectionVisible, |
| TextOffset selStart, |
| TextOffset selEnd, |
| Color hiliteColor) { |
| |
| if (fDocumentView != null) { |
| fDocumentView.drawText(g, damagedRect, selectionVisible, selStart, selEnd, hiliteColor); |
| } |
| } |
| |
| private void documentSizeChanged() { |
| |
| if (fScroller != null) { |
| fScroller.clientScrollSizeChanged(); |
| } |
| } |
| |
| int getFormatWidth() { |
| |
| if (fDocumentView != null) { |
| return fDocumentView.getFormatWidth(); |
| } |
| return 0; |
| } |
| |
| /** |
| * Return true if the paragraph at the given offset is left-to-right. |
| * @param offset an offset in the text |
| * @return true if the paragraph at the given offset is left-to-right |
| */ |
| boolean paragraphIsLeftToRight(int offset) { |
| |
| if (fDocumentView != null) { |
| return fDocumentView.paragraphIsLeftToRight(offset); |
| } |
| return true; |
| } |
| |
| private static final class DocumentView { |
| |
| private TextComponent fHost; |
| private boolean fWraps; |
| private boolean fWrapToWindowWidth; |
| private int fInsetAmount; |
| private PanelEventBroadcaster fListener; |
| |
| // fBounds is the total scrollable area of the document (including insets) |
| private Rectangle fBounds = new Rectangle(); |
| |
| private Point fOrigin; |
| |
| private MFormatter fFormatter; |
| |
| private OffscreenBufferCache fBufferCache; |
| |
| // Note, when this is true the caret won't blink in 1.1. Looks like an AWT bug. |
| private static boolean fNoOffscreenBuffer = |
| Boolean.getBoolean("TextComponent.NoOffscreenBuffer"); |
| |
| // Amount by which to reduce the format width to allow for right-aligned carets. |
| private final int CARET_SLOP = 1; |
| |
| DocumentView(TextComponent host, |
| MConstText text, |
| AttributeMap defaultValues, |
| boolean wraps, |
| int wrapWidth, |
| int insetAmount, |
| PanelEventBroadcaster listener) { |
| |
| fHost = host; |
| fWrapToWindowWidth = wrapWidth == WINDOW_WIDTH; |
| fInsetAmount = insetAmount; |
| fListener = listener; |
| |
| initFormatterAndSize(text, defaultValues, wraps, wrapWidth); |
| |
| fBufferCache = new OffscreenBufferCache(host.fHost); |
| } |
| |
| /** |
| * Note: this computes the bounds rectangle relative to fOrigin |
| */ |
| private void calcBoundsRect() { |
| |
| final int insetDim = 2 * fInsetAmount; |
| |
| final int minX = fFormatter.minX(); |
| final int minY = fFormatter.minY(); |
| |
| fBounds.setBounds(fOrigin.x + minX - fInsetAmount, |
| fOrigin.y + minY - fInsetAmount, |
| fFormatter.maxX() - minX + insetDim, |
| fFormatter.maxY() - minY + insetDim); |
| //if (minX <= 0) { |
| // System.out.println("calcBoundsRect: minX="+minX+ |
| // "; bounds.x="+fBounds.x+"; width="+fBounds.width); |
| //} |
| } |
| |
| private void initFormatterAndSize(MConstText text, |
| AttributeMap defaultValues, |
| boolean wraps, |
| int wrapWidth) { |
| |
| Rectangle hostBounds = fHost.getBounds(); |
| int formatWidth; |
| |
| if (!wraps || fWrapToWindowWidth) { |
| formatWidth = hostBounds.width - 2 * fInsetAmount; |
| if (formatWidth <= CARET_SLOP) { |
| formatWidth = CARET_SLOP+1; |
| } |
| } |
| else { |
| formatWidth = wrapWidth; |
| } |
| |
| fFormatter = MFormatter.createFormatter(text, |
| defaultValues, |
| formatWidth-CARET_SLOP, |
| wraps, |
| fHost.getGraphics()); |
| |
| fFormatter.formatToHeight(hostBounds.height * 2); |
| fOrigin = new Point(fInsetAmount, fInsetAmount); |
| calcBoundsRect(); |
| } |
| |
| // notification method called by TextComponent |
| void hostSizeChanged() { |
| |
| final boolean wrap = fFormatter.wrap(); |
| if (fWrapToWindowWidth || !wrap) { |
| |
| Rectangle hostBounds = fHost.getBounds(); |
| // variable not used final int insetDim = 2 * fInsetAmount; |
| |
| int formatWidth = hostBounds.width - 2*fInsetAmount; |
| if (formatWidth <= CARET_SLOP) { |
| formatWidth = CARET_SLOP+1; |
| } |
| fFormatter.setLineBound(formatWidth-CARET_SLOP); |
| |
| fFormatter.formatToHeight(hostBounds.y + (hostBounds.height*2) - fOrigin.y); |
| |
| calcBoundsRect(); |
| |
| //System.out.println("Window bounds="+hostBounds+"; document bounds="+fBounds); |
| |
| fHost.documentSizeChanged(); |
| fListener.textStateChanged(TextPanelEvent.FORMAT_WIDTH_CHANGED); |
| //System.out.println("formatWidth="+formatWidth); |
| //System.out.println("document bounds="+fBounds); |
| //System.out.println(); |
| } |
| //dumpWidthInfo(); |
| } |
| |
| int getFormatWidth() { |
| |
| return fFormatter.lineBound(); |
| } |
| |
| boolean paragraphIsLeftToRight(int offset) { |
| |
| int lineNumber = fFormatter.lineContaining(offset); |
| return fFormatter.lineIsLeftToRight(lineNumber); |
| } |
| |
| private void textSizeMightHaveChanged() { |
| |
| boolean changed = false; |
| final int insetDim = 2 * fInsetAmount; |
| |
| int textHeight = fFormatter.maxY() - fFormatter.minY() + insetDim; |
| if (textHeight != fBounds.height) { |
| fBounds.height = textHeight; |
| changed = true; |
| } |
| |
| if (!fFormatter.wrap()) { |
| int textWidth = fFormatter.maxX() - fFormatter.minX() + insetDim; |
| if (textWidth != fBounds.width) { |
| fBounds.width = textWidth; |
| changed = true; |
| } |
| } |
| |
| if (changed) { |
| //System.out.println("Text size changed. fBounds: " + fBounds); |
| calcBoundsRect(); |
| fHost.documentSizeChanged(); |
| fHost.scrollToShow(getDocumentBounds()); |
| } |
| } |
| |
| private void doDrawText(Graphics g, |
| Rectangle drawRect, |
| boolean selectionVisible, |
| TextOffset selStart, |
| TextOffset selEnd, |
| Color hiliteColor) { |
| |
| Color oldColor = g.getColor(); |
| g.setColor(fHost.getHost().getBackground()); |
| g.fillRect(drawRect.x, drawRect.y, drawRect.width, drawRect.height); |
| g.setColor(oldColor); |
| |
| // g.clearRect(drawRect.x, drawRect.y, drawRect.width, drawRect.height); |
| |
| if (selectionVisible) { |
| fFormatter.draw(g, drawRect, fOrigin, selStart, selEnd, hiliteColor); |
| } |
| else { |
| fFormatter.draw(g, drawRect, fOrigin, null, null, null); |
| } |
| |
| if (selStart != null && selStart.equals(selEnd) && selectionVisible) { |
| |
| fFormatter.drawCaret(g, selStart, fOrigin, |
| STRONG_CARET_COLOR, WEAK_CARET_COLOR); |
| } |
| } |
| |
| void drawText(Graphics g, |
| Rectangle drawRect, |
| boolean selectionVisible, |
| TextOffset selStart, |
| TextOffset selEnd, |
| Color hiliteColor) { |
| |
| if (g != null) { |
| drawRect = drawRect.intersection(fHost.getBounds()); |
| //System.out.println("drawText:drawRect: " + drawRect); |
| g.clipRect(drawRect.x, drawRect.y, drawRect.width, drawRect.height); |
| if (fNoOffscreenBuffer) { |
| doDrawText(g, drawRect, selectionVisible, selStart, selEnd, hiliteColor); |
| } |
| else { |
| Image offscreenBuffer = fBufferCache.getBuffer(drawRect.width, drawRect.height); |
| Graphics offscreenGraphics = offscreenBuffer.getGraphics(); |
| offscreenGraphics.translate(-drawRect.x, -drawRect.y); |
| |
| doDrawText(offscreenGraphics, drawRect, selectionVisible, selStart, selEnd, hiliteColor); |
| |
| g.drawImage(offscreenBuffer, drawRect.x, drawRect.y, fHost.fHost); |
| } |
| } |
| textSizeMightHaveChanged(); |
| } |
| |
| void reformatAndDrawText(int reformatStart, |
| int reformatLength, |
| TextOffset selStart, |
| TextOffset selEnd, |
| Rectangle additionalUpdateRect, |
| Color hiliteColor) { |
| |
| Rectangle visibleBounds = fHost.getBounds(); |
| Rectangle redrawRect = fFormatter.updateFormat(reformatStart, |
| reformatLength, |
| visibleBounds, |
| fOrigin); |
| //System.out.println("[1] redrawRect: " + redrawRect); |
| |
| if (additionalUpdateRect != null) { |
| redrawRect.add(additionalUpdateRect); |
| //System.out.println("[2] redrawRect: " + redrawRect); |
| } |
| |
| boolean haveSelection; |
| |
| if (selStart != null && selEnd != null) { |
| haveSelection = true; |
| redrawRect.add(fFormatter.getBoundingRect(selStart, selEnd, fOrigin, MFormatter.LOOSE)); |
| //System.out.println("[3] redrawRect: " + redrawRect); |
| } |
| else { |
| haveSelection = false; |
| } |
| |
| drawText(fHost.getGraphics(), redrawRect, haveSelection, selStart, selEnd, hiliteColor); |
| } |
| |
| private void letBehaviorDraw(Graphics g, Rectangle drawRect) { |
| |
| boolean result = false; |
| |
| if (fHost.fBehavior != null) { |
| result = fHost.fBehavior.paint(g, drawRect); |
| } |
| |
| if (!result) { |
| drawText(g, drawRect, false, null, null, null); |
| } |
| } |
| |
| void moveBy(int dx, int dy) { |
| |
| Rectangle visibleBounds = fHost.getBounds(); |
| Graphics g = fHost.getGraphics(); |
| |
| fBounds.x += dx; |
| fBounds.y += dy; |
| fOrigin.x += dx; |
| fOrigin.y += dy; |
| |
| Rectangle refreshRect = new Rectangle(visibleBounds); |
| |
| if (dx == 0) { |
| if (g != null) { |
| g.copyArea(visibleBounds.x, visibleBounds.y, visibleBounds.width, visibleBounds.height, dx, dy); |
| } |
| if (dy < 0) { |
| refreshRect.y = visibleBounds.y + visibleBounds.height + dy; |
| } |
| refreshRect.height = Math.abs(dy); |
| //System.out.println("refreshRect=" + refreshRect); |
| } |
| |
| letBehaviorDraw(g, refreshRect); |
| } |
| |
| private Rectangle getInsetBounds() { |
| |
| int insetDim = 2 * fInsetAmount; |
| return new Rectangle(fBounds.x-fInsetAmount, |
| fBounds.y-fInsetAmount, |
| fBounds.width+insetDim, |
| fBounds.height+insetDim); |
| } |
| |
| void paint(Graphics g) { |
| |
| Rectangle hostBounds = fHost.getBounds(); |
| Rectangle textRefreshRect = hostBounds.intersection(getInsetBounds()); |
| letBehaviorDraw(g, textRefreshRect); |
| } |
| |
| Rectangle getCaretRect(TextOffset offset) { |
| |
| return fFormatter.getCaretRect(offset, fOrigin); |
| } |
| |
| TextOffset pointToTextOffset(TextOffset result, |
| int x, |
| int y, |
| TextOffset anchor, |
| boolean infiniteMode) { |
| |
| return fFormatter.pointToTextOffset(result, x, y, fOrigin, anchor, infiniteMode); |
| } |
| |
| Rectangle getScrollableArea() { |
| |
| Rectangle area = new Rectangle(fBounds); |
| area.x += fInsetAmount - fOrigin.x; |
| area.y += fInsetAmount - fOrigin.y; |
| return area; |
| } |
| |
| /** |
| * Doesn't clone so TextComponent needs to be nice. TextComponent |
| * is the only class which can access this anyway. |
| */ |
| Rectangle getDocumentBounds() { |
| |
| return fBounds; |
| } |
| |
| int getDocX() { |
| |
| return fOrigin.x - fInsetAmount; |
| } |
| |
| int getDocY() { |
| |
| return fOrigin.y - fInsetAmount; |
| } |
| |
| int lineContaining(TextOffset offset) { |
| |
| return fFormatter.lineContaining(offset); |
| } |
| |
| int lineRangeLow(int lineNumber) { |
| |
| return fFormatter.lineRangeLow(lineNumber); |
| } |
| |
| int lineRangeLimit(int lineNumber) { |
| |
| return fFormatter.lineRangeLimit(lineNumber); |
| } |
| |
| void stopBackgroundFormatting() { |
| |
| fFormatter.stopBackgroundFormatting(); |
| } |
| |
| Rectangle getBoundingRect(TextOffset offset1, TextOffset offset2) { |
| |
| Rectangle r = fFormatter.getBoundingRect(offset1, offset2, fOrigin, MFormatter.TIGHT); |
| //r.width += CARET_SLOP; |
| //System.out.println("offset1="+offset1+"; offset2="+offset2); |
| //System.out.println("bounds width="+r.width+"; host width="+(fHost.getBounds().width)); |
| return r; |
| } |
| |
| TextOffset findNewInsertionOffset(TextOffset result, |
| TextOffset initialOffset, |
| TextOffset previousOffset, |
| short direction) { |
| |
| return fFormatter.findNewInsertionOffset( |
| result, initialOffset, previousOffset, direction); |
| } |
| } |
| } |
