import org.eclipse.jface.text.hyperlink.MultipleHyperlinkPresenter;

/*******************************************************************************

 * Copyright (c) 2007, 2008 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.jface.internal.text;

import org.eclipse.jface.text.IRegion;

import org.eclipse.jface.text.ITextViewer;

import org.eclipse.jface.text.ITextViewerExtension5;

import org.eclipse.jface.text.Region;

import org.eclipse.swt.custom.StyledText;

import org.eclipse.swt.graphics.GC;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.graphics.Rectangle;

/**

 * @since 3.4

 */

public class TextUtils {

	/**

	 * Determines graphical area covered by the given text region in

	 * the given viewer.

	 *

	 * @param region the region whose graphical extend must be computed

	 * @param textViewer the text viewer containing the region

	 * @return the graphical extend of the given region in the given viewer

	 */

	public static Rectangle computeArea(IRegion region, ITextViewer textViewer) {

		int start= 0;

		int end= 0;

		IRegion widgetRegion= modelRange2WidgetRange(region, textViewer);

		if (widgetRegion != null) {

			start= widgetRegion.getOffset();

			end= start + widgetRegion.getLength();

		}

		StyledText styledText= textViewer.getTextWidget();

		Rectangle bounds;

		if (end > 0 && start < end)

			bounds= styledText.getTextBounds(start, end - 1);

		else {

			Point loc= styledText.getLocationAtOffset(start);

			bounds= new Rectangle(loc.x, loc.y, getAverageCharWidth(textViewer.getTextWidget()), styledText.getLineHeight(start));

		}

		return new Rectangle(bounds.x, bounds.y, bounds.width, bounds.height);

	}

	/**

	 * Translates a given region of the text viewer's document into

	 * the corresponding region of the viewer's widget.

	 *

	 * @param region the document region

	 * @param textViewer the viewer containing the region 

	 * @return the corresponding widget region

	 * @since 2.1

	 */

	private static IRegion modelRange2WidgetRange(IRegion region, ITextViewer textViewer) {

		if (textViewer instanceof ITextViewerExtension5) {

			ITextViewerExtension5 extension= (ITextViewerExtension5) textViewer;

			return extension.modelRange2WidgetRange(region);

		}

		IRegion visibleRegion= textViewer.getVisibleRegion();

		int start= region.getOffset() - visibleRegion.getOffset();

		int end= start + region.getLength();

		if (end > visibleRegion.getLength())

			end= visibleRegion.getLength();

		return new Region(start, end - start);

	}

	/**

	 * Returns the average character width of the given widget.

	 *

	 * @param widget the widget to calculate the average char width for

	 * @return the average character width of the given widget

	 */

	public static int getAverageCharWidth(StyledText widget) {

		GC gc= new GC(widget);

		gc.setFont(widget.getFont());

		int increment= gc.getFontMetrics().getAverageCharWidth();

		gc.dispose();

		return increment;

	}

}

/*******************************************************************************

 * Copyright (c) 2007, 2008 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.jface.text.hyperlink;

import org.eclipse.jface.internal.text.TextUtils;

import org.eclipse.jface.preference.IPreferenceStore;

import org.eclipse.jface.resource.JFaceResources;

import org.eclipse.jface.text.AbstractInformationControl;

import org.eclipse.jface.text.AbstractInformationControlManager;

import org.eclipse.jface.text.IInformationControl;

import org.eclipse.jface.text.IInformationControlCreator;

import org.eclipse.jface.text.IInformationControlExtension2;

import org.eclipse.jface.text.IInformationControlExtension3;

import org.eclipse.jface.text.IRegion;

import org.eclipse.jface.text.ITextHover;

import org.eclipse.jface.text.ITextHoverExtension;

import org.eclipse.jface.text.ITextViewer;

import org.eclipse.jface.text.IWidgetTokenKeeper;

import org.eclipse.jface.text.IWidgetTokenKeeperExtension;

import org.eclipse.jface.text.IWidgetTokenOwner;

import org.eclipse.jface.text.IWidgetTokenOwnerExtension;

import org.eclipse.jface.text.Region;

import org.eclipse.jface.util.Geometry;

import org.eclipse.swt.SWT;

import org.eclipse.swt.custom.ScrolledComposite;

import org.eclipse.swt.events.KeyEvent;

import org.eclipse.swt.events.KeyListener;

import org.eclipse.swt.events.MouseEvent;

import org.eclipse.swt.events.MouseListener;

import org.eclipse.swt.events.MouseMoveListener;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.graphics.RGB;

import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Event;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Listener;

import org.eclipse.swt.widgets.ScrollBar;

import org.eclipse.swt.widgets.Shell;

import com.ibm.icu.text.MessageFormat;

/**

 * A hyperlink presenter capable of showing multiple hyperlinks in a hover.

 * 

 * @since 3.4

 */

public class MultipleHyperlinkPresenter extends DefaultHyperlinkPresenter {

	/**

	 * An information control capable of showing a list of hyperlinks. The hyperlinks can be opened.

	 */

	private static class LinkListInformationControl extends AbstractInformationControl implements IInformationControlExtension2 {

		private IHyperlink[] fInput;

		private Composite fParent;

		/**

		 * Creates a link list information control with the given shell as parent.

		 *

		 * @param parentShell the parent shell

		 */

		public LinkListInformationControl(Shell parentShell) {

			super(parentShell, false);

			create();

		}

		/* (non-Javadoc)

		 * @see org.eclipse.jface.text.IInformationControl#setInformation(java.lang.String)

		 */

		public void setInformation(String information) {

			//replaced by IInformationControlExtension2#setInput(java.lang.Object)

		}

		/* (non-Javadoc)

		 * @see org.eclipse.jface.text.IInformationControlExtension2#setInput(java.lang.Object)

		 */

		public void setInput(Object input) {

			fInput= (IHyperlink[]) input;

			deferredCreateContent(fParent);

		}

		/* (non-Javadoc)

		 * @see org.eclipse.jface.text.AbstractInformationControl#createContent(org.eclipse.swt.widgets.Composite)

		 */

		protected void createContent(Composite parent) {

			fParent= new Composite(parent, SWT.NONE);

			fParent.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

			GridLayout layout= new GridLayout(1, false);

			layout.marginHeight= 0;

			layout.marginWidth= 0;

			fParent.setLayout(layout);

		}

		/* (non-Javadoc)

		 * @see org.eclipse.jface.text.AbstractInformationControl#computeSizeHint()

		 */

		public Point computeSizeHint() {

			Point minSize= getShell().computeSize(SWT.DEFAULT, SWT.DEFAULT, true);

			Point constraints= getSizeConstraints();

			if (constraints == null)

				return minSize;

			return Geometry.min(minSize, constraints);

		}

		private void deferredCreateContent(Composite parent) {

			ScrolledComposite scrolledComposite= new ScrolledComposite(parent, SWT.H_SCROLL | SWT.V_SCROLL);

			GridData gridData= new GridData(SWT.FILL, SWT.FILL, true, true);

			scrolledComposite.setLayoutData(gridData);

			scrolledComposite.setExpandVertical(false);

			scrolledComposite.setExpandHorizontal(false);

			Composite composite= createLinks(scrolledComposite);

			scrolledComposite.setContent(composite);

			Point point= composite.computeSize(SWT.DEFAULT, SWT.DEFAULT);

			composite.setSize(point);

			scrolledComposite.setMinSize(point);

			Point contentSize= composite.computeSize(SWT.DEFAULT, SWT.DEFAULT);

			Point constraints= getSizeConstraints();

			if (constraints != null && contentSize.x < constraints.x) {

				ScrollBar horizontalBar= scrolledComposite.getHorizontalBar();

				int scrollBarHeight;

				if (horizontalBar == null) {

					Point scrollSize= scrolledComposite.computeSize(SWT.DEFAULT, SWT.DEFAULT);

					scrollBarHeight= scrollSize.y - contentSize.y;

				} else {

					scrollBarHeight= horizontalBar.getSize().y;

				}

				gridData.heightHint= contentSize.y - scrollBarHeight;

			}

			if (constraints != null && contentSize.y < constraints.y) {

				ScrollBar verticalBar= scrolledComposite.getVerticalBar();

				int scrollBarWidth;

				if (verticalBar == null) {

					Point scrollSize= scrolledComposite.computeSize(SWT.DEFAULT, SWT.DEFAULT);

					scrollBarWidth= scrollSize.x - contentSize.x;

				} else {

					scrollBarWidth= verticalBar.getSize().x;

				}

				gridData.widthHint= contentSize.x - scrollBarWidth;

			}

		}

		private Composite createLinks(Composite parent) {

			Composite composite= new Composite(parent, SWT.NONE);

			composite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

			GridLayout layout= new GridLayout(1, false);

			layout.marginWidth= 2;

			layout.marginHeight= 2;

			layout.verticalSpacing= 0;

			composite.setLayout(layout);

			composite.setBackground(composite.getDisplay().getSystemColor(SWT.COLOR_WHITE));

			final Composite[] menuEntries= new Composite[fInput.length];

			for (int i= 0; i < fInput.length; i++) {

				final IHyperlink link= fInput[i];

				final Composite labelComposite= new Composite(composite, SWT.NONE);

				labelComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

				GridLayout layout2= new GridLayout(1, false);

				layout2.marginHeight= 2;

				layout2.marginWidth= 2;

				labelComposite.setLayout(layout2);

				labelComposite.setBackground(composite.getBackground());

				menuEntries[i]= labelComposite;

				final Label label= new Label(labelComposite, SWT.NONE);

				label.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));

				label.setBackground(labelComposite.getBackground());

				String text= link.getHyperlinkText();

				if (text == null)

					text= HyperlinkMessages.getString("LinkListInformationControl.unknownLink"); //$NON-NLS-1$

				if (i == 0) {

					text= MessageFormat.format(HyperlinkMessages.getString("LinkListInformationControl.defaultLinkPattern"), new Object[] { text }); //$NON-NLS-1$

					label.setFont(JFaceResources.getFontRegistry().getBold(JFaceResources.DIALOG_FONT));

				}

				label.setText(text);

				label.addMouseListener(new MouseListener() {

					public void mouseDoubleClick(MouseEvent e) {

					}

					public void mouseDown(MouseEvent e) {

					}

					public void mouseUp(MouseEvent e) {

						LinkListInformationControl.this.dispose();

						link.open();

					}

				});

				label.addMouseMoveListener(new MouseMoveListener() {

					public void mouseMove(MouseEvent e) {

						Display display= labelComposite.getDisplay();

						for (int j= 0; j < menuEntries.length; j++) {

							setColor(menuEntries[j], display.getSystemColor(SWT.COLOR_WHITE), display.getSystemColor(SWT.COLOR_BLACK));

						}

						setColor(labelComposite, display.getSystemColor(SWT.COLOR_LIST_SELECTION), display.getSystemColor(SWT.COLOR_LIST_SELECTION_TEXT));

					}

					private void setColor(Control control, Color backColor, Color foreColor) {

						control.setBackground(backColor);

						control.setForeground(foreColor);

						if (control instanceof Composite) {

							Control[] children= ((Composite) control).getChildren();

							for (int j= 0; j < children.length; j++) {

								setColor(children[j], backColor, foreColor);

							}

						}

					}

				});

			}

			return composite;

		}

		/* (non-Javadoc)

		 * @see org.eclipse.jface.text.IInformationControlExtension#hasContents()

		 */

		public boolean hasContents() {

			return true;

		}

	}

	private class MultipleHyperlinkHover implements ITextHover, ITextHoverExtension {

		/**

		 * @see org.eclipse.jface.text.ITextHover#getHoverInfo(org.eclipse.jface.text.ITextViewer, org.eclipse.jface.text.IRegion)

		 * @deprecated

		 */

		public String getHoverInfo(ITextViewer textViewer, IRegion hoverRegion) {

			return null;

		}

		/* (non-Javadoc)

		 * @see org.eclipse.jface.text.ITextHover#getHoverRegion(org.eclipse.jface.text.ITextViewer, int)

		 */

		public IRegion getHoverRegion(ITextViewer textViewer, int offset) {

			return fSubjectRegion;

		}

		/* (non-Javadoc)

		 * @see org.eclipse.jface.text.ITextHoverExtension2#getHoverInfo2(org.eclipse.jface.text.ITextViewer, org.eclipse.jface.text.IRegion)

		 */

		public Object getHoverInfo2(ITextViewer textViewer, IRegion hoverRegion) {

			return fHyperlinks;

		}

		/* (non-Javadoc)

		 * @see org.eclipse.jface.text.ITextHoverExtension#getHoverControlCreator()

		 */

		public IInformationControlCreator getHoverControlCreator() {

			return new IInformationControlCreator() {

				public IInformationControl createInformationControl(Shell parent) {

					return new LinkListInformationControl(parent);

				}

			};

		}

	}

	private static class MultipleHyperlinkHoverManager extends AbstractInformationControlManager implements IWidgetTokenKeeper, IWidgetTokenKeeperExtension {

		private class Closer implements IInformationControlCloser, Listener, KeyListener {

			private Control fSubjectControl;

			private Display fDisplay;

			private IInformationControl fControl;

			private Rectangle fSubjectArea;

			/* (non-Javadoc)

			 * @see org.eclipse.jface.text.AbstractInformationControlManager.IInformationControlCloser#setInformationControl(org.eclipse.jface.text.IInformationControl)

			 */

			public void setInformationControl(IInformationControl control) {

				fControl= control;

			}

			/* (non-Javadoc)

			 * @see org.eclipse.jface.text.AbstractInformationControlManager.IInformationControlCloser#setSubjectControl(org.eclipse.swt.widgets.Control)

			 */

			public void setSubjectControl(Control subject) {

				fSubjectControl= subject;

			}

			/* (non-Javadoc)

			 * @see org.eclipse.jface.text.AbstractInformationControlManager.IInformationControlCloser#start(org.eclipse.swt.graphics.Rectangle)

			 */

			public void start(Rectangle subjectArea) {

				fSubjectArea= subjectArea;

				fDisplay= fSubjectControl.getDisplay();

				if (!fDisplay.isDisposed()) {

					fDisplay.addFilter(SWT.FocusOut, this);

					fDisplay.addFilter(SWT.MouseMove, this);

					fTextViewer.getTextWidget().addKeyListener(this);

				}

			}

			/* (non-Javadoc)

			 * @see org.eclipse.jface.text.AbstractInformationControlManager.IInformationControlCloser#stop()

			 */

			public void stop() {

				if (fDisplay != null && !fDisplay.isDisposed()) {

					fDisplay.removeFilter(SWT.FocusOut, this);

					fDisplay.removeFilter(SWT.MouseMove, this);

					fTextViewer.getTextWidget().removeKeyListener(this);

				}

				fSubjectArea= null;

			}

			/* (non-Javadoc)

			 * @see org.eclipse.swt.widgets.Listener#handleEvent(org.eclipse.swt.widgets.Event)

			 */

			public void handleEvent(Event event) {

				switch (event.type) {

					case SWT.FocusOut:

						if (!fControl.isFocusControl())

							disposeInformationControl();

						break;

					case SWT.MouseMove:

						handleMouseMove(event);

						break;

				}

			}

			/**

			 * Handle mouse movement events.

			 * 

			 * @param event the event

			 * @since 3.4

			 */

			private void handleMouseMove(Event event) {

				if (!(event.widget instanceof Control))

					return;

				Control eventControl= (Control) event.widget;

				//transform coordinates to subject control:

				Point mouseLoc= event.display.map(eventControl, fSubjectControl, event.x, event.y);

				if (fSubjectArea.contains(mouseLoc))

					return;

				if (inKeepUpZone(mouseLoc.x, mouseLoc.y, ((IInformationControlExtension3) fControl).getBounds()))

					return;

				hideInformationControl();

			}

			/**

			 * Tests whether a given mouse location is within the keep-up zone.

			 * The hover should not be hidden as long as the mouse stays inside this zone.

			 * 

			 * @param x the x coordinate, relative to the <em>subject control</em>

			 * @param y the y coordinate, relative to the <em>subject control</em>

			 * @param controlBounds the bounds of the current control

			 * 

			 * @return <code>true</code> iff the mouse event occurred in the keep-up zone

			 */

			private boolean inKeepUpZone(int x, int y, Rectangle controlBounds) {

				Rectangle iControlBounds= fSubjectControl.getDisplay().map(null, fSubjectControl, controlBounds);

				Rectangle totalBounds= Geometry.copy(iControlBounds);

				// FIXME: should maybe use convex hull, not bounding box

				totalBounds.add(fSubjectArea);

				return totalBounds.contains(x, y);

			}

			/* (non-Javadoc)

			 * @see org.eclipse.swt.events.KeyListener#keyPressed(org.eclipse.swt.events.KeyEvent)

			 */

			public void keyPressed(KeyEvent e) {

			}

			/* (non-Javadoc)

			 * @see org.eclipse.swt.events.KeyListener#keyReleased(org.eclipse.swt.events.KeyEvent)

			 */

			public void keyReleased(KeyEvent e) {

				hideInformationControl();

			}

		}

		/**

		 * Priority of the hover managed by this manager.

		 * Default value: One higher then for the hovers 

		 * managed by TextViewerHoverManager.

		 */

		private static final int WIDGET_TOKEN_PRIORITY= 1;

		private final MultipleHyperlinkHover fHover;

		private final ITextViewer fTextViewer;

		private Closer fCloser;

		/**

		 * Create a new MultipleHyperlinkHoverManager. The MHHM can show and hide

		 * the given MultipleHyperlinkHover inside the given ITextViewer.

		 * 

		 * @param hover the hover to manage 

		 * @param viewer the viewer to show the hover in

		 */

		public MultipleHyperlinkHoverManager(MultipleHyperlinkHover hover, ITextViewer viewer) {

			super(hover.getHoverControlCreator());

			fHover= hover;

			fTextViewer= viewer;

			fCloser= new Closer();

			setCloser(fCloser);

		}

		/* (non-Javadoc)

		 * @see org.eclipse.jface.text.AbstractInformationControlManager#computeInformation()

		 */

		protected void computeInformation() {

			IRegion region= fHover.getHoverRegion(fTextViewer, -1);

			if (region == null) {

				setInformation(null, null);

				return;

			}

			Rectangle area= TextUtils.computeArea(region, fTextViewer);

			if (area == null || area.isEmpty()) {

				setInformation(null, null);

				return;

			}

			Object information= fHover.getHoverInfo2(fTextViewer, region);

			setCustomInformationControlCreator(fHover.getHoverControlCreator());

			setInformation(information, area);

		}

		/* (non-Javadoc)

		 * @see org.eclipse.jface.text.AbstractInformationControlManager#showInformationControl(org.eclipse.swt.graphics.Rectangle)

		 */

		protected void showInformationControl(Rectangle subjectArea) {

			if (fTextViewer instanceof IWidgetTokenOwnerExtension) {

				if (((IWidgetTokenOwnerExtension) fTextViewer).requestWidgetToken(this, WIDGET_TOKEN_PRIORITY))

					super.showInformationControl(subjectArea);

			} else if (fTextViewer instanceof IWidgetTokenOwner) {

				if (((IWidgetTokenOwner) fTextViewer).requestWidgetToken(this))

					super.showInformationControl(subjectArea);

			} else {

				super.showInformationControl(subjectArea);

			}

		}

		/* (non-Javadoc)

		 * @see org.eclipse.jface.text.AbstractInformationControlManager#hideInformationControl()

		 */

		protected void hideInformationControl() {

			super.hideInformationControl();

			if (fTextViewer instanceof IWidgetTokenOwner) {

				((IWidgetTokenOwner) fTextViewer).releaseWidgetToken(this);

			}

		}

		/* (non-Javadoc)

		 * @see org.eclipse.jface.text.IWidgetTokenKeeper#requestWidgetToken(org.eclipse.jface.text.IWidgetTokenOwner)

		 */

		public boolean requestWidgetToken(IWidgetTokenOwner owner) {

			hideInformationControl();

			return true;

		}

		/* (non-Javadoc)

		 * @see org.eclipse.jface.text.IWidgetTokenKeeperExtension#requestWidgetToken(org.eclipse.jface.text.IWidgetTokenOwner, int)

		 */

		public boolean requestWidgetToken(IWidgetTokenOwner owner, int priority) {

			if (priority < WIDGET_TOKEN_PRIORITY)

				return false;

			hideInformationControl();

			return true;

		}

		/* (non-Javadoc)

		 * @see org.eclipse.jface.text.IWidgetTokenKeeperExtension#setFocus(org.eclipse.jface.text.IWidgetTokenOwner)

		 */

		public boolean setFocus(IWidgetTokenOwner owner) {

			return false;

		}

	}

	private ITextViewer fTextViewer;

	private IHyperlink[] fHyperlinks;

	private Region fSubjectRegion;

	private MultipleHyperlinkHoverManager fManager;

	/**

	 * Creates a new multiple hyperlink presenter which uses

	 * {@link #HYPERLINK_COLOR} to read the color from the given preference store.

	 *

	 * @param store the preference store

	 */

	public MultipleHyperlinkPresenter(IPreferenceStore store) {

		super(store);

	}

	/**

	 * Creates a new multiple hyperlink presenter.

	 *

	 * @param color the hyperlink color, to be disposed by the caller

	 */

	public MultipleHyperlinkPresenter(RGB color) {

		super(color);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.text.hyperlink.DefaultHyperlinkPresenter#install(org.eclipse.jface.text.ITextViewer)

	 */

	public void install(ITextViewer viewer) {

		super.install(viewer);

		fTextViewer= viewer;

		fManager= new MultipleHyperlinkHoverManager(new MultipleHyperlinkHover(), fTextViewer);

		fManager.install(viewer.getTextWidget());

		fManager.setSizeConstraints(100, 12, false, true);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.text.hyperlink.DefaultHyperlinkPresenter#uninstall()

	 */

	public void uninstall() {

		super.uninstall();

		if (fTextViewer != null) {

			fManager.dispose();

			fTextViewer= null;

		}

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.text.hyperlink.DefaultHyperlinkPresenter#canShowMultipleHyperlinks()

	 */

	public boolean canShowMultipleHyperlinks() {

		return true;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.text.hyperlink.DefaultHyperlinkPresenter#hideHyperlinks()

	 */

	public void hideHyperlinks() {

		super.hideHyperlinks();

		fHyperlinks= null;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.text.hyperlink.DefaultHyperlinkPresenter#showHyperlinks(org.eclipse.jface.text.hyperlink.IHyperlink[])

	 */

	public void showHyperlinks(final IHyperlink[] hyperlinks) {

		super.showHyperlinks(new IHyperlink[] { hyperlinks[0] });

		if (equals(fHyperlinks, hyperlinks))

			return;

		fManager.disposeInformationControl();

		fSubjectRegion= null;

		fHyperlinks= hyperlinks;

		if (hyperlinks.length == 1)

			return;

		int start= hyperlinks[0].getHyperlinkRegion().getOffset();

		int end= start + hyperlinks[0].getHyperlinkRegion().getLength();

		for (int i= 1; i < hyperlinks.length; i++) {

			int hstart= hyperlinks[i].getHyperlinkRegion().getOffset();

			int hend= hstart + hyperlinks[i].getHyperlinkRegion().getLength();

			start= Math.min(start, hstart);

			end= Math.max(end, hend);

		}

		fSubjectRegion= new Region(start, end - start);

		fManager.showInformation();

	}

	private boolean equals(IHyperlink[] oldLinks, IHyperlink[] newLinks) {

		if (oldLinks == null)

			return false;

		if (oldLinks.length != newLinks.length)

			return false;

		for (int i= 0; i < newLinks.length; i++) {

			if (!oldLinks[i].getHyperlinkRegion().equals(newLinks[i].getHyperlinkRegion()))

				return false;

		}

		return true;

	}

}