| /* |
| * (C) Copyright IBM Corp. 1998-2004. 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.uiimpl; |
| |
| import java.awt.Color; |
| import java.awt.Component; |
| import java.awt.Dimension; |
| import java.awt.FontMetrics; |
| import java.awt.Graphics; |
| import java.awt.Image; |
| |
| import java.awt.event.MouseMotionListener; |
| import java.awt.event.MouseListener; |
| import java.awt.event.MouseEvent; |
| |
| import com.ibm.richtext.textlayout.attributes.AttributeMap; |
| import com.ibm.richtext.textlayout.attributes.TextAttribute; |
| |
| import com.ibm.richtext.styledtext.MTabRuler; |
| import com.ibm.richtext.styledtext.StandardTabRuler; |
| import com.ibm.richtext.styledtext.TabStop; |
| import com.ibm.richtext.styledtext.StyleModifier; |
| |
| import com.ibm.richtext.textpanel.TextPanelListener; |
| import com.ibm.richtext.textpanel.MTextPanel; |
| import com.ibm.richtext.textpanel.TextPanel; |
| import com.ibm.richtext.textpanel.TextPanelEvent; |
| |
| /** |
| * TabRuler is a Component which presents a user interface for |
| * setting the leading margin, trailing margin, first line indent, |
| * and tab types and positions. |
| * <p> |
| * TabRuler does not implement TextPanelListener directly; however, |
| * it can receive updates from a MTextPanel. To have a TabRuler listen |
| * to a panel, call <code>listenToPanel</code>. TabRuler responds to |
| * user manipulation by modifying the paragraph styles on its MTextPanel |
| * (if any). |
| */ |
| public final class TabRulerImpl implements MouseListener, MouseMotionListener |
| { |
| static final String COPYRIGHT = |
| "(C) Copyright IBM Corp. 1998-1999 - All Rights Reserved"; |
| private static final class TabStopBuffer { |
| public int fPosition; |
| public byte fType; |
| |
| TabStopBuffer(int position, byte type) { |
| fPosition = position; |
| fType = type; |
| } |
| |
| TabStopBuffer(TabStop tab) { |
| this(tab.getPosition(), tab.getType()); |
| } |
| |
| TabStop getTabStop() { |
| return new TabStop(fPosition, fType); |
| } |
| } |
| |
| private static final class TabRulerModifier extends StyleModifier { |
| |
| private TabStop fOldTab; // tab to remove |
| private TabStop fNewTab; // tab to add |
| private AttributeMap fPanelDefaults; |
| |
| TabRulerModifier(TabStop oldTab, |
| TabStop newTab, |
| AttributeMap panelDefaults) { |
| fOldTab = oldTab; |
| fNewTab = newTab; |
| fPanelDefaults = panelDefaults; |
| } |
| |
| public AttributeMap modifyStyle(AttributeMap oldStyle) { |
| |
| MTabRuler oldRuler = (MTabRuler) getWithDefault(TextAttribute.TAB_RULER, |
| oldStyle, |
| fPanelDefaults); |
| MTabRuler ruler = oldRuler; |
| |
| if (fOldTab != null) { |
| if (ruler.containsTab(fOldTab)) { |
| ruler = ruler.removeTab(fOldTab.getPosition()); |
| } |
| } |
| if (fNewTab != null) { |
| ruler = ruler.addTab(fNewTab); |
| } |
| |
| if (ruler != oldRuler) { |
| return oldStyle.addAttribute(TextAttribute.TAB_RULER, ruler); |
| } |
| else { |
| return oldStyle; |
| } |
| } |
| } |
| |
| private static final class ImageCache { |
| |
| static final String COPYRIGHT = |
| "(C) Copyright IBM Corp. 1998-1999 - All Rights Reserved"; |
| private Image fImage = null; |
| private boolean fIsValid = false; |
| private Component fComponent; // workaround for compiler bug, |
| // should just be able to say Component.this |
| // if this were not a static class |
| |
| ImageCache(Component component) { |
| |
| fComponent = component; |
| } |
| |
| Graphics getGraphics(int width, int height) { |
| |
| if (width <= 0 || height <= 0) { |
| return null; |
| } |
| |
| Image image = fImage; |
| if (image == null || image.getWidth(fComponent) < width |
| || image.getHeight(fComponent) < height) { |
| if (!fComponent.isVisible()) { // fix race condition if component not fully initialized |
| return null; |
| } |
| image = fComponent.createImage(width, height); |
| } |
| Graphics g = image.getGraphics(); |
| fImage = image; |
| return g; |
| } |
| |
| void drawImage(Graphics g, int x, int y, Color color) { |
| |
| if (!fIsValid) { |
| throw new Error("Drawing image when not valid"); |
| } |
| g.drawImage(fImage, x, y, color, fComponent); |
| } |
| |
| boolean isValid() { |
| |
| return fIsValid; |
| } |
| |
| void setValid(boolean isValid) { |
| |
| fIsValid = isValid; |
| } |
| } |
| |
| /** |
| * This class listens to a MTextPanel for changes which |
| * affect a TabRuler's appearance, and updates the TabRuler |
| * as necessary. |
| * @see TabRuler |
| * @see com.ibm.richtext.textpanel.MTextPanel |
| */ |
| private static final class Updater implements TextPanelListener { |
| |
| static final String COPYRIGHT = |
| "(C) Copyright IBM Corp. 1998-1999 - All Rights Reserved"; |
| private TabRulerImpl fTabRuler; |
| private MTextPanel fTextPanel; |
| |
| /** |
| * Create a new TabRulerUpdater. |
| * @param tabRuler the TabRuler to update when a change occurs |
| * in the MTextPanel |
| */ |
| Updater(TabRulerImpl tabRuler) { |
| |
| fTabRuler = tabRuler; |
| } |
| |
| /** |
| * Remove self as listener from previous MTextPanel, |
| * set current MTextPanel and listen to it (if not null). |
| */ |
| void setTextPanel(MTextPanel textPanel) { |
| |
| if (fTextPanel != null) { |
| fTextPanel.removeListener(this); |
| } |
| |
| fTextPanel = textPanel; |
| |
| if (fTextPanel != null) { |
| fTextPanel.addListener(this); |
| setAll(); |
| } |
| } |
| |
| private void setAll() { |
| |
| int offset = fTextPanel.getSelectionStart(); |
| boolean leftToRight = fTextPanel.paragraphIsLeftToRight(offset); |
| AttributeMap style = fTextPanel.getText().paragraphStyleAt(offset); |
| fTabRuler.set(style, false); |
| fTabRuler.setFormatWidth(fTextPanel.getFormatWidth(), false); |
| fTabRuler.setLeftToRight(leftToRight, true); |
| } |
| |
| /** |
| * TextPanelListener method. This class responds to text |
| * changes by updating its TabRuler. |
| */ |
| public void textEventOccurred(TextPanelEvent event) { |
| |
| int changeCode = event.getID(); |
| |
| if (changeCode == TextPanelEvent.SELECTION_STYLES_CHANGED || |
| changeCode == TextPanelEvent.TEXT_CHANGED) { |
| |
| int offset = fTextPanel.getSelectionStart(); |
| AttributeMap style = fTextPanel.getText().paragraphStyleAt(offset); |
| boolean leftToRight = fTextPanel.paragraphIsLeftToRight(offset); |
| fTabRuler.set(style, false); |
| fTabRuler.setLeftToRight(leftToRight, true); |
| } |
| else if (changeCode == TextPanelEvent.FORMAT_WIDTH_CHANGED) { |
| |
| fTabRuler.setFormatWidth(fTextPanel.getFormatWidth(), true); |
| } |
| } |
| |
| /** |
| * TextPanelListener method. |
| */ |
| public boolean respondsToEventType(int type) { |
| |
| return type == TextPanelEvent.SELECTION_STYLES_CHANGED || |
| type == TextPanelEvent.TEXT_CHANGED || |
| type == TextPanelEvent.FORMAT_WIDTH_CHANGED; |
| } |
| } |
| |
| /** |
| * The default background color for TabRulers. |
| * @see #setBackColor |
| */ |
| public static final Color DEFAULT_BACK_COLOR = Color.lightGray; |
| |
| private static final int kTrackNone = 0; |
| private static final int kTrackTab = 1; |
| private static final int kTrackLM = 2; |
| private static final int kTrackFLI = 3; |
| private static final int kTrackTM = 4; |
| |
| private Component fHost; |
| private MTabRuler fRuler; |
| private int fLeadingMargin; |
| private int fFirstLineIndent; |
| private int fFormatWidth; |
| private int fTrailingMarginPosition; // opposite of actual trailing margin |
| private boolean fLeftToRight; |
| private int fBaseline; |
| private int fOrigin; |
| private Color fBackColor = DEFAULT_BACK_COLOR; |
| |
| private int fTrackItem; // 0 - none, 1 - tab, 2 - lm, 3 - fli, 4 - tm |
| private TabStopBuffer fTrackTab; |
| private TabStop fOldTab; |
| private int fTrackDelta; |
| private boolean fTrackVisible; |
| private Updater fUpdater; |
| private MTextPanel fTextPanel = null; |
| |
| private ImageCache fImageCache; |
| |
| /** |
| * Create a new TabRuler. |
| * @param baseline the y-coordinate of the ruler's baseline |
| * @param origin the x-coordinate in this Component where |
| * the left margin appears |
| * @param textPanel the MTextPanel to listen to. This TabRuler |
| * will reflect the MTextPanel's paragraph styles, and update |
| * the paragraph styles when manipulated. |
| */ |
| public TabRulerImpl(int baseline, |
| int origin, |
| MTextPanel textPanel, |
| Component host) { |
| |
| fHost = host; |
| fImageCache = new ImageCache(host); |
| fUpdater = new Updater(this); |
| fBaseline = baseline; |
| fOrigin = origin; |
| host.addMouseListener(this); |
| host.addMouseMotionListener(this); |
| if (textPanel != null) { |
| listenToTextPanel(textPanel); |
| } |
| else { |
| fRuler = new StandardTabRuler(); |
| } |
| } |
| |
| /** |
| * Listen to the given MTextPanel and reflect its changes, |
| * and update its paragraph styles when TabRuler is |
| * manipulated. |
| * @param textPanel the MTextPanel to listen to |
| */ |
| public void listenToTextPanel(MTextPanel textPanel) { |
| |
| fTextPanel = textPanel; |
| fUpdater.setTextPanel(textPanel); |
| } |
| |
| /** |
| * Return the background color of this TabRuler. |
| * @return the background color of this TabRuler |
| */ |
| public Color getBackColor() { |
| |
| return fBackColor; |
| } |
| |
| /** |
| * Set the background color of this TabRuler. |
| * @param backColor the new background color of this TabRuler |
| */ |
| public void setBackColor(Color backColor) { |
| |
| if (!backColor.equals(fBackColor)) { |
| fBackColor = backColor; |
| Graphics g = fHost.getGraphics(); |
| if (g != null) { |
| paint(g); |
| } |
| } |
| } |
| |
| private static Object getWithDefault(Object key, |
| AttributeMap style, |
| AttributeMap defaults) { |
| Object value = style.get(key); |
| if (value == null) { |
| value = defaults.get(key); |
| } |
| return value; |
| } |
| |
| private static float getFloatWithDefault(Object key, |
| AttributeMap style, |
| AttributeMap defaults) { |
| Object value = getWithDefault(key, style, defaults); |
| return ((Float)value).floatValue(); |
| } |
| |
| private void setLeftToRight(boolean leftToRight, boolean update) { |
| |
| if (fLeftToRight != leftToRight) { |
| |
| fLeftToRight = leftToRight; |
| redrawSelf(update); |
| } |
| } |
| |
| private void setFormatWidth(int formatWidth, boolean update) { |
| |
| if (fFormatWidth != formatWidth) { |
| |
| fTrailingMarginPosition += (formatWidth - fFormatWidth); |
| fFormatWidth = formatWidth; |
| redrawSelf(update); |
| } |
| } |
| |
| /** |
| * Set TabRuler from values in paragraphStyle. Only TabRulerUpdater |
| * should call this method. |
| * @param paragraphStyle the paragraph style which the TabRuler will |
| * reflect |
| */ |
| private void set(AttributeMap paragraphStyle, boolean update) { |
| |
| AttributeMap panelDefaults; |
| |
| if (fTextPanel==null) { |
| panelDefaults = TextPanel.getDefaultSettings().getDefaultValues(); |
| } |
| else { |
| panelDefaults = fTextPanel.getDefaultValues(); |
| } |
| |
| int leadingMargin = (int) getFloatWithDefault(TextAttribute.LEADING_MARGIN, |
| paragraphStyle, |
| panelDefaults); |
| int firstLineIndent = (int) getFloatWithDefault(TextAttribute.FIRST_LINE_INDENT, |
| paragraphStyle, |
| panelDefaults); |
| int trailingMargin = (int) getFloatWithDefault(TextAttribute.TRAILING_MARGIN, |
| paragraphStyle, |
| panelDefaults); |
| |
| MTabRuler ruler = (MTabRuler) getWithDefault(TextAttribute.TAB_RULER, |
| paragraphStyle, |
| panelDefaults); |
| |
| int ourFli = leadingMargin + firstLineIndent; |
| int ourTmp = fFormatWidth - trailingMargin; |
| |
| if (leadingMargin == fLeadingMargin && |
| fFirstLineIndent == ourFli && |
| fTrailingMarginPosition == ourTmp && |
| ruler.equals(fRuler)) { |
| return; |
| } |
| |
| fLeadingMargin = leadingMargin; |
| fFirstLineIndent = ourFli; |
| fTrailingMarginPosition = ourTmp; |
| fRuler = ruler; |
| |
| redrawSelf(update); |
| } |
| |
| private void redrawSelf(boolean drawNow) { |
| |
| fImageCache.setValid(false); |
| |
| Graphics g = fHost.getGraphics(); |
| if (g != null) |
| paint(g); |
| } |
| |
| /** |
| * Return debugging info. |
| */ |
| public String toString() { |
| |
| return "TabRuler{fLeadingMargin="+fLeadingMargin+ |
| "}{fFirstLineIndent="+fFirstLineIndent+ |
| "}{fFormatWidth="+fFormatWidth+ |
| "}{fTrailingMarginPosition="+fTrailingMarginPosition+ |
| "}{fRuler="+fRuler+ |
| "}"; |
| } |
| |
| /** |
| * Return the MTabRuler represented by this TabRuler. |
| * @return the MTabRuler represented by this TabRuler |
| */ |
| public MTabRuler getRuler() |
| { |
| return fRuler; |
| } |
| |
| /** |
| * Return the leading margin of this TabRuler. |
| * @return the leading margin of this TabRuler |
| */ |
| public int getLeadingMargin() |
| { |
| return fLeadingMargin; |
| } |
| |
| /** |
| * Return the first line indent of this TabRuler. |
| * @return the first line indent of this TabRuler |
| */ |
| public int getFirstLineIndent() |
| { |
| return fFirstLineIndent - fLeadingMargin; |
| } |
| |
| /** |
| * Return the trailing margin of this TabRuler. |
| * @return the trailing margin of this TabRuler |
| */ |
| public final int getTrailingMargin() |
| { |
| return fFormatWidth - fTrailingMarginPosition; |
| } |
| |
| private int visualToRulerPos(int visPos) { |
| |
| if (fLeftToRight) { |
| return visPos - fOrigin; |
| } |
| else { |
| return fOrigin + fFormatWidth - visPos; |
| } |
| } |
| |
| private int rulerToVisualPos(int rulerPos) { |
| |
| if (fLeftToRight) { |
| return fOrigin + rulerPos; |
| } |
| else { |
| return fOrigin + fFormatWidth - rulerPos; |
| } |
| } |
| |
| private int dirMult() { |
| |
| return fLeftToRight? 1 : -1; |
| } |
| |
| /** |
| * @param tabPosition the logical (ruler) position of the tab |
| */ |
| private void drawTab(Graphics g, int tabPosition, byte tabType, int tabTop, int tabBottom) |
| { |
| int pos = rulerToVisualPos(tabPosition); |
| int wid = 0; |
| switch (tabType) { |
| case TabStop.kLeading: wid = 3; break; |
| case TabStop.kCenter: wid = 0; break; |
| case TabStop.kTrailing: wid = -3; break; |
| case TabStop.kDecimal: wid = 0; break; |
| default: break; |
| } |
| wid *= dirMult(); |
| |
| if (tabType != TabStop.kAuto) { |
| g.drawLine(pos, tabTop, pos, tabBottom); |
| if (wid != 0) |
| g.drawLine(pos, tabBottom, pos + wid, tabBottom); |
| } |
| g.drawLine(pos-2, tabTop+2, pos, tabTop); |
| g.drawLine(pos, tabTop, pos+2, tabTop+2); |
| if (tabType == TabStop.kDecimal) { |
| g.drawLine(pos + 3, tabBottom, pos + 4, tabBottom); |
| } |
| } |
| |
| private void drawLM(Graphics g) |
| { |
| int pos = rulerToVisualPos(fLeadingMargin); |
| int[] xpts = { pos, pos, pos + (4*dirMult()), pos }; |
| int[] ypts = { fBaseline + 12, fBaseline + 7, fBaseline + 7, fBaseline + 12 }; |
| g.fillPolygon(xpts, ypts, 3); |
| g.drawPolygon(xpts, ypts, 4); |
| } |
| |
| private void drawFLI(Graphics g) |
| { |
| int pos = rulerToVisualPos(fFirstLineIndent); |
| int[] xpts = { pos, pos, pos + (4*dirMult()), pos }; |
| int[] ypts = { fBaseline, fBaseline + 5, fBaseline + 5, fBaseline }; |
| g.fillPolygon(xpts, ypts, 3); |
| g.drawPolygon(xpts, ypts, 4); |
| } |
| |
| private void drawRM(Graphics g) |
| { |
| int pos = rulerToVisualPos(fTrailingMarginPosition); |
| int[] xpts = { pos, pos, pos - (6*dirMult()), pos }; |
| int[] ypts = { fBaseline, fBaseline + 12, fBaseline + 6, fBaseline }; |
| g.fillPolygon(xpts, ypts, 3); |
| g.drawPolygon(xpts, ypts, 4); |
| } |
| |
| private static int alignInt(int value) { |
| |
| return (int)((int)(value / 4.5) * 4.5); |
| } |
| |
| private static final int[] fgLengths = { 10, 2, 4, 2, 6, 2, 4, 2 }; |
| |
| /** |
| * Component method override. |
| */ |
| public void paint(Graphics g) |
| { |
| Dimension size = fHost.getSize(); |
| |
| int width = size.width; |
| int baseline = fBaseline; |
| int baseline2 = baseline + 2; |
| int baseline10 = baseline + 10; |
| int baseline12 = baseline + 12; |
| |
| if (!fImageCache.isValid()) { |
| |
| Graphics gCache = fImageCache.getGraphics(width, baseline12 + 1); |
| if (gCache == null) { |
| return; |
| } |
| |
| // set background color |
| |
| gCache.setColor(fBackColor); |
| gCache.setPaintMode(); |
| gCache.fillRect(0, 0, width, baseline12 + 1); |
| |
| // paint ticks |
| |
| gCache.setColor(Color.black); |
| gCache.drawLine(0, 0, width, 0); |
| gCache.drawLine(0, baseline, width, baseline); |
| |
| int[] lengths = fgLengths; |
| |
| int index = 0; |
| int inchnum = 0; |
| FontMetrics fm = null; |
| if (!fLeftToRight) { |
| fm = gCache.getFontMetrics(); |
| } |
| |
| for (int i = 0; i < fFormatWidth; i += 9) { |
| int len = lengths[index]; |
| int pos = rulerToVisualPos(i); |
| gCache.drawLine(pos, baseline, pos, baseline - len); |
| |
| if (index == 0) { |
| String str = Integer.toString(inchnum++); |
| int drawX; |
| if (fLeftToRight) { |
| drawX = pos + 2; |
| } |
| else { |
| drawX = pos - fm.stringWidth(str) - 2; |
| } |
| |
| gCache.drawString(str, drawX, baseline - 2); |
| } |
| |
| if (++index == lengths.length) |
| index = 0; |
| } |
| |
| // paint tabs |
| TabStop tab = fRuler.firstTab(); |
| while (tab != null && tab.getPosition() < fTrailingMarginPosition) { |
| boolean dodraw = true; |
| if (tab.getType() == TabStop.kAuto) { |
| if (tab.getPosition() <= Math.max(fLeadingMargin, fFirstLineIndent)) |
| dodraw = false; |
| else if (tab.getPosition() >= fTrailingMarginPosition) |
| dodraw = false; |
| } |
| |
| if (dodraw) |
| drawTab(gCache, tab.getPosition(), tab.getType(), baseline2, baseline10); |
| |
| tab = fRuler.nextTab(tab.getPosition()); |
| } |
| |
| gCache.drawLine(0, baseline12, width, baseline12); |
| |
| // paint others except for tracked item |
| if (fTrackItem != kTrackLM) drawLM(gCache); |
| if (fTrackItem != kTrackTM) drawRM(gCache); |
| if (fTrackItem != kTrackFLI && fTrackItem != kTrackLM) drawFLI(gCache); |
| fImageCache.setValid(true); |
| } |
| |
| fImageCache.drawImage(g, 0, 0, Color.lightGray); |
| |
| switch (fTrackItem) { |
| case kTrackTab: if (fTrackVisible) drawTab(g, fTrackTab.fPosition, fTrackTab.fType, baseline2, baseline10); break; |
| case kTrackLM: drawLM(g); drawFLI(g); break; |
| case kTrackTM: drawRM(g); break; |
| case kTrackFLI: drawFLI(g); break; |
| default: break; |
| } |
| } |
| |
| /** |
| * MouseListener method. |
| */ |
| public void mouseClicked(MouseEvent e) {} |
| /** |
| * MouseListener method. |
| */ |
| public void mouseEntered(MouseEvent e) {} |
| /** |
| * MouseListener method. |
| */ |
| public void mouseExited(MouseEvent e) {} |
| |
| /** |
| * MouseListener method. |
| */ |
| public void mousePressed(MouseEvent e) |
| { |
| // find out if we hit a tabstop |
| int x = visualToRulerPos(e.getX()); |
| int y = e.getY(); |
| |
| if (y > fBaseline && y < fBaseline + 12) { |
| if (y >= fBaseline + 7 && x >= fLeadingMargin - 3 && x <= fLeadingMargin + 3) { |
| fTrackItem = kTrackLM; |
| fTrackDelta = fLeadingMargin - x; |
| } else if (y < fBaseline + 7 && x >= fFirstLineIndent - 3 && x <= fFirstLineIndent + 3) { |
| fTrackItem = kTrackFLI; |
| fTrackDelta = fFirstLineIndent - x; |
| } else if (x >= fTrailingMarginPosition - 3 && x <= fTrailingMarginPosition + 3) { |
| fTrackItem = kTrackTM; |
| fTrackDelta = fTrailingMarginPosition - x; |
| } else if (e.isControlDown()) { |
| fTrackItem = kTrackTab; |
| fTrackTab = new TabStopBuffer(alignInt(x), TabStop.kLeading); |
| fTrackDelta = fTrackTab.fPosition - x; |
| fTrackVisible = true; |
| } else { |
| TabStop tab = fRuler.firstTab(); |
| while (tab.getType() != TabStop.kAuto) { |
| if (x < tab.getPosition() - 3) |
| break; |
| if (x < tab.getPosition() + 3) { |
| fOldTab = tab; |
| fTrackTab = new TabStopBuffer(tab); |
| fRuler = fRuler.removeTab(fOldTab.getPosition()); |
| |
| if (e.getClickCount() > 1) { |
| switch (fTrackTab.fType) { |
| case TabStop.kLeading: fTrackTab.fType = TabStop.kCenter; break; |
| case TabStop.kCenter: fTrackTab.fType = TabStop.kTrailing; break; |
| case TabStop.kTrailing: fTrackTab.fType = TabStop.kDecimal; break; |
| case TabStop.kDecimal: fTrackTab.fType = TabStop.kLeading; break; |
| default: break; |
| } |
| } |
| fTrackItem = kTrackTab; |
| fTrackDelta = tab.getPosition() - x; |
| fTrackVisible = true; |
| break; |
| } |
| |
| tab = fRuler.nextTab(tab.getPosition()); |
| } |
| } |
| |
| if (fTrackItem != kTrackNone) { |
| fImageCache.setValid(false); |
| paint(fHost.getGraphics()); |
| return; |
| } |
| } |
| } |
| |
| /** |
| * MouseListener method. |
| */ |
| public void mouseDragged(MouseEvent e) |
| { |
| int x = visualToRulerPos(e.getX()); |
| int y = e.getY(); |
| |
| if (fTrackItem != kTrackNone) { |
| boolean repaint = false; |
| boolean inrange = y > fBaseline && y < fBaseline + 12; |
| boolean inbigrange = y > 0 && y < fHost.getSize().height + 20; |
| int newpos = alignInt(x + fTrackDelta); |
| if (newpos < 0) |
| newpos = 0; |
| |
| switch (fTrackItem) { |
| case kTrackTab: { |
| if (inrange) { |
| repaint = !fTrackVisible; |
| fTrackVisible = true; |
| if (newpos != fTrackTab.fPosition) { |
| fTrackTab.fPosition = newpos; |
| repaint = true; |
| } |
| } else if (fTrackVisible) { |
| fTrackVisible = false; |
| repaint = true; |
| } |
| } break; |
| |
| /* It would be nice to optionally track the margin 'independently' of the first line indent. |
| Unfortunately this makes for more work when we have multiple paragraph styles selected. |
| Since internally the first line indent is relative to the margin, moving the margin |
| independently so that all affected paragraphs share the same margin but retain first |
| line indents in the 'same' positions means that I need to also adjust the first line |
| indents in each paragraph by some delta. I'm not ready to do that yet. */ |
| |
| case kTrackLM: { |
| if (inbigrange && newpos != fLeadingMargin) { |
| fFirstLineIndent += newpos - fLeadingMargin; |
| fLeadingMargin = newpos; |
| repaint = true; |
| } |
| } break; |
| |
| case kTrackFLI: { |
| if (inbigrange && newpos != fFirstLineIndent) { |
| fFirstLineIndent = newpos; |
| repaint = true; |
| } |
| } break; |
| |
| case kTrackTM: { |
| if (inbigrange && newpos != fTrailingMarginPosition) { |
| fTrailingMarginPosition = newpos; |
| repaint = true; |
| } |
| } break; |
| } |
| |
| |
| if (repaint) |
| paint(fHost.getGraphics()); |
| } |
| } |
| |
| /** |
| * MouseListener method. |
| */ |
| public void mouseReleased(MouseEvent e) |
| { |
| if (fTrackItem != kTrackNone) { |
| if (fTrackItem == kTrackTab && fTrackVisible) { |
| fRuler = fRuler.addTab(fTrackTab.getTabStop()); |
| } else { |
| fTrackTab = null; |
| } |
| |
| notify(fTrackItem); |
| |
| fTrackItem = kTrackNone; |
| fTrackTab = null; |
| fOldTab = null; |
| |
| fImageCache.setValid(false); |
| paint(fHost.getGraphics()); |
| } |
| } |
| |
| /** |
| * MouseListener method. |
| */ |
| public void mouseMoved(MouseEvent e) {} |
| |
| private void notify(int change) |
| { |
| if (fTextPanel != null) { |
| |
| StyleModifier modifier; |
| |
| if (change == kTrackTab) { |
| TabStop newTab = fTrackTab==null? null : fTrackTab.getTabStop(); |
| modifier = new TabRulerModifier(fOldTab, newTab, fTextPanel.getDefaultValues()); |
| } |
| else { |
| Object key; |
| Object value; |
| |
| switch(change) { |
| case kTrackLM: |
| key = TextAttribute.LEADING_MARGIN; |
| value = new Float(getLeadingMargin()); |
| break; |
| |
| case kTrackTM: |
| key = TextAttribute.TRAILING_MARGIN; |
| value = new Float(getTrailingMargin()); |
| break; |
| |
| case kTrackFLI: |
| key = TextAttribute.FIRST_LINE_INDENT; |
| value = new Float(getFirstLineIndent()); |
| break; |
| |
| default: |
| throw new Error("Invalid change code."); |
| } |
| |
| modifier = StyleModifier.createAddModifier(key, value); |
| } |
| |
| fTextPanel.modifyParagraphStyleOnSelection(modifier); |
| } |
| } |
| |
| /** |
| * Component override. |
| */ |
| public Dimension getMinimumSize() |
| { |
| return new Dimension(100, fBaseline + 13); |
| } |
| |
| /** |
| * Component override. |
| */ |
| public Dimension getPreferredSize() |
| { |
| return getMinimumSize(); |
| } |
| } |
