| /******************************************************************************* |
| * Copyright (c) 2000, 2005 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.ui.internal.ide.dialogs; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.net.URL; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| |
| import javax.xml.parsers.ParserConfigurationException; |
| |
| import org.eclipse.core.resources.IMarker; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.jface.action.MenuManager; |
| import org.eclipse.jface.preference.JFacePreferences; |
| import org.eclipse.jface.resource.JFaceColors; |
| import org.eclipse.jface.resource.JFaceResources; |
| import org.eclipse.jface.util.IPropertyChangeListener; |
| import org.eclipse.jface.util.PropertyChangeEvent; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.custom.CLabel; |
| import org.eclipse.swt.custom.ScrolledComposite; |
| import org.eclipse.swt.custom.StyleRange; |
| import org.eclipse.swt.custom.StyledText; |
| import org.eclipse.swt.events.DisposeEvent; |
| import org.eclipse.swt.events.DisposeListener; |
| import org.eclipse.swt.events.FocusAdapter; |
| import org.eclipse.swt.events.FocusEvent; |
| import org.eclipse.swt.events.KeyEvent; |
| import org.eclipse.swt.events.KeyListener; |
| import org.eclipse.swt.events.MouseAdapter; |
| import org.eclipse.swt.events.MouseEvent; |
| import org.eclipse.swt.events.MouseMoveListener; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.events.TraverseEvent; |
| import org.eclipse.swt.events.TraverseListener; |
| import org.eclipse.swt.graphics.Color; |
| import org.eclipse.swt.graphics.Cursor; |
| import org.eclipse.swt.graphics.GC; |
| import org.eclipse.swt.graphics.Point; |
| 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.Display; |
| import org.eclipse.swt.widgets.Event; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Listener; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorSite; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.internal.ide.IDEInternalWorkbenchImages; |
| import org.eclipse.ui.internal.ide.IDEWorkbenchMessages; |
| import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin; |
| import org.eclipse.ui.internal.ide.IIDEHelpContextIds; |
| import org.eclipse.ui.part.EditorPart; |
| import org.xml.sax.SAXException; |
| |
| /** |
| * A "fake" editor to show a welcome page |
| * The contents of this page are supplied in the product configuration |
| * |
| * PRIVATE |
| * This class is internal to the workbench and must not be called outside the workbench |
| */ |
| public class WelcomeEditor extends EditorPart { |
| |
| private final static int HORZ_SCROLL_INCREMENT = 20; |
| |
| private final static int VERT_SCROLL_INCREMENT = 20; |
| |
| // width at which wrapping will stop and a horizontal scroll bar will be |
| // introduced |
| private final static int WRAP_MIN_WIDTH = 150; |
| |
| private Composite editorComposite; |
| |
| private Cursor handCursor; |
| |
| private Cursor busyCursor; |
| |
| private WelcomeParser parser; |
| |
| private ArrayList hyperlinkRanges = new ArrayList(); |
| |
| private ArrayList texts = new ArrayList(); |
| |
| private ScrolledComposite scrolledComposite; |
| |
| private IPropertyChangeListener colorListener; |
| |
| private boolean mouseDown = false; |
| |
| private boolean dragEvent = false; |
| |
| private StyledText firstText, lastText; |
| |
| private StyledText lastNavigatedText, currentText; |
| |
| private boolean nextTabAbortTraversal, previousTabAbortTraversal = false; |
| |
| private WelcomeEditorCopyAction copyAction; |
| |
| /** |
| * Create a new instance of the welcome editor |
| */ |
| public WelcomeEditor() { |
| super(); |
| setPartName(IDEWorkbenchMessages.WelcomeEditor_title); |
| copyAction = new WelcomeEditorCopyAction(this); |
| copyAction.setEnabled(false); |
| } |
| |
| /** |
| * Update the welcome page to start at the |
| * beginning of the text. |
| */ |
| private void focusOn(StyledText newText, int caretOffset) { |
| if (newText == null) |
| return; |
| newText.setFocus(); |
| newText.setCaretOffset(caretOffset); |
| scrolledComposite.setOrigin(0, newText.getLocation().y); |
| } |
| |
| /** |
| * Finds the next text |
| */ |
| private StyledText nextText(StyledText text) { |
| int index = 0; |
| if (text == null) |
| return (StyledText) texts.get(0); |
| else |
| index = texts.indexOf(text); |
| |
| //If we are not at the end.... |
| if (index < texts.size() - 1) |
| return (StyledText) texts.get(index + 1); |
| else |
| return (StyledText) texts.get(0); |
| } |
| |
| /** |
| * Finds the previous text |
| */ |
| private StyledText previousText(StyledText text) { |
| int index = 0; |
| if (text == null) |
| return (StyledText) texts.get(0); |
| else |
| index = texts.indexOf(text); |
| |
| //If we are at the beginning.... |
| if (index == 0) |
| return (StyledText) texts.get(texts.size() - 1); |
| else |
| return (StyledText) texts.get(index - 1); |
| } |
| |
| /** |
| * Returns the current text. |
| */ |
| protected StyledText getCurrentText() { |
| return currentText; |
| } |
| |
| /** |
| * Returns the copy action. |
| */ |
| protected WelcomeEditorCopyAction getCopyAction() { |
| return copyAction; |
| } |
| |
| /** |
| * Finds the next link after the current selection. |
| */ |
| private StyleRange findNextLink(StyledText text) { |
| if (text == null) |
| return null; |
| |
| WelcomeItem item = (WelcomeItem) text.getData(); |
| StyleRange[] ranges = text.getStyleRanges(); |
| int currentSelectionEnd = text.getSelection().y; |
| |
| for (int i = 0; i < ranges.length; i++) { |
| if (ranges[i].start >= currentSelectionEnd) |
| if (item.isLinkAt(ranges[i].start)) |
| return ranges[i]; |
| } |
| return null; |
| } |
| |
| /** |
| * Finds the previous link before the current selection. |
| */ |
| private StyleRange findPreviousLink(StyledText text) { |
| if (text == null) |
| return null; |
| |
| WelcomeItem item = (WelcomeItem) text.getData(); |
| StyleRange[] ranges = text.getStyleRanges(); |
| int currentSelectionStart = text.getSelection().x; |
| |
| for (int i = ranges.length - 1; i > -1; i--) { |
| if ((ranges[i].start + ranges[i].length) < currentSelectionStart) |
| if (item.isLinkAt(ranges[i].start + ranges[i].length - 1)) |
| return ranges[i]; |
| } |
| return null; |
| } |
| |
| /** |
| * Finds the current link of the current selection. |
| */ |
| protected StyleRange getCurrentLink(StyledText text) { |
| StyleRange[] ranges = text.getStyleRanges(); |
| int currentSelectionEnd = text.getSelection().y; |
| int currentSelectionStart = text.getSelection().x; |
| |
| for (int i = 0; i < ranges.length; i++) { |
| if ((currentSelectionStart >= ranges[i].start) |
| && (currentSelectionEnd <= (ranges[i].start + ranges[i].length))) { |
| return ranges[i]; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Adds listeners to the given styled text |
| */ |
| private void addListeners(StyledText styledText) { |
| styledText.addMouseListener(new MouseAdapter() { |
| public void mouseDown(MouseEvent e) { |
| if (e.button != 1) { |
| return; |
| } |
| mouseDown = true; |
| } |
| |
| public void mouseUp(MouseEvent e) { |
| mouseDown = false; |
| StyledText text = (StyledText) e.widget; |
| WelcomeItem item = (WelcomeItem) e.widget.getData(); |
| int offset = text.getCaretOffset(); |
| if (dragEvent) { |
| dragEvent = false; |
| if (item.isLinkAt(offset)) { |
| text.setCursor(handCursor); |
| } |
| } else if (item.isLinkAt(offset)) { |
| text.setCursor(busyCursor); |
| if (e.button == 1) { |
| item.triggerLinkAt(offset); |
| StyleRange selectionRange = getCurrentLink(text); |
| text.setSelectionRange(selectionRange.start, |
| selectionRange.length); |
| text.setCursor(null); |
| } |
| } |
| } |
| }); |
| |
| styledText.addMouseMoveListener(new MouseMoveListener() { |
| public void mouseMove(MouseEvent e) { |
| // Do not change cursor on drag events |
| if (mouseDown) { |
| if (!dragEvent) { |
| StyledText text = (StyledText) e.widget; |
| text.setCursor(null); |
| } |
| dragEvent = true; |
| return; |
| } |
| StyledText text = (StyledText) e.widget; |
| WelcomeItem item = (WelcomeItem) e.widget.getData(); |
| int offset = -1; |
| try { |
| offset = text.getOffsetAtLocation(new Point(e.x, e.y)); |
| } catch (IllegalArgumentException ex) { |
| // location is not over a character |
| } |
| if (offset == -1) |
| text.setCursor(null); |
| else if (item.isLinkAt(offset)) |
| text.setCursor(handCursor); |
| else |
| text.setCursor(null); |
| } |
| }); |
| |
| styledText.addTraverseListener(new TraverseListener() { |
| public void keyTraversed(TraverseEvent e) { |
| StyledText text = (StyledText) e.widget; |
| |
| switch (e.detail) { |
| case SWT.TRAVERSE_ESCAPE: |
| e.doit = true; |
| break; |
| case SWT.TRAVERSE_TAB_NEXT: |
| // Handle Ctrl-Tab |
| if ((e.stateMask & SWT.CTRL) != 0) { |
| if (e.widget == lastText) |
| return; |
| else { |
| e.doit = false; |
| nextTabAbortTraversal = true; |
| lastText.traverse(SWT.TRAVERSE_TAB_NEXT); |
| return; |
| } |
| } |
| if (nextTabAbortTraversal) { |
| nextTabAbortTraversal = false; |
| return; |
| } |
| // Find the next link in current widget, if applicable |
| // Stop at top of widget |
| StyleRange nextLink = findNextLink(text); |
| if (nextLink == null) { |
| // go to the next widget, focus at beginning |
| StyledText nextText = nextText(text); |
| nextText.setSelection(0); |
| focusOn(nextText, 0); |
| } else { |
| // focusOn: allow none tab traversals to align |
| focusOn(text, text.getSelection().x); |
| text.setSelectionRange(nextLink.start, nextLink.length); |
| } |
| e.detail = SWT.TRAVERSE_NONE; |
| e.doit = true; |
| break; |
| case SWT.TRAVERSE_TAB_PREVIOUS: |
| // Handle Ctrl-Shift-Tab |
| if ((e.stateMask & SWT.CTRL) != 0) { |
| if (e.widget == firstText) |
| return; |
| else { |
| e.doit = false; |
| previousTabAbortTraversal = true; |
| firstText.traverse(SWT.TRAVERSE_TAB_PREVIOUS); |
| return; |
| } |
| } |
| if (previousTabAbortTraversal) { |
| previousTabAbortTraversal = false; |
| return; |
| } |
| // Find the previous link in current widget, if applicable |
| // Stop at top of widget also |
| StyleRange previousLink = findPreviousLink(text); |
| if (previousLink == null) { |
| if (text.getSelection().x == 0) { |
| // go to the previous widget, focus at end |
| StyledText previousText = previousText(text); |
| previousText.setSelection(previousText |
| .getCharCount()); |
| previousLink = findPreviousLink(previousText); |
| if (previousLink == null) |
| focusOn(previousText, 0); |
| else { |
| focusOn(previousText, previousText |
| .getSelection().x); |
| previousText |
| .setSelectionRange(previousLink.start, |
| previousLink.length); |
| } |
| } else { |
| // stay at top of this widget |
| focusOn(text, 0); |
| } |
| } else { |
| // focusOn: allow none tab traversals to align |
| focusOn(text, text.getSelection().x); |
| text.setSelectionRange(previousLink.start, |
| previousLink.length); |
| } |
| e.detail = SWT.TRAVERSE_NONE; |
| e.doit = true; |
| break; |
| default: |
| break; |
| } |
| } |
| }); |
| |
| styledText.addKeyListener(new KeyListener() { |
| public void keyReleased(KeyEvent e) { |
| //Ignore a key release |
| } |
| |
| public void keyPressed(KeyEvent event) { |
| StyledText text = (StyledText) event.widget; |
| if (event.character == ' ' || event.character == SWT.CR) { |
| if (text != null) { |
| WelcomeItem item = (WelcomeItem) text.getData(); |
| |
| //Be sure we are in the selection |
| int offset = text.getSelection().x + 1; |
| |
| if (item.isLinkAt(offset)) { |
| text.setCursor(busyCursor); |
| item.triggerLinkAt(offset); |
| StyleRange selectionRange = getCurrentLink(text); |
| text.setSelectionRange(selectionRange.start, |
| selectionRange.length); |
| text.setCursor(null); |
| } |
| } |
| return; |
| } |
| |
| // When page down is pressed, move the cursor to the next item in the |
| // welcome page. Note that this operation wraps (pages to the top item |
| // when the last item is reached). |
| if (event.keyCode == SWT.PAGE_DOWN) { |
| focusOn(nextText(text), 0); |
| return; |
| } |
| |
| // When page up is pressed, move the cursor to the previous item in the |
| // welcome page. Note that this operation wraps (pages to the bottom item |
| // when the first item is reached). |
| if (event.keyCode == SWT.PAGE_UP) { |
| focusOn(previousText(text), 0); |
| return; |
| } |
| } |
| }); |
| |
| styledText.addFocusListener(new FocusAdapter() { |
| public void focusLost(FocusEvent e) { |
| // Remember current text widget |
| lastNavigatedText = (StyledText) e.widget; |
| } |
| |
| public void focusGained(FocusEvent e) { |
| currentText = (StyledText) e.widget; |
| |
| // Remove highlighted selection if text widget has changed |
| if ((currentText != lastNavigatedText) |
| && (lastNavigatedText != null)) |
| lastNavigatedText.setSelection(lastNavigatedText |
| .getSelection().x); |
| |
| // enable/disable copy action |
| copyAction.setEnabled(currentText.getSelectionCount() > 0); |
| } |
| }); |
| |
| styledText.addSelectionListener(new SelectionAdapter() { |
| public void widgetSelected(SelectionEvent e) { |
| // enable/disable copy action |
| StyledText text = (StyledText) e.widget; |
| copyAction.setEnabled(text.getSelectionCount() > 0); |
| } |
| }); |
| } |
| |
| /** |
| * Creates the wizard's title area. |
| * |
| * @param parent the SWT parent for the title area composite |
| * @return the created info area composite |
| */ |
| private Composite createInfoArea(Composite parent) { |
| // Create the title area which will contain |
| // a title, message, and image. |
| this.scrolledComposite = new ScrolledComposite(parent, SWT.V_SCROLL |
| | SWT.H_SCROLL); |
| this.scrolledComposite.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| final Composite infoArea = new Composite(this.scrolledComposite, |
| SWT.NONE); |
| GridLayout layout = new GridLayout(); |
| layout.marginHeight = 10; |
| layout.verticalSpacing = 5; |
| layout.numColumns = 2; |
| infoArea.setLayout(layout); |
| GridData data = new GridData(GridData.FILL_BOTH); |
| infoArea.setLayoutData(data); |
| boolean wrapped = parser.isFormatWrapped(); |
| int HINDENT = 20; |
| |
| // Get the background color for the title area |
| Display display = parent.getDisplay(); |
| Color background = JFaceColors.getBannerBackground(display); |
| Color foreground = JFaceColors.getBannerForeground(display); |
| infoArea.setBackground(background); |
| |
| int textStyle = SWT.MULTI | SWT.READ_ONLY; |
| if (wrapped) { |
| textStyle = textStyle | SWT.WRAP; |
| } |
| StyledText sampleStyledText = null; |
| // Create the intro item |
| WelcomeItem item = getIntroItem(); |
| if (item != null) { |
| StyledText styledText = new StyledText(infoArea, textStyle); |
| this.texts.add(styledText); |
| sampleStyledText = styledText; |
| styledText.setCursor(null); |
| JFaceColors.setColors(styledText, foreground, background); |
| styledText.setText(getIntroItem().getText()); |
| setBoldRanges(styledText, item.getBoldRanges()); |
| setLinkRanges(styledText, item.getActionRanges()); |
| setLinkRanges(styledText, item.getHelpRanges()); |
| GridData gd = new GridData(GridData.FILL_HORIZONTAL); |
| gd.horizontalSpan = 2; |
| gd.horizontalIndent = HINDENT; |
| gd.verticalAlignment = GridData.VERTICAL_ALIGN_BEGINNING; |
| styledText.setLayoutData(gd); |
| styledText.setData(item); |
| addListeners(styledText); |
| |
| Label spacer = new Label(infoArea, SWT.NONE); |
| spacer.setBackground(background); |
| gd = new GridData(GridData.VERTICAL_ALIGN_BEGINNING); |
| gd.horizontalSpan = 2; |
| spacer.setLayoutData(gd); |
| } |
| firstText = sampleStyledText; |
| |
| // Create the welcome items |
| Label imageLabel = null; |
| WelcomeItem[] items = getItems(); |
| for (int i = 0; i < items.length; i++) { |
| Label label = new Label(infoArea, SWT.NONE); |
| label.setBackground(background); |
| label |
| .setImage(PlatformUI |
| .getWorkbench() |
| .getSharedImages() |
| .getImage( |
| IDEInternalWorkbenchImages.IMG_OBJS_WELCOME_ITEM)); |
| GridData gd = new GridData(); |
| gd.horizontalIndent = HINDENT; |
| gd.verticalAlignment = GridData.VERTICAL_ALIGN_BEGINNING; |
| label.setLayoutData(gd); |
| if (imageLabel == null) { |
| imageLabel = label; |
| } |
| |
| StyledText styledText = new StyledText(infoArea, textStyle); |
| this.texts.add(styledText); |
| sampleStyledText = styledText; |
| styledText.setCursor(null); |
| JFaceColors.setColors(styledText, foreground, background); |
| styledText.setText(items[i].getText()); |
| setBoldRanges(styledText, items[i].getBoldRanges()); |
| setLinkRanges(styledText, items[i].getActionRanges()); |
| setLinkRanges(styledText, items[i].getHelpRanges()); |
| gd = new GridData(GridData.FILL_HORIZONTAL); |
| gd.verticalAlignment = GridData.VERTICAL_ALIGN_BEGINNING; |
| gd.verticalSpan = 2; |
| styledText.setLayoutData(gd); |
| styledText.setData(items[i]); |
| addListeners(styledText); |
| |
| Label spacer = new Label(infoArea, SWT.NONE); |
| spacer.setBackground(background); |
| gd = new GridData(GridData.VERTICAL_ALIGN_BEGINNING); |
| gd.horizontalSpan = 2; |
| spacer.setLayoutData(gd); |
| |
| // create context menu |
| MenuManager menuMgr = new MenuManager("#PopUp"); //$NON-NLS-1$ |
| menuMgr.add(copyAction); |
| styledText.setMenu(menuMgr.createContextMenu(styledText)); |
| } |
| |
| lastText = sampleStyledText; |
| this.scrolledComposite.setContent(infoArea); |
| Point p = infoArea.computeSize(SWT.DEFAULT, SWT.DEFAULT, true); |
| this.scrolledComposite.setMinHeight(p.y); |
| if (wrapped) { |
| // introduce a horizontal scroll bar after a minimum width is reached |
| this.scrolledComposite.setMinWidth(WRAP_MIN_WIDTH); |
| } else { |
| this.scrolledComposite.setMinWidth(p.x); |
| } |
| this.scrolledComposite.setExpandHorizontal(true); |
| this.scrolledComposite.setExpandVertical(true); |
| |
| // When the welcome editor is resized, we need to set the width hint for |
| // wrapped StyledText widgets so that the wrapped height will be recalculated. |
| if (wrapped && (imageLabel != null)) { |
| // figure out how wide the StyledText widgets should be, do this by first |
| // calculating the width of the area not used by styled text widgets |
| Rectangle bounds = imageLabel.getBounds(); |
| final int adjust = HINDENT + bounds.width + layout.verticalSpacing |
| + (layout.marginWidth * 2); |
| final int adjustFirst = HINDENT + (layout.marginWidth * 2); |
| infoArea.addListener(SWT.Resize, new Listener() { |
| public void handleEvent(Event event) { |
| int w = scrolledComposite.getClientArea().width; |
| // if the horizontal scroll bar exists, we want to wrap to the |
| // minimum wrap width |
| if (w < WRAP_MIN_WIDTH) { |
| w = WRAP_MIN_WIDTH; |
| } |
| for (int i = 0; i < texts.size(); i++) { |
| int extent; |
| if (i == 0) |
| extent = w - adjustFirst; |
| else |
| extent = w - adjust; |
| StyledText text = (StyledText) texts.get(i); |
| Point p = text.computeSize(extent, SWT.DEFAULT, false); |
| ((GridData) text.getLayoutData()).widthHint = p.x; |
| } |
| // reset the scrolled composite height since the height of the |
| // styled text widgets have changed |
| Point p = infoArea.computeSize(SWT.DEFAULT, SWT.DEFAULT, |
| true); |
| scrolledComposite.setMinHeight(p.y); |
| } |
| }); |
| } |
| |
| // Adjust the scrollbar increments |
| if (sampleStyledText == null) { |
| this.scrolledComposite.getHorizontalBar().setIncrement( |
| HORZ_SCROLL_INCREMENT); |
| this.scrolledComposite.getVerticalBar().setIncrement( |
| VERT_SCROLL_INCREMENT); |
| } else { |
| GC gc = new GC(sampleStyledText); |
| int width = gc.getFontMetrics().getAverageCharWidth(); |
| gc.dispose(); |
| this.scrolledComposite.getHorizontalBar().setIncrement(width); |
| this.scrolledComposite.getVerticalBar().setIncrement( |
| sampleStyledText.getLineHeight()); |
| } |
| return infoArea; |
| } |
| |
| /** |
| * Creates the SWT controls for this workbench part. |
| * <p> |
| * Clients should not call this method (the workbench calls this method at |
| * appropriate times). |
| * </p> |
| * <p> |
| * For implementors this is a multi-step process: |
| * <ol> |
| * <li>Create one or more controls within the parent.</li> |
| * <li>Set the parent layout as needed.</li> |
| * <li>Register any global actions with the <code>IActionService</code>.</li> |
| * <li>Register any popup menus with the <code>IActionService</code>.</li> |
| * <li>Register a selection provider with the <code>ISelectionService</code> |
| * (optional). </li> |
| * </ol> |
| * </p> |
| * |
| * @param parent the parent control |
| */ |
| public void createPartControl(Composite parent) { |
| // read our contents |
| readFile(); |
| if (parser == null) |
| return; |
| |
| handCursor = new Cursor(parent.getDisplay(), SWT.CURSOR_HAND); |
| busyCursor = new Cursor(parent.getDisplay(), SWT.CURSOR_WAIT); |
| |
| editorComposite = new Composite(parent, SWT.NONE); |
| GridLayout layout = new GridLayout(); |
| layout.marginHeight = 0; |
| layout.marginWidth = 0; |
| layout.verticalSpacing = 0; |
| layout.horizontalSpacing = 0; |
| editorComposite.setLayout(layout); |
| |
| createTitleArea(editorComposite); |
| |
| Label titleBarSeparator = new Label(editorComposite, SWT.HORIZONTAL |
| | SWT.SEPARATOR); |
| GridData gd = new GridData(GridData.FILL_HORIZONTAL); |
| titleBarSeparator.setLayoutData(gd); |
| |
| createInfoArea(editorComposite); |
| |
| getSite().getWorkbenchWindow().getWorkbench().getHelpSystem().setHelp( |
| editorComposite, IIDEHelpContextIds.WELCOME_EDITOR); |
| |
| this.colorListener = new IPropertyChangeListener() { |
| public void propertyChange(PropertyChangeEvent event) { |
| if (event.getProperty() |
| .equals(JFacePreferences.HYPERLINK_COLOR)) { |
| Color fg = JFaceColors.getHyperlinkText(editorComposite |
| .getDisplay()); |
| Iterator links = hyperlinkRanges.iterator(); |
| while (links.hasNext()) { |
| StyleRange range = (StyleRange) links.next(); |
| range.foreground = fg; |
| } |
| } |
| } |
| }; |
| |
| JFacePreferences.getPreferenceStore().addPropertyChangeListener( |
| this.colorListener); |
| |
| } |
| |
| /** |
| * Creates the wizard's title area. |
| * |
| * @param parent the SWT parent for the title area composite |
| * @return the created title area composite |
| */ |
| private Composite createTitleArea(Composite parent) { |
| // Get the background color for the title area |
| Display display = parent.getDisplay(); |
| Color background = JFaceColors.getBannerBackground(display); |
| Color foreground = JFaceColors.getBannerForeground(display); |
| |
| // Create the title area which will contain |
| // a title, message, and image. |
| Composite titleArea = new Composite(parent, SWT.NONE | SWT.NO_FOCUS); |
| GridLayout layout = new GridLayout(); |
| layout.marginHeight = 0; |
| layout.marginWidth = 0; |
| layout.verticalSpacing = 0; |
| layout.horizontalSpacing = 0; |
| layout.numColumns = 2; |
| titleArea.setLayout(layout); |
| titleArea.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| titleArea.setBackground(background); |
| |
| // Message label |
| final CLabel messageLabel = new CLabel(titleArea, SWT.LEFT) { |
| protected String shortenText(GC gc, String text, int width) { |
| if (gc.textExtent(text, SWT.DRAW_MNEMONIC).x <= width) |
| return text; |
| final String ellipsis = "..."; //$NON-NLS-1$ |
| int ellipseWidth = gc.textExtent(ellipsis, SWT.DRAW_MNEMONIC).x; |
| int length = text.length(); |
| int end = length - 1; |
| while (end > 0) { |
| text = text.substring(0, end); |
| int l1 = gc.textExtent(text, SWT.DRAW_MNEMONIC).x; |
| if (l1 + ellipseWidth <= width) { |
| return text + ellipsis; |
| } |
| end--; |
| } |
| return text + ellipsis; |
| } |
| }; |
| JFaceColors.setColors(messageLabel, foreground, background); |
| messageLabel.setText(getBannerTitle()); |
| messageLabel.setFont(JFaceResources.getHeaderFont()); |
| |
| final IPropertyChangeListener fontListener = new IPropertyChangeListener() { |
| public void propertyChange(PropertyChangeEvent event) { |
| if (JFaceResources.HEADER_FONT.equals(event.getProperty())) { |
| messageLabel.setFont(JFaceResources.getHeaderFont()); |
| } |
| } |
| }; |
| |
| messageLabel.addDisposeListener(new DisposeListener() { |
| public void widgetDisposed(DisposeEvent event) { |
| JFaceResources.getFontRegistry().removeListener(fontListener); |
| } |
| }); |
| |
| JFaceResources.getFontRegistry().addListener(fontListener); |
| |
| GridData gd = new GridData(GridData.FILL_BOTH); |
| messageLabel.setLayoutData(gd); |
| |
| // Title image |
| Label titleImage = new Label(titleArea, SWT.LEFT); |
| titleImage.setBackground(background); |
| titleImage.setImage(PlatformUI.getWorkbench().getSharedImages() |
| .getImage(IDEInternalWorkbenchImages.IMG_OBJS_WELCOME_BANNER)); |
| gd = new GridData(); |
| gd.horizontalAlignment = GridData.END; |
| titleImage.setLayoutData(gd); |
| |
| return titleArea; |
| } |
| |
| /** |
| * The <code>WorkbenchPart</code> implementation of this |
| * <code>IWorkbenchPart</code> method disposes the title image |
| * loaded by <code>setInitializationData</code>. Subclasses may extend. |
| */ |
| public void dispose() { |
| super.dispose(); |
| if (busyCursor != null) |
| busyCursor.dispose(); |
| if (handCursor != null) |
| handCursor.dispose(); |
| if (this.colorListener != null) { |
| JFacePreferences.getPreferenceStore().removePropertyChangeListener( |
| this.colorListener); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * Saves the contents of this editor. |
| * <p> |
| * Subclasses must override this method to implement the open-save-close lifecycle |
| * for an editor. For greater details, see <code>IEditorPart</code> |
| * </p> |
| * |
| * @see IEditorPart |
| */ |
| public void doSave(IProgressMonitor monitor) { |
| // do nothing |
| } |
| |
| /* (non-Javadoc) |
| * Saves the contents of this editor to another object. |
| * <p> |
| * Subclasses must override this method to implement the open-save-close lifecycle |
| * for an editor. For greater details, see <code>IEditorPart</code> |
| * </p> |
| * |
| * @see IEditorPart |
| */ |
| public void doSaveAs() { |
| // do nothing |
| } |
| |
| /** |
| * Returns the title obtained from the parser |
| */ |
| private String getBannerTitle() { |
| if (parser.getTitle() == null) |
| return ""; //$NON-NLS-1$ |
| return parser.getTitle(); |
| } |
| |
| /** |
| * Returns the intro item or <code>null</code> |
| */ |
| private WelcomeItem getIntroItem() { |
| return parser.getIntroItem(); |
| } |
| |
| /** |
| * Returns the welcome items |
| */ |
| private WelcomeItem[] getItems() { |
| return parser.getItems(); |
| } |
| |
| /* (non-Javadoc) |
| * Sets the cursor and selection state for this editor to the passage defined |
| * by the given marker. |
| * <p> |
| * Subclasses may override. For greater details, see <code>IEditorPart</code> |
| * </p> |
| * |
| * @see IEditorPart |
| */ |
| public void gotoMarker(IMarker marker) { |
| // do nothing |
| } |
| |
| /* (non-Javadoc) |
| * Initializes the editor part with a site and input. |
| * <p> |
| * Subclasses of <code>EditorPart</code> must implement this method. Within |
| * the implementation subclasses should verify that the input type is acceptable |
| * and then save the site and input. Here is sample code: |
| * </p> |
| * <pre> |
| * if (!(input instanceof IFileEditorInput)) |
| * throw new PartInitException("Invalid Input: Must be IFileEditorInput"); |
| * setSite(site); |
| * setInput(editorInput); |
| * </pre> |
| */ |
| public void init(IEditorSite site, IEditorInput input) |
| throws PartInitException { |
| if (!(input instanceof WelcomeEditorInput)) |
| throw new PartInitException( |
| "Invalid Input: Must be WelcomeEditorInput"); //$NON-NLS-1$ |
| setSite(site); |
| setInput(input); |
| } |
| |
| /* (non-Javadoc) |
| * Returns whether the contents of this editor have changed since the last save |
| * operation. |
| * <p> |
| * Subclasses must override this method to implement the open-save-close lifecycle |
| * for an editor. For greater details, see <code>IEditorPart</code> |
| * </p> |
| * |
| * @see IEditorPart |
| */ |
| public boolean isDirty() { |
| return false; |
| } |
| |
| /* (non-Javadoc) |
| * Returns whether the "save as" operation is supported by this editor. |
| * <p> |
| * Subclasses must override this method to implement the open-save-close lifecycle |
| * for an editor. For greater details, see <code>IEditorPart</code> |
| * </p> |
| * |
| * @see IEditorPart |
| */ |
| public boolean isSaveAsAllowed() { |
| return false; |
| } |
| |
| /** |
| * Read the contents of the welcome page |
| * |
| * @param is the <code>InputStream</code> to parse |
| * @throws IOException if there is a problem parsing the stream. |
| */ |
| public void read(InputStream is) throws IOException { |
| try { |
| parser = new WelcomeParser(); |
| } catch (ParserConfigurationException e) { |
| throw (IOException) (new IOException().initCause(e)); |
| } catch (SAXException e) { |
| throw (IOException) (new IOException().initCause(e)); |
| } |
| parser.parse(is); |
| } |
| |
| /** |
| * Reads the welcome file |
| */ |
| public void readFile() { |
| URL url = ((WelcomeEditorInput) getEditorInput()).getAboutInfo() |
| .getWelcomePageURL(); |
| |
| if (url == null) |
| // should not happen |
| return; |
| |
| InputStream is = null; |
| try { |
| is = url.openStream(); |
| read(is); |
| } catch (IOException e) { |
| IStatus status = new Status(IStatus.ERROR, |
| IDEWorkbenchPlugin.IDE_WORKBENCH, 1, IDEWorkbenchMessages.WelcomeEditor_accessException, e); |
| IDEWorkbenchPlugin.log(IDEWorkbenchMessages.WelcomeEditor_readFileError, status); |
| } finally { |
| try { |
| if (is != null) |
| is.close(); |
| } catch (IOException e) { |
| } |
| } |
| } |
| |
| /** |
| * Sets the styled text's bold ranges |
| */ |
| private void setBoldRanges(StyledText styledText, int[][] boldRanges) { |
| for (int i = 0; i < boldRanges.length; i++) { |
| StyleRange r = new StyleRange(boldRanges[i][0], boldRanges[i][1], |
| null, null, SWT.BOLD); |
| styledText.setStyleRange(r); |
| } |
| } |
| |
| /** |
| * Asks this part to take focus within the workbench. |
| * <p> |
| * Clients should not call this method (the workbench calls this method at |
| * appropriate times). |
| * </p> |
| */ |
| public void setFocus() { |
| if ((editorComposite != null) && (lastNavigatedText == null) |
| && (currentText == null)) |
| editorComposite.setFocus(); |
| } |
| |
| /** |
| * Sets the styled text's link (blue) ranges |
| */ |
| private void setLinkRanges(StyledText styledText, int[][] linkRanges) { |
| //Color fg = styledText.getDisplay().getSystemColor(SWT.COLOR_BLUE); |
| Color fg = JFaceColors.getHyperlinkText(styledText.getShell() |
| .getDisplay()); |
| for (int i = 0; i < linkRanges.length; i++) { |
| StyleRange r = new StyleRange(linkRanges[i][0], linkRanges[i][1], |
| fg, null); |
| styledText.setStyleRange(r); |
| hyperlinkRanges.add(r); |
| } |
| } |
| |
| } |
