| /***************************************************************************** |
| * Copyright (c) 2000, 2018 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 |
| * |
| * SPDX-License-Identifier: EPL-1.0 |
| *******************************************************************************/ |
| package org.eclipse.apogy.core.invocator.ui.composites; |
| |
| import java.io.BufferedReader; |
| import java.io.FileInputStream; |
| import java.io.FileWriter; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.InputStreamReader; |
| import java.util.MissingResourceException; |
| import java.util.ResourceBundle; |
| import java.util.StringTokenizer; |
| |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.browser.Browser; |
| import org.eclipse.swt.custom.Bullet; |
| import org.eclipse.swt.custom.CaretEvent; |
| import org.eclipse.swt.custom.CaretListener; |
| import org.eclipse.swt.custom.PaintObjectEvent; |
| import org.eclipse.swt.custom.PaintObjectListener; |
| import org.eclipse.swt.custom.ST; |
| import org.eclipse.swt.custom.StyleRange; |
| import org.eclipse.swt.custom.StyledText; |
| import org.eclipse.swt.events.ControlAdapter; |
| import org.eclipse.swt.events.ControlEvent; |
| import org.eclipse.swt.events.MenuAdapter; |
| import org.eclipse.swt.events.MenuEvent; |
| import org.eclipse.swt.events.ModifyEvent; |
| import org.eclipse.swt.events.ModifyListener; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.events.VerifyEvent; |
| import org.eclipse.swt.events.VerifyListener; |
| import org.eclipse.swt.graphics.Color; |
| import org.eclipse.swt.graphics.Font; |
| import org.eclipse.swt.graphics.FontData; |
| import org.eclipse.swt.graphics.GC; |
| import org.eclipse.swt.graphics.GlyphMetrics; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.graphics.ImageData; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.graphics.RGB; |
| import org.eclipse.swt.graphics.Rectangle; |
| import org.eclipse.swt.graphics.Resource; |
| import org.eclipse.swt.layout.FillLayout; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Button; |
| import org.eclipse.swt.widgets.ColorDialog; |
| import org.eclipse.swt.widgets.Combo; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.CoolBar; |
| import org.eclipse.swt.widgets.CoolItem; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Event; |
| import org.eclipse.swt.widgets.FileDialog; |
| import org.eclipse.swt.widgets.FontDialog; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Listener; |
| import org.eclipse.swt.widgets.Menu; |
| import org.eclipse.swt.widgets.MenuItem; |
| import org.eclipse.swt.widgets.MessageBox; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.swt.widgets.Spinner; |
| import org.eclipse.swt.widgets.Text; |
| import org.eclipse.swt.widgets.ToolBar; |
| import org.eclipse.swt.widgets.ToolItem; |
| |
| public class TextEditor { |
| Display display; |
| Shell shell; |
| CoolBar coolBar; |
| StyledText styledText; |
| Label statusBar; |
| ToolItem boldControl, italicControl, leftAlignmentItem, centerAlignmentItem, rightAlignmentItem, |
| justifyAlignmentItem, blockSelectionItem; |
| Combo fontNameControl, fontSizeControl; |
| MenuItem underlineSingleItem, underlineDoubleItem, underlineErrorItem, underlineSquiggleItem, borderSolidItem, |
| borderDashItem, borderDotItem; |
| |
| boolean insert = true; |
| StyleRange[] selectedRanges; |
| int newCharCount, start; |
| String fileName = null; |
| int styleState; |
| String link; |
| |
| // Resources |
| Image iBold, iItalic, iUnderline, iStrikeout, iLeftAlignment, iRightAlignment, iCenterAlignment, iJustifyAlignment, |
| iCopy, iCut, iLink; |
| Image iPaste, iSpacing, iIndent, iTextForeground, iTextBackground, iBaselineUp, iBaselineDown, iBulletList, |
| iNumberedList, iBlockSelection, iBorderStyle; |
| Font font, textFont; |
| Color textForeground, textBackground, strikeoutColor, underlineColor, borderColor; |
| |
| static final int BULLET_WIDTH = 40; |
| static final int MARGIN = 5; |
| static final int BOLD = SWT.BOLD; |
| static final int ITALIC = SWT.ITALIC; |
| static final int FONT_STYLE = BOLD | ITALIC; |
| static final int STRIKEOUT = 1 << 3; |
| static final int FOREGROUND = 1 << 4; |
| static final int BACKGROUND = 1 << 5; |
| static final int FONT = 1 << 6; |
| static final int BASELINE_UP = 1 << 7; |
| static final int BASELINE_DOWN = 1 << 8; |
| static final int UNDERLINE_SINGLE = 1 << 9; |
| static final int UNDERLINE_DOUBLE = 1 << 10; |
| static final int UNDERLINE_ERROR = 1 << 11; |
| static final int UNDERLINE_SQUIGGLE = 1 << 12; |
| static final int UNDERLINE_LINK = 1 << 13; |
| static final int UNDERLINE = UNDERLINE_SINGLE | UNDERLINE_DOUBLE | UNDERLINE_SQUIGGLE | UNDERLINE_ERROR |
| | UNDERLINE_LINK; |
| static final int BORDER_SOLID = 1 << 23; |
| static final int BORDER_DASH = 1 << 24; |
| static final int BORDER_DOT = 1 << 25; |
| static final int BORDER = BORDER_SOLID | BORDER_DASH | BORDER_DOT; |
| |
| static final boolean SAMPLE_TEXT = false; |
| static final boolean USE_BASELINE = false; |
| |
| static final String[] FONT_SIZES = new String[] { "6", //$NON-NLS-1$ |
| "8", //$NON-NLS-1$ |
| "9", //$NON-NLS-1$ |
| "10", //$NON-NLS-1$ |
| "11", //$NON-NLS-1$ |
| "12", //$NON-NLS-1$ |
| "14", //$NON-NLS-1$ |
| "24", //$NON-NLS-1$ |
| "36", //$NON-NLS-1$ |
| "48" //$NON-NLS-1$ |
| }; |
| |
| static final ResourceBundle resources = ResourceBundle.getBundle("examples_texteditor"); //$NON-NLS-1$ |
| |
| static String getResourceString(String key) { |
| try { |
| return resources.getString(key); |
| } catch (MissingResourceException e) { |
| return key; |
| } catch (NullPointerException e) { |
| return "!" + key + "!"; //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| } |
| |
| public static void main(String[] args) { |
| Display display = new Display(); |
| TextEditor editor = new TextEditor(); |
| Shell shell = editor.open(display); |
| while (!shell.isDisposed()) { |
| if (!display.readAndDispatch()) |
| display.sleep(); |
| } |
| editor.releaseResources(); |
| display.dispose(); |
| } |
| |
| /* |
| * Default constructor is needed so that example launcher can create an |
| * instance. |
| */ |
| public TextEditor() { |
| } |
| |
| public TextEditor(Display display) { |
| open(display); |
| } |
| |
| public Shell open(Display display) { |
| this.display = display; |
| initResources(); |
| this.shell = new Shell(display); |
| this.shell.setText(getResourceString("Window_title")); //$NON-NLS-1$ |
| this.styledText = new StyledText(this.shell, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL); |
| createMenuBar(); |
| createToolBar(); |
| createPopup(); |
| this.statusBar = new Label(this.shell, SWT.NONE); |
| installListeners(); |
| updateToolBar(); |
| updateStatusBar(); |
| this.shell.setSize(1000, 700); |
| this.shell.open(); |
| return this.shell; |
| } |
| |
| void addControl(Control control) { |
| int offset = this.styledText.getCaretOffset(); |
| this.styledText.replaceTextRange(offset, 0, "\uFFFC"); //$NON-NLS-1$ |
| StyleRange style = new StyleRange(); |
| Point size = control.computeSize(SWT.DEFAULT, SWT.DEFAULT); |
| int ascent = 2 * size.y / 3; |
| int descent = size.y - ascent; |
| style.metrics = new GlyphMetrics(ascent + MARGIN, descent + MARGIN, size.x + 2 * MARGIN); |
| style.data = control; |
| int[] ranges = { offset, 1 }; |
| StyleRange[] styles = { style }; |
| this.styledText.setStyleRanges(0, 0, ranges, styles); |
| control.setSize(size); |
| } |
| |
| void addImage(Image image) { |
| int offset = this.styledText.getCaretOffset(); |
| this.styledText.replaceTextRange(offset, 0, "\uFFFC"); //$NON-NLS-1$ |
| StyleRange style = new StyleRange(); |
| Rectangle rect = image.getBounds(); |
| style.metrics = new GlyphMetrics(rect.height, 0, rect.width); |
| style.data = image; |
| int[] ranges = { offset, 1 }; |
| StyleRange[] styles = { style }; |
| this.styledText.setStyleRanges(0, 0, ranges, styles); |
| } |
| |
| void adjustFontSize(int increment) { |
| int newIndex = this.fontSizeControl.getSelectionIndex() + increment; |
| if (0 <= newIndex && newIndex < this.fontSizeControl.getItemCount()) { |
| String name = this.fontNameControl.getText(); |
| int size = Integer.parseInt(this.fontSizeControl.getItem(newIndex)); |
| disposeResource(this.textFont); |
| this.textFont = new Font(this.display, name, size, SWT.NORMAL); |
| setStyle(FONT); |
| updateToolBar(); |
| } |
| } |
| |
| void createMenuBar() { |
| Menu menu = new Menu(this.shell, SWT.BAR); |
| this.shell.setMenuBar(menu); |
| |
| MenuItem fileItem = new MenuItem(menu, SWT.CASCADE); |
| Menu fileMenu = new Menu(this.shell, SWT.DROP_DOWN); |
| fileItem.setText(getResourceString("File_menuitem")); //$NON-NLS-1$ |
| fileItem.setMenu(fileMenu); |
| |
| MenuItem openItem = new MenuItem(fileMenu, SWT.PUSH); |
| openItem.setText(getResourceString("Open_menuitem")); //$NON-NLS-1$ |
| openItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| FileDialog dialog = new FileDialog(TextEditor.this.shell, SWT.OPEN); |
| dialog.setFilterNames(new String[] { getResourceString("Text_Documents") }); //$NON-NLS-1$ |
| dialog.setFilterExtensions(new String[] { "*.txt" }); //$NON-NLS-1$ |
| String name = dialog.open(); |
| if (name == null) |
| return; |
| TextEditor.this.fileName = name; |
| FileInputStream file = null; |
| try { |
| file = new FileInputStream(name); |
| TextEditor.this.styledText.setText(openFile(file)); |
| } catch (IOException e) { |
| showError(getResourceString("Error"), e.getMessage()); //$NON-NLS-1$ |
| } finally { |
| try { |
| if (file != null) |
| file.close(); |
| } catch (IOException e) { |
| showError(getResourceString("Error"), e.getMessage()); //$NON-NLS-1$ |
| } |
| } |
| } |
| }); |
| |
| final MenuItem saveItem = new MenuItem(fileMenu, SWT.PUSH); |
| saveItem.setText(getResourceString("Save_menuitem")); //$NON-NLS-1$ |
| saveItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| saveFile(); |
| } |
| }); |
| |
| fileMenu.addMenuListener(new MenuAdapter() { |
| @Override |
| public void menuShown(MenuEvent event) { |
| saveItem.setEnabled(TextEditor.this.fileName != null); |
| } |
| }); |
| |
| MenuItem saveAsItem = new MenuItem(fileMenu, SWT.PUSH); |
| saveAsItem.setText(getResourceString("SaveAs_menuitem")); //$NON-NLS-1$ |
| saveAsItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| FileDialog dialog = new FileDialog(TextEditor.this.shell, SWT.SAVE); |
| dialog.setFilterNames(new String[] { getResourceString("Text_Documents") }); //$NON-NLS-1$ |
| dialog.setFilterExtensions(new String[] { "*.txt" }); //$NON-NLS-1$ |
| if (TextEditor.this.fileName != null) |
| dialog.setFileName(TextEditor.this.fileName); |
| String name = dialog.open(); |
| if (name != null) { |
| TextEditor.this.fileName = name; |
| saveFile(); |
| } |
| } |
| }); |
| |
| new MenuItem(fileMenu, SWT.SEPARATOR); |
| |
| MenuItem exitItem = new MenuItem(fileMenu, SWT.PUSH); |
| exitItem.setText(getResourceString("Exit_menuitem")); //$NON-NLS-1$ |
| exitItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| TextEditor.this.shell.dispose(); |
| } |
| }); |
| |
| MenuItem editItem = new MenuItem(menu, SWT.CASCADE); |
| final Menu editMenu = new Menu(this.shell, SWT.DROP_DOWN); |
| editItem.setText(getResourceString("Edit_menuitem")); //$NON-NLS-1$ |
| editItem.setMenu(editMenu); |
| final MenuItem cutItem = new MenuItem(editMenu, SWT.PUSH); |
| cutItem.setText(getResourceString("Cut_menuitem")); //$NON-NLS-1$ |
| cutItem.setImage(this.iCut); |
| cutItem.setAccelerator(SWT.MOD1 | 'x'); |
| cutItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| TextEditor.this.styledText.cut(); |
| } |
| }); |
| |
| final MenuItem copyItem = new MenuItem(editMenu, SWT.PUSH); |
| copyItem.setText(getResourceString("Copy_menuitem")); //$NON-NLS-1$ |
| copyItem.setImage(this.iCopy); |
| copyItem.setAccelerator(SWT.MOD1 | 'c'); |
| copyItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| TextEditor.this.styledText.copy(); |
| } |
| }); |
| |
| MenuItem pasteItem = new MenuItem(editMenu, SWT.PUSH); |
| pasteItem.setText(getResourceString("Paste_menuitem")); //$NON-NLS-1$ |
| pasteItem.setImage(this.iPaste); |
| pasteItem.setAccelerator(SWT.MOD1 | 'v'); |
| pasteItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| TextEditor.this.styledText.paste(); |
| } |
| }); |
| |
| new MenuItem(editMenu, SWT.SEPARATOR); |
| final MenuItem selectAllItem = new MenuItem(editMenu, SWT.PUSH); |
| selectAllItem.setText(getResourceString("SelectAll_menuitem")); //$NON-NLS-1$ |
| selectAllItem.setAccelerator(SWT.MOD1 | 'a'); |
| selectAllItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| TextEditor.this.styledText.selectAll(); |
| } |
| }); |
| |
| editMenu.addMenuListener(new MenuAdapter() { |
| @Override |
| public void menuShown(MenuEvent event) { |
| int selectionCount = TextEditor.this.styledText.getSelectionCount(); |
| cutItem.setEnabled(selectionCount > 0); |
| copyItem.setEnabled(selectionCount > 0); |
| selectAllItem.setEnabled(selectionCount < TextEditor.this.styledText.getCharCount()); |
| } |
| }); |
| |
| MenuItem wrapItem = new MenuItem(editMenu, SWT.CHECK); |
| wrapItem.setText(getResourceString("Wrap_menuitem")); //$NON-NLS-1$ |
| wrapItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| MenuItem item = (MenuItem) event.widget; |
| boolean enabled = item.getSelection(); |
| TextEditor.this.styledText.setWordWrap(enabled); |
| editMenu.getItem(6).setEnabled(enabled); |
| editMenu.getItem(8).setEnabled(enabled); |
| TextEditor.this.leftAlignmentItem.setEnabled(enabled); |
| TextEditor.this.centerAlignmentItem.setEnabled(enabled); |
| TextEditor.this.rightAlignmentItem.setEnabled(enabled); |
| TextEditor.this.justifyAlignmentItem.setEnabled(enabled); |
| TextEditor.this.blockSelectionItem.setEnabled(!enabled); |
| } |
| }); |
| |
| MenuItem justifyItem = new MenuItem(editMenu, SWT.CHECK); |
| justifyItem.setText(getResourceString("Justify_menuitem")); //$NON-NLS-1$ |
| justifyItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| MenuItem item = (MenuItem) event.widget; |
| TextEditor.this.styledText.setJustify(item.getSelection()); |
| updateToolBar(); |
| } |
| }); |
| justifyItem.setEnabled(false); |
| |
| MenuItem setFontItem = new MenuItem(editMenu, SWT.PUSH); |
| setFontItem.setText(getResourceString("SetFont_menuitem")); //$NON-NLS-1$ |
| setFontItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| FontDialog fontDialog = new FontDialog(TextEditor.this.shell); |
| fontDialog.setFontList(TextEditor.this.styledText.getFont().getFontData()); |
| FontData data = fontDialog.open(); |
| if (data != null) { |
| Font newFont = new Font(TextEditor.this.display, data); |
| TextEditor.this.styledText.setFont(newFont); |
| if (TextEditor.this.font != null) |
| TextEditor.this.font.dispose(); |
| TextEditor.this.font = newFont; |
| updateToolBar(); |
| } |
| } |
| }); |
| |
| MenuItem alignmentItem = new MenuItem(editMenu, SWT.CASCADE); |
| alignmentItem.setText(getResourceString("Alignment_menuitem")); //$NON-NLS-1$ |
| Menu alignmentMenu = new Menu(this.shell, SWT.DROP_DOWN); |
| alignmentItem.setMenu(alignmentMenu); |
| final MenuItem leftAlignmentItem = new MenuItem(alignmentMenu, SWT.RADIO); |
| leftAlignmentItem.setText(getResourceString("Left_menuitem")); //$NON-NLS-1$ |
| leftAlignmentItem.setSelection(true); |
| leftAlignmentItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| TextEditor.this.styledText.setAlignment(SWT.LEFT); |
| updateToolBar(); |
| } |
| }); |
| alignmentItem.setEnabled(false); |
| |
| final MenuItem centerAlignmentItem = new MenuItem(alignmentMenu, SWT.RADIO); |
| centerAlignmentItem.setText(getResourceString("Center_menuitem")); //$NON-NLS-1$ |
| centerAlignmentItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| TextEditor.this.styledText.setAlignment(SWT.CENTER); |
| updateToolBar(); |
| } |
| }); |
| |
| MenuItem rightAlignmentItem = new MenuItem(alignmentMenu, SWT.RADIO); |
| rightAlignmentItem.setText(getResourceString("Right_menuitem")); //$NON-NLS-1$ |
| rightAlignmentItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| TextEditor.this.styledText.setAlignment(SWT.RIGHT); |
| updateToolBar(); |
| } |
| }); |
| |
| MenuItem editOrientationItem = new MenuItem(editMenu, SWT.CASCADE); |
| editOrientationItem.setText(getResourceString("Orientation_menuitem")); //$NON-NLS-1$ |
| Menu editOrientationMenu = new Menu(this.shell, SWT.DROP_DOWN); |
| editOrientationItem.setMenu(editOrientationMenu); |
| |
| MenuItem leftToRightItem = new MenuItem(editOrientationMenu, SWT.RADIO); |
| leftToRightItem.setText(getResourceString("LeftToRight_menuitem")); //$NON-NLS-1$ |
| leftToRightItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| TextEditor.this.styledText.setOrientation(SWT.LEFT_TO_RIGHT); |
| } |
| }); |
| leftToRightItem.setSelection(true); |
| |
| MenuItem rightToLeftItem = new MenuItem(editOrientationMenu, SWT.RADIO); |
| rightToLeftItem.setText(getResourceString("RightToLeft_menuitem")); //$NON-NLS-1$ |
| rightToLeftItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| TextEditor.this.styledText.setOrientation(SWT.RIGHT_TO_LEFT); |
| } |
| }); |
| |
| new MenuItem(editMenu, SWT.SEPARATOR); |
| MenuItem insertObjectItem = new MenuItem(editMenu, SWT.CASCADE); |
| insertObjectItem.setText(getResourceString("InsertObject_menuitem")); //$NON-NLS-1$ |
| Menu insertObjectMenu = new Menu(this.shell, SWT.DROP_DOWN); |
| insertObjectItem.setMenu(insertObjectMenu); |
| |
| MenuItem insertControlItem = new MenuItem(insertObjectMenu, SWT.CASCADE); |
| insertControlItem.setText(getResourceString("Controls_menuitem")); //$NON-NLS-1$ |
| Menu controlChoice = new Menu(this.shell, SWT.DROP_DOWN); |
| insertControlItem.setMenu(controlChoice); |
| |
| MenuItem buttonItem = new MenuItem(controlChoice, SWT.PUSH); |
| buttonItem.setText(getResourceString("Button_menuitem")); //$NON-NLS-1$ |
| MenuItem comboItem = new MenuItem(controlChoice, SWT.PUSH); |
| comboItem.setText(getResourceString("Combo_menuitem")); //$NON-NLS-1$ |
| |
| buttonItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| Button button = new Button(TextEditor.this.styledText, SWT.PUSH); |
| button.setText(getResourceString("Button_menuitem")); //$NON-NLS-1$ |
| addControl(button); |
| } |
| }); |
| |
| comboItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| Combo combo = new Combo(TextEditor.this.styledText, SWT.NONE); |
| combo.setText(getResourceString("Combo_menuitem")); //$NON-NLS-1$ |
| addControl(combo); |
| } |
| }); |
| |
| MenuItem insertImageItem = new MenuItem(insertObjectMenu, SWT.PUSH); |
| insertImageItem.setText(getResourceString("Image_menuitem")); //$NON-NLS-1$ |
| |
| insertImageItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| FileDialog fileDialog = new FileDialog(TextEditor.this.shell, SWT.OPEN); |
| String fileName = fileDialog.open(); |
| if (fileName != null) { |
| try { |
| Image image = new Image(TextEditor.this.display, fileName); |
| addImage(image); |
| } catch (Exception e) { |
| showError(getResourceString("Bad_image"), e.getMessage()); //$NON-NLS-1$ |
| } |
| } |
| } |
| }); |
| |
| if (SAMPLE_TEXT) { |
| new MenuItem(editMenu, SWT.SEPARATOR); |
| MenuItem loadProfileItem = new MenuItem(editMenu, SWT.CASCADE); |
| loadProfileItem.setText(getResourceString("LoadProfile_menuitem")); //$NON-NLS-1$ |
| Menu loadProfileMenu = new Menu(this.shell, SWT.DROP_DOWN); |
| loadProfileItem.setMenu(loadProfileMenu); |
| SelectionAdapter adapter = new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| int profile = Integer.parseInt((String) event.widget.getData()); |
| loadProfile(profile); |
| } |
| }; |
| |
| MenuItem profileItem = new MenuItem(loadProfileMenu, SWT.PUSH); |
| profileItem.setText(getResourceString("Profile1_menuitem")); //$NON-NLS-1$ |
| profileItem.setData("1"); //$NON-NLS-1$ |
| profileItem.addSelectionListener(adapter); |
| profileItem = new MenuItem(loadProfileMenu, SWT.PUSH); |
| profileItem.setText(getResourceString("Profile2_menuitem")); //$NON-NLS-1$ |
| profileItem.setData("2"); //$NON-NLS-1$ |
| profileItem.addSelectionListener(adapter); |
| profileItem = new MenuItem(loadProfileMenu, SWT.PUSH); |
| profileItem.setText(getResourceString("Profile3_menuitem")); //$NON-NLS-1$ |
| profileItem.setData("3"); //$NON-NLS-1$ |
| profileItem.addSelectionListener(adapter); |
| profileItem = new MenuItem(loadProfileMenu, SWT.PUSH); |
| profileItem.setText(getResourceString("Profile4_menuitem")); //$NON-NLS-1$ |
| profileItem.setData("4"); //$NON-NLS-1$ |
| profileItem.addSelectionListener(adapter); |
| } |
| } |
| |
| void createPopup() { |
| Menu menu = new Menu(this.styledText); |
| final MenuItem cutItem = new MenuItem(menu, SWT.PUSH); |
| cutItem.setText(getResourceString("Cut_menuitem")); //$NON-NLS-1$ |
| cutItem.setImage(this.iCut); |
| cutItem.addListener(SWT.Selection, new Listener() { |
| @Override |
| public void handleEvent(Event event) { |
| TextEditor.this.styledText.cut(); |
| } |
| }); |
| final MenuItem copyItem = new MenuItem(menu, SWT.PUSH); |
| copyItem.setText(getResourceString("Copy_menuitem")); //$NON-NLS-1$ |
| copyItem.setImage(this.iCopy); |
| copyItem.addListener(SWT.Selection, new Listener() { |
| @Override |
| public void handleEvent(Event event) { |
| TextEditor.this.styledText.copy(); |
| } |
| }); |
| final MenuItem pasteItem = new MenuItem(menu, SWT.PUSH); |
| pasteItem.setText(getResourceString("Paste_menuitem")); //$NON-NLS-1$ |
| pasteItem.setImage(this.iPaste); |
| pasteItem.addListener(SWT.Selection, new Listener() { |
| @Override |
| public void handleEvent(Event event) { |
| TextEditor.this.styledText.paste(); |
| } |
| }); |
| new MenuItem(menu, SWT.SEPARATOR); |
| final MenuItem selectAllItem = new MenuItem(menu, SWT.PUSH); |
| selectAllItem.setText(getResourceString("SelectAll_menuitem")); //$NON-NLS-1$ |
| selectAllItem.addListener(SWT.Selection, new Listener() { |
| @Override |
| public void handleEvent(Event event) { |
| TextEditor.this.styledText.selectAll(); |
| } |
| }); |
| menu.addMenuListener(new MenuAdapter() { |
| @Override |
| public void menuShown(MenuEvent event) { |
| int selectionCount = TextEditor.this.styledText.getSelectionCount(); |
| cutItem.setEnabled(selectionCount > 0); |
| copyItem.setEnabled(selectionCount > 0); |
| selectAllItem.setEnabled(selectionCount < TextEditor.this.styledText.getCharCount()); |
| } |
| }); |
| this.styledText.setMenu(menu); |
| } |
| |
| void createToolBar() { |
| this.coolBar = new CoolBar(this.shell, SWT.FLAT); |
| ToolBar styleToolBar = new ToolBar(this.coolBar, SWT.FLAT); |
| this.boldControl = new ToolItem(styleToolBar, SWT.CHECK); |
| this.boldControl.setImage(this.iBold); |
| this.boldControl.setToolTipText(getResourceString("Bold")); //$NON-NLS-1$ |
| this.boldControl.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| setStyle(BOLD); |
| } |
| }); |
| |
| this.italicControl = new ToolItem(styleToolBar, SWT.CHECK); |
| this.italicControl.setImage(this.iItalic); |
| this.italicControl.setToolTipText(getResourceString("Italic")); //$NON-NLS-1$ |
| this.italicControl.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| setStyle(ITALIC); |
| } |
| }); |
| |
| final Menu underlineMenu = new Menu(this.shell, SWT.POP_UP); |
| this.underlineSingleItem = new MenuItem(underlineMenu, SWT.RADIO); |
| this.underlineSingleItem.setText(getResourceString("Single_menuitem")); //$NON-NLS-1$ |
| this.underlineSingleItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| if (TextEditor.this.underlineSingleItem.getSelection()) { |
| setStyle(UNDERLINE_SINGLE); |
| } |
| } |
| }); |
| this.underlineSingleItem.setSelection(true); |
| |
| this.underlineDoubleItem = new MenuItem(underlineMenu, SWT.RADIO); |
| this.underlineDoubleItem.setText(getResourceString("Double_menuitem")); //$NON-NLS-1$ |
| this.underlineDoubleItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| if (TextEditor.this.underlineDoubleItem.getSelection()) { |
| setStyle(UNDERLINE_DOUBLE); |
| } |
| } |
| }); |
| |
| this.underlineSquiggleItem = new MenuItem(underlineMenu, SWT.RADIO); |
| this.underlineSquiggleItem.setText(getResourceString("Squiggle_menuitem")); //$NON-NLS-1$ |
| this.underlineSquiggleItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| if (TextEditor.this.underlineSquiggleItem.getSelection()) { |
| setStyle(UNDERLINE_SQUIGGLE); |
| } |
| } |
| }); |
| |
| this.underlineErrorItem = new MenuItem(underlineMenu, SWT.RADIO); |
| this.underlineErrorItem.setText(getResourceString("Error_menuitem")); //$NON-NLS-1$ |
| this.underlineErrorItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| if (TextEditor.this.underlineErrorItem.getSelection()) { |
| setStyle(UNDERLINE_ERROR); |
| } |
| } |
| }); |
| |
| MenuItem underlineColorItem = new MenuItem(underlineMenu, SWT.PUSH); |
| underlineColorItem.setText(getResourceString("Color_menuitem")); //$NON-NLS-1$ |
| underlineColorItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| ColorDialog dialog = new ColorDialog(TextEditor.this.shell); |
| RGB rgb = TextEditor.this.underlineColor != null ? TextEditor.this.underlineColor.getRGB() : null; |
| dialog.setRGB(rgb); |
| RGB newRgb = dialog.open(); |
| if (newRgb != null) { |
| if (!newRgb.equals(rgb)) { |
| disposeResource(TextEditor.this.underlineColor); |
| TextEditor.this.underlineColor = new Color(TextEditor.this.display, newRgb); |
| } |
| if (TextEditor.this.underlineSingleItem.getSelection()) |
| setStyle(UNDERLINE_SINGLE); |
| else if (TextEditor.this.underlineDoubleItem.getSelection()) |
| setStyle(UNDERLINE_DOUBLE); |
| else if (TextEditor.this.underlineErrorItem.getSelection()) |
| setStyle(UNDERLINE_ERROR); |
| else if (TextEditor.this.underlineSquiggleItem.getSelection()) |
| setStyle(UNDERLINE_SQUIGGLE); |
| } |
| } |
| }); |
| |
| final ToolItem underlineControl = new ToolItem(styleToolBar, SWT.DROP_DOWN); |
| underlineControl.setImage(this.iUnderline); |
| underlineControl.setToolTipText(getResourceString("Underline")); //$NON-NLS-1$ |
| underlineControl.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| if (event.detail == SWT.ARROW) { |
| Rectangle rect = underlineControl.getBounds(); |
| Point pt = new Point(rect.x, rect.y + rect.height); |
| underlineMenu.setLocation(TextEditor.this.display.map(underlineControl.getParent(), null, pt)); |
| underlineMenu.setVisible(true); |
| } else { |
| if (TextEditor.this.underlineSingleItem.getSelection()) |
| setStyle(UNDERLINE_SINGLE); |
| else if (TextEditor.this.underlineDoubleItem.getSelection()) |
| setStyle(UNDERLINE_DOUBLE); |
| else if (TextEditor.this.underlineErrorItem.getSelection()) |
| setStyle(UNDERLINE_ERROR); |
| else if (TextEditor.this.underlineSquiggleItem.getSelection()) |
| setStyle(UNDERLINE_SQUIGGLE); |
| } |
| } |
| }); |
| |
| ToolItem strikeoutControl = new ToolItem(styleToolBar, SWT.DROP_DOWN); |
| strikeoutControl.setImage(this.iStrikeout); |
| strikeoutControl.setToolTipText(getResourceString("Strikeout")); //$NON-NLS-1$ |
| strikeoutControl.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| if (event.detail == SWT.ARROW) { |
| ColorDialog dialog = new ColorDialog(TextEditor.this.shell); |
| RGB rgb = TextEditor.this.strikeoutColor != null ? TextEditor.this.strikeoutColor.getRGB() : null; |
| dialog.setRGB(rgb); |
| RGB newRgb = dialog.open(); |
| if (newRgb == null) |
| return; |
| if (!newRgb.equals(rgb)) { |
| disposeResource(TextEditor.this.strikeoutColor); |
| TextEditor.this.strikeoutColor = new Color(TextEditor.this.display, newRgb); |
| } |
| } |
| setStyle(STRIKEOUT); |
| } |
| }); |
| |
| final Menu borderMenu = new Menu(this.shell, SWT.POP_UP); |
| this.borderSolidItem = new MenuItem(borderMenu, SWT.RADIO); |
| this.borderSolidItem.setText(getResourceString("Solid")); //$NON-NLS-1$ |
| this.borderSolidItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| if (TextEditor.this.borderSolidItem.getSelection()) { |
| setStyle(BORDER_SOLID); |
| } |
| } |
| }); |
| this.borderSolidItem.setSelection(true); |
| |
| this.borderDashItem = new MenuItem(borderMenu, SWT.RADIO); |
| this.borderDashItem.setText(getResourceString("Dash")); //$NON-NLS-1$ |
| this.borderDashItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| if (TextEditor.this.borderDashItem.getSelection()) { |
| setStyle(BORDER_DASH); |
| } |
| } |
| }); |
| |
| this.borderDotItem = new MenuItem(borderMenu, SWT.RADIO); |
| this.borderDotItem.setText(getResourceString("Dot")); //$NON-NLS-1$ |
| this.borderDotItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| if (TextEditor.this.borderDotItem.getSelection()) { |
| setStyle(BORDER_DOT); |
| } |
| } |
| }); |
| |
| MenuItem borderColorItem = new MenuItem(borderMenu, SWT.PUSH); |
| borderColorItem.setText(getResourceString("Color_menuitem")); //$NON-NLS-1$ |
| borderColorItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| ColorDialog dialog = new ColorDialog(TextEditor.this.shell); |
| RGB rgb = TextEditor.this.borderColor != null ? TextEditor.this.borderColor.getRGB() : null; |
| dialog.setRGB(rgb); |
| RGB newRgb = dialog.open(); |
| if (newRgb != null) { |
| if (!newRgb.equals(rgb)) { |
| disposeResource(TextEditor.this.borderColor); |
| TextEditor.this.borderColor = new Color(TextEditor.this.display, newRgb); |
| } |
| if (TextEditor.this.borderDashItem.getSelection()) |
| setStyle(BORDER_DASH); |
| else if (TextEditor.this.borderDotItem.getSelection()) |
| setStyle(BORDER_DOT); |
| else if (TextEditor.this.borderSolidItem.getSelection()) |
| setStyle(BORDER_SOLID); |
| } |
| } |
| }); |
| |
| final ToolItem borderControl = new ToolItem(styleToolBar, SWT.DROP_DOWN); |
| borderControl.setImage(this.iBorderStyle); |
| borderControl.setToolTipText(getResourceString("Box")); //$NON-NLS-1$ |
| borderControl.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| if (event.detail == SWT.ARROW) { |
| Rectangle rect = borderControl.getBounds(); |
| Point pt = new Point(rect.x, rect.y + rect.height); |
| borderMenu.setLocation(TextEditor.this.display.map(borderControl.getParent(), null, pt)); |
| borderMenu.setVisible(true); |
| } else { |
| if (TextEditor.this.borderDashItem.getSelection()) |
| setStyle(BORDER_DASH); |
| else if (TextEditor.this.borderDotItem.getSelection()) |
| setStyle(BORDER_DOT); |
| else if (TextEditor.this.borderSolidItem.getSelection()) |
| setStyle(BORDER_SOLID); |
| } |
| } |
| }); |
| |
| ToolItem foregroundItem = new ToolItem(styleToolBar, SWT.DROP_DOWN); |
| foregroundItem.setImage(this.iTextForeground); |
| foregroundItem.setToolTipText(getResourceString("TextForeground")); //$NON-NLS-1$ |
| foregroundItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| if (event.detail == SWT.ARROW || TextEditor.this.textForeground == null) { |
| ColorDialog dialog = new ColorDialog(TextEditor.this.shell); |
| RGB rgb = TextEditor.this.textForeground != null ? TextEditor.this.textForeground.getRGB() : null; |
| dialog.setRGB(rgb); |
| RGB newRgb = dialog.open(); |
| if (newRgb == null) |
| return; |
| if (!newRgb.equals(rgb)) { |
| disposeResource(TextEditor.this.textForeground); |
| TextEditor.this.textForeground = new Color(TextEditor.this.display, newRgb); |
| } |
| } |
| setStyle(FOREGROUND); |
| } |
| }); |
| |
| ToolItem backgroundItem = new ToolItem(styleToolBar, SWT.DROP_DOWN); |
| backgroundItem.setImage(this.iTextBackground); |
| backgroundItem.setToolTipText(getResourceString("TextBackground")); //$NON-NLS-1$ |
| backgroundItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| if (event.detail == SWT.ARROW || TextEditor.this.textBackground == null) { |
| ColorDialog dialog = new ColorDialog(TextEditor.this.shell); |
| RGB rgb = TextEditor.this.textBackground != null ? TextEditor.this.textBackground.getRGB() : null; |
| dialog.setRGB(rgb); |
| RGB newRgb = dialog.open(); |
| if (newRgb == null) |
| return; |
| if (!newRgb.equals(rgb)) { |
| disposeResource(TextEditor.this.textBackground); |
| TextEditor.this.textBackground = new Color(TextEditor.this.display, newRgb); |
| } |
| } |
| setStyle(BACKGROUND); |
| } |
| }); |
| |
| ToolItem baselineUpItem = new ToolItem(styleToolBar, SWT.PUSH); |
| baselineUpItem.setImage(this.iBaselineUp); |
| String tooltip = "IncreaseFont"; //$NON-NLS-1$ |
| if (USE_BASELINE) |
| tooltip = "IncreaseBaseline"; //$NON-NLS-1$ |
| baselineUpItem.setToolTipText(getResourceString(tooltip)); |
| baselineUpItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| if (USE_BASELINE) { |
| setStyle(BASELINE_UP); |
| } else { |
| adjustFontSize(1); |
| } |
| } |
| }); |
| |
| ToolItem baselineDownItem = new ToolItem(styleToolBar, SWT.PUSH); |
| baselineDownItem.setImage(this.iBaselineDown); |
| tooltip = "DecreaseFont"; //$NON-NLS-1$ |
| if (USE_BASELINE) |
| tooltip = "DecreaseBaseline"; //$NON-NLS-1$ |
| baselineDownItem.setToolTipText(getResourceString(tooltip)); |
| baselineDownItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| if (USE_BASELINE) { |
| setStyle(BASELINE_DOWN); |
| } else { |
| adjustFontSize(-1); |
| } |
| } |
| }); |
| ToolItem linkItem = new ToolItem(styleToolBar, SWT.PUSH); |
| linkItem.setImage(this.iLink); |
| linkItem.setToolTipText(getResourceString("Link")); //$NON-NLS-1$ |
| linkItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| setLink(); |
| } |
| }); |
| |
| CoolItem coolItem = new CoolItem(this.coolBar, SWT.NONE); |
| coolItem.setControl(styleToolBar); |
| |
| Composite composite = new Composite(this.coolBar, SWT.NONE); |
| GridLayout layout = new GridLayout(2, false); |
| layout.marginHeight = 1; |
| composite.setLayout(layout); |
| this.fontNameControl = new Combo(composite, SWT.DROP_DOWN | SWT.READ_ONLY); |
| this.fontNameControl.setItems(getFontNames()); |
| this.fontNameControl.setVisibleItemCount(12); |
| this.fontSizeControl = new Combo(composite, SWT.DROP_DOWN | SWT.READ_ONLY); |
| this.fontSizeControl.setItems(FONT_SIZES); |
| this.fontSizeControl.setVisibleItemCount(8); |
| SelectionAdapter adapter = new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| String name = TextEditor.this.fontNameControl.getText(); |
| int size = Integer.parseInt(TextEditor.this.fontSizeControl.getText()); |
| disposeResource(TextEditor.this.textFont); |
| TextEditor.this.textFont = new Font(TextEditor.this.display, name, size, SWT.NORMAL); |
| setStyle(FONT); |
| } |
| }; |
| this.fontSizeControl.addSelectionListener(adapter); |
| this.fontNameControl.addSelectionListener(adapter); |
| coolItem = new CoolItem(this.coolBar, SWT.NONE); |
| coolItem.setControl(composite); |
| |
| ToolBar alignmentToolBar = new ToolBar(this.coolBar, SWT.FLAT); |
| this.blockSelectionItem = new ToolItem(alignmentToolBar, SWT.CHECK); |
| this.blockSelectionItem.setImage(this.iBlockSelection); |
| this.blockSelectionItem.setToolTipText(getResourceString("BlockSelection")); //$NON-NLS-1$ |
| this.blockSelectionItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| TextEditor.this.styledText.invokeAction(ST.TOGGLE_BLOCKSELECTION); |
| } |
| }); |
| |
| this.leftAlignmentItem = new ToolItem(alignmentToolBar, SWT.RADIO); |
| this.leftAlignmentItem.setImage(this.iLeftAlignment); |
| this.leftAlignmentItem.setToolTipText(getResourceString("AlignLeft")); //$NON-NLS-1$ |
| this.leftAlignmentItem.setSelection(true); |
| this.leftAlignmentItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| Point selection = TextEditor.this.styledText.getSelection(); |
| int lineStart = TextEditor.this.styledText.getLineAtOffset(selection.x); |
| int lineEnd = TextEditor.this.styledText.getLineAtOffset(selection.y); |
| TextEditor.this.styledText.setLineAlignment(lineStart, lineEnd - lineStart + 1, SWT.LEFT); |
| } |
| }); |
| this.leftAlignmentItem.setEnabled(false); |
| |
| this.centerAlignmentItem = new ToolItem(alignmentToolBar, SWT.RADIO); |
| this.centerAlignmentItem.setImage(this.iCenterAlignment); |
| this.centerAlignmentItem.setToolTipText(getResourceString("Center_menuitem")); //$NON-NLS-1$ |
| this.centerAlignmentItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| Point selection = TextEditor.this.styledText.getSelection(); |
| int lineStart = TextEditor.this.styledText.getLineAtOffset(selection.x); |
| int lineEnd = TextEditor.this.styledText.getLineAtOffset(selection.y); |
| TextEditor.this.styledText.setLineAlignment(lineStart, lineEnd - lineStart + 1, SWT.CENTER); |
| } |
| }); |
| this.centerAlignmentItem.setEnabled(false); |
| |
| this.rightAlignmentItem = new ToolItem(alignmentToolBar, SWT.RADIO); |
| this.rightAlignmentItem.setImage(this.iRightAlignment); |
| this.rightAlignmentItem.setToolTipText(getResourceString("AlignRight")); //$NON-NLS-1$ |
| this.rightAlignmentItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| Point selection = TextEditor.this.styledText.getSelection(); |
| int lineStart = TextEditor.this.styledText.getLineAtOffset(selection.x); |
| int lineEnd = TextEditor.this.styledText.getLineAtOffset(selection.y); |
| TextEditor.this.styledText.setLineAlignment(lineStart, lineEnd - lineStart + 1, SWT.RIGHT); |
| } |
| }); |
| this.rightAlignmentItem.setEnabled(false); |
| |
| this.justifyAlignmentItem = new ToolItem(alignmentToolBar, SWT.CHECK); |
| this.justifyAlignmentItem.setImage(this.iJustifyAlignment); |
| this.justifyAlignmentItem.setToolTipText(getResourceString("Justify")); //$NON-NLS-1$ |
| this.justifyAlignmentItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| Point selection = TextEditor.this.styledText.getSelection(); |
| int lineStart = TextEditor.this.styledText.getLineAtOffset(selection.x); |
| int lineEnd = TextEditor.this.styledText.getLineAtOffset(selection.y); |
| TextEditor.this.styledText.setLineJustify(lineStart, lineEnd - lineStart + 1, |
| TextEditor.this.justifyAlignmentItem.getSelection()); |
| } |
| }); |
| this.justifyAlignmentItem.setEnabled(false); |
| |
| ToolItem bulletListItem = new ToolItem(alignmentToolBar, SWT.PUSH); |
| bulletListItem.setImage(this.iBulletList); |
| bulletListItem.setToolTipText(getResourceString("BulletList")); //$NON-NLS-1$ |
| bulletListItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| setBullet(ST.BULLET_DOT); |
| } |
| }); |
| |
| ToolItem numberedListItem = new ToolItem(alignmentToolBar, SWT.PUSH); |
| numberedListItem.setImage(this.iNumberedList); |
| numberedListItem.setToolTipText(getResourceString("NumberedList")); //$NON-NLS-1$ |
| numberedListItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| setBullet(ST.BULLET_NUMBER | ST.BULLET_TEXT); |
| } |
| }); |
| |
| coolItem = new CoolItem(this.coolBar, SWT.NONE); |
| coolItem.setControl(alignmentToolBar); |
| composite = new Composite(this.coolBar, SWT.NONE); |
| layout = new GridLayout(4, false); |
| layout.marginHeight = 1; |
| composite.setLayout(layout); |
| Label label = new Label(composite, SWT.NONE); |
| label.setText(getResourceString("Indent")); //$NON-NLS-1$ |
| Spinner indent = new Spinner(composite, SWT.BORDER); |
| indent.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| Spinner spinner = (Spinner) event.widget; |
| TextEditor.this.styledText.setIndent(spinner.getSelection()); |
| } |
| }); |
| label = new Label(composite, SWT.NONE); |
| label.setText(getResourceString("Spacing")); //$NON-NLS-1$ |
| Spinner spacing = new Spinner(composite, SWT.BORDER); |
| spacing.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| Spinner spinner = (Spinner) event.widget; |
| TextEditor.this.styledText.setLineSpacing(spinner.getSelection()); |
| } |
| }); |
| |
| coolItem = new CoolItem(this.coolBar, SWT.NONE); |
| coolItem.setControl(composite); |
| CoolItem[] coolItems = this.coolBar.getItems(); |
| for (int i = 0; i < coolItems.length; i++) { |
| CoolItem item = coolItems[i]; |
| Control control = item.getControl(); |
| Point size = control.computeSize(SWT.DEFAULT, SWT.DEFAULT); |
| item.setMinimumSize(size); |
| size = item.computeSize(size.x, size.y); |
| item.setPreferredSize(size); |
| item.setSize(size); |
| } |
| this.coolBar.addControlListener(new ControlAdapter() { |
| @Override |
| public void controlResized(ControlEvent event) { |
| handleResize(event); |
| } |
| }); |
| } |
| |
| void disposeRanges(StyleRange[] ranges) { |
| StyleRange[] allRanges = this.styledText.getStyleRanges(0, this.styledText.getCharCount(), false); |
| for (int i = 0; i < ranges.length; i++) { |
| StyleRange style = ranges[i]; |
| boolean disposeFg = true, disposeBg = true, disposeStrike = true, disposeUnder = true, disposeBorder = true, |
| disposeFont = true; |
| |
| for (int j = 0; j < allRanges.length; j++) { |
| StyleRange s = allRanges[j]; |
| if (disposeFont && style.font == s.font) |
| disposeFont = false; |
| if (disposeFg && style.foreground == s.foreground) |
| disposeFg = false; |
| if (disposeBg && style.background == s.background) |
| disposeBg = false; |
| if (disposeStrike && style.strikeoutColor == s.strikeoutColor) |
| disposeStrike = false; |
| if (disposeUnder && style.underlineColor == s.underlineColor) |
| disposeUnder = false; |
| if (disposeBorder && style.borderColor == s.borderColor) |
| disposeBorder = false; |
| } |
| if (disposeFont && style.font != this.textFont && style.font != null) |
| style.font.dispose(); |
| if (disposeFg && style.foreground != this.textForeground && style.foreground != null) |
| style.foreground.dispose(); |
| if (disposeBg && style.background != this.textBackground && style.background != null) |
| style.background.dispose(); |
| if (disposeStrike && style.strikeoutColor != this.strikeoutColor && style.strikeoutColor != null) |
| style.strikeoutColor.dispose(); |
| if (disposeUnder && style.underlineColor != this.underlineColor && style.underlineColor != null) |
| style.underlineColor.dispose(); |
| if (disposeBorder && style.borderColor != this.borderColor && style.borderColor != null) |
| style.borderColor.dispose(); |
| |
| Object data = style.data; |
| if (data != null) { |
| if (data instanceof Image) |
| ((Image) data).dispose(); |
| if (data instanceof Control) |
| ((Control) data).dispose(); |
| } |
| } |
| } |
| |
| void disposeResource(Resource resource) { |
| if (resource == null) |
| return; |
| StyleRange[] styles = this.styledText.getStyleRanges(0, this.styledText.getCharCount(), false); |
| int index = 0; |
| while (index < styles.length) { |
| if (styles[index].font == resource) |
| break; |
| if (styles[index].foreground == resource) |
| break; |
| if (styles[index].background == resource) |
| break; |
| if (styles[index].strikeoutColor == resource) |
| break; |
| if (styles[index].underlineColor == resource) |
| break; |
| if (styles[index].borderColor == resource) |
| break; |
| index++; |
| } |
| if (index == styles.length) |
| resource.dispose(); |
| } |
| |
| String[] getFontNames() { |
| FontData[] fontNames = this.display.getFontList(null, true); |
| String[] names = new String[fontNames.length]; |
| int count = 0; |
| mainfor: for (int i = 0; i < fontNames.length; i++) { |
| String fontName = fontNames[i].getName(); |
| if (fontName.startsWith("@")) //$NON-NLS-1$ |
| continue; |
| for (int j = 0; j < count; j++) { |
| if (names[j].equals(fontName)) |
| continue mainfor; |
| } |
| names[count++] = fontName; |
| } |
| if (count < names.length) { |
| String[] newNames = new String[count]; |
| System.arraycopy(names, 0, newNames, 0, count); |
| names = newNames; |
| } |
| return names; |
| } |
| |
| StyleRange[] getStyles(InputStream stream) { |
| try { |
| StyleRange[] styles = new StyleRange[256]; |
| int count = 0; |
| BufferedReader reader = new BufferedReader(new InputStreamReader(stream)); |
| String line; |
| while ((line = reader.readLine()) != null) { |
| StringTokenizer tokenizer = new StringTokenizer(line, ";", false); //$NON-NLS-1$ |
| StyleRange range = new StyleRange(); |
| range.start = Integer.parseInt(tokenizer.nextToken()); |
| range.length = Integer.parseInt(tokenizer.nextToken()); |
| range.fontStyle = Integer.parseInt(tokenizer.nextToken()); |
| range.strikeout = tokenizer.nextToken().equals("true"); //$NON-NLS-1$ |
| range.underline = tokenizer.nextToken().equals("true"); //$NON-NLS-1$ |
| if (tokenizer.hasMoreTokens()) { |
| int red = Integer.parseInt(tokenizer.nextToken()); |
| int green = Integer.parseInt(tokenizer.nextToken()); |
| int blue = Integer.parseInt(tokenizer.nextToken()); |
| range.foreground = new Color(this.display, red, green, blue); |
| } |
| if (tokenizer.hasMoreTokens()) { |
| int red = Integer.parseInt(tokenizer.nextToken()); |
| int green = Integer.parseInt(tokenizer.nextToken()); |
| int blue = Integer.parseInt(tokenizer.nextToken()); |
| range.background = new Color(this.display, red, green, blue); |
| } |
| if (count >= styles.length) { |
| StyleRange[] newStyles = new StyleRange[styles.length + 256]; |
| System.arraycopy(styles, 0, newStyles, 0, styles.length); |
| styles = newStyles; |
| } |
| styles[count++] = range; |
| } |
| if (count < styles.length) { |
| StyleRange[] newStyles = new StyleRange[count]; |
| System.arraycopy(styles, 0, newStyles, 0, count); |
| styles = newStyles; |
| } |
| return styles; |
| } catch (IOException e) { |
| showError(getResourceString("Error"), e.getMessage()); //$NON-NLS-1$ |
| } |
| return null; |
| } |
| |
| void handleKeyDown(Event event) { |
| if (event.keyCode == SWT.INSERT) { |
| this.insert = !this.insert; |
| } |
| } |
| |
| void handleModify(ModifyEvent event) { |
| if (this.newCharCount > 0 && this.start >= 0) { |
| StyleRange style = new StyleRange(); |
| if (this.textFont != null && !this.textFont.equals(this.styledText.getFont())) { |
| style.font = this.textFont; |
| } else { |
| style.fontStyle = SWT.NONE; |
| if (this.boldControl.getSelection()) |
| style.fontStyle |= SWT.BOLD; |
| if (this.italicControl.getSelection()) |
| style.fontStyle |= SWT.ITALIC; |
| } |
| if ((this.styleState & FOREGROUND) != 0) { |
| style.foreground = this.textForeground; |
| } |
| if ((this.styleState & BACKGROUND) != 0) { |
| style.background = this.textBackground; |
| } |
| int underlineStyle = this.styleState & UNDERLINE; |
| if (underlineStyle != 0) { |
| style.underline = true; |
| style.underlineColor = this.underlineColor; |
| switch (underlineStyle) { |
| case UNDERLINE_SINGLE: |
| style.underlineStyle = SWT.UNDERLINE_SINGLE; |
| break; |
| case UNDERLINE_DOUBLE: |
| style.underlineStyle = SWT.UNDERLINE_DOUBLE; |
| break; |
| case UNDERLINE_SQUIGGLE: |
| style.underlineStyle = SWT.UNDERLINE_SQUIGGLE; |
| break; |
| case UNDERLINE_ERROR: |
| style.underlineStyle = SWT.UNDERLINE_ERROR; |
| break; |
| case UNDERLINE_LINK: { |
| style.underlineColor = null; |
| if (this.link != null && this.link.length() > 0) { |
| style.underlineStyle = SWT.UNDERLINE_LINK; |
| style.data = this.link; |
| } else { |
| style.underline = false; |
| } |
| break; |
| } |
| } |
| } |
| if ((this.styleState & STRIKEOUT) != 0) { |
| style.strikeout = true; |
| style.strikeoutColor = this.strikeoutColor; |
| } |
| int borderStyle = this.styleState & BORDER; |
| if (borderStyle != 0) { |
| style.borderColor = this.borderColor; |
| switch (borderStyle) { |
| case BORDER_DASH: |
| style.borderStyle = SWT.BORDER_DASH; |
| break; |
| case BORDER_DOT: |
| style.borderStyle = SWT.BORDER_DOT; |
| break; |
| case BORDER_SOLID: |
| style.borderStyle = SWT.BORDER_SOLID; |
| break; |
| } |
| } |
| int[] ranges = { this.start, this.newCharCount }; |
| StyleRange[] styles = { style }; |
| this.styledText.setStyleRanges(this.start, this.newCharCount, ranges, styles); |
| } |
| disposeRanges(this.selectedRanges); |
| } |
| |
| void handleMouseUp(Event event) { |
| if (this.link != null) { |
| int offset = this.styledText.getCaretOffset(); |
| StyleRange range = offset > 0 ? this.styledText.getStyleRangeAtOffset(offset - 1) : null; |
| if (range != null) { |
| if (this.link == range.data) { |
| Shell dialog = new Shell(this.shell); |
| dialog.setLayout(new FillLayout()); |
| dialog.setText(getResourceString("Browser")); //$NON-NLS-1$ |
| Browser browser = new Browser(dialog, SWT.NONE); |
| browser.setUrl(this.link); |
| dialog.open(); |
| } |
| } |
| } |
| } |
| |
| void handlePaintObject(PaintObjectEvent event) { |
| GC gc = event.gc; |
| StyleRange style = event.style; |
| Object data = style.data; |
| if (data instanceof Image) { |
| Image image = (Image) data; |
| int x = event.x; |
| int y = event.y + event.ascent - style.metrics.ascent; |
| gc.drawImage(image, x, y); |
| } |
| if (data instanceof Control) { |
| Control control = (Control) data; |
| Point pt = control.getSize(); |
| int x = event.x + MARGIN; |
| int y = event.y + event.ascent - 2 * pt.y / 3; |
| control.setLocation(x, y); |
| } |
| } |
| |
| void handleResize(ControlEvent event) { |
| Rectangle rect = this.shell.getClientArea(); |
| Point cSize = this.coolBar.computeSize(rect.width, SWT.DEFAULT); |
| Point sSize = this.statusBar.computeSize(SWT.DEFAULT, SWT.DEFAULT); |
| int statusMargin = 2; |
| this.coolBar.setBounds(rect.x, rect.y, cSize.x, cSize.y); |
| this.styledText.setBounds(rect.x, rect.y + cSize.y, rect.width, |
| rect.height - cSize.y - (sSize.y + 2 * statusMargin)); |
| this.statusBar.setBounds(rect.x + statusMargin, rect.y + rect.height - sSize.y - statusMargin, |
| rect.width - (2 * statusMargin), sSize.y); |
| } |
| |
| void handleVerifyText(VerifyEvent event) { |
| this.start = event.start; |
| this.newCharCount = event.text.length(); |
| int replaceCharCount = event.end - this.start; |
| |
| // mark styles to be disposed |
| this.selectedRanges = this.styledText.getStyleRanges(this.start, replaceCharCount, false); |
| } |
| |
| void initResources() { |
| this.iBold = loadImage(this.display, "bold"); //$NON-NLS-1$ |
| this.iItalic = loadImage(this.display, "italic"); //$NON-NLS-1$ |
| this.iUnderline = loadImage(this.display, "underline"); //$NON-NLS-1$ |
| this.iStrikeout = loadImage(this.display, "strikeout"); //$NON-NLS-1$ |
| this.iBlockSelection = loadImage(this.display, "fullscrn"); //$NON-NLS-1$ |
| this.iBorderStyle = loadImage(this.display, "resize"); //$NON-NLS-1$ |
| this.iLeftAlignment = loadImage(this.display, "left"); //$NON-NLS-1$ |
| this.iRightAlignment = loadImage(this.display, "right"); //$NON-NLS-1$ |
| this.iCenterAlignment = loadImage(this.display, "center"); //$NON-NLS-1$ |
| this.iJustifyAlignment = loadImage(this.display, "justify"); //$NON-NLS-1$ |
| this.iCut = loadImage(this.display, "cut"); //$NON-NLS-1$ |
| this.iCopy = loadImage(this.display, "copy"); //$NON-NLS-1$ |
| this.iPaste = loadImage(this.display, "paste"); //$NON-NLS-1$ |
| this.iTextForeground = loadImage(this.display, "textForeground"); //$NON-NLS-1$ |
| this.iTextBackground = loadImage(this.display, "textBackground"); //$NON-NLS-1$ |
| this.iBaselineUp = loadImage(this.display, "font_big"); //$NON-NLS-1$ |
| this.iBaselineDown = loadImage(this.display, "font_sml"); //$NON-NLS-1$ |
| this.iBulletList = loadImage(this.display, "para_bul"); //$NON-NLS-1$ |
| this.iNumberedList = loadImage(this.display, "para_num"); //$NON-NLS-1$ |
| this.iLink = new Image(this.display, getClass().getResourceAsStream("link_obj.gif")); //$NON-NLS-1$ |
| } |
| |
| void installListeners() { |
| this.styledText.addCaretListener(new CaretListener() { |
| @Override |
| public void caretMoved(CaretEvent event) { |
| updateStatusBar(); |
| updateToolBar(); |
| } |
| }); |
| this.styledText.addListener(SWT.MouseUp, new Listener() { |
| @Override |
| public void handleEvent(Event event) { |
| handleMouseUp(event); |
| } |
| }); |
| this.styledText.addListener(SWT.KeyDown, new Listener() { |
| @Override |
| public void handleEvent(Event event) { |
| handleKeyDown(event); |
| } |
| }); |
| this.styledText.addVerifyListener(new VerifyListener() { |
| @Override |
| public void verifyText(VerifyEvent event) { |
| handleVerifyText(event); |
| } |
| }); |
| this.styledText.addModifyListener(new ModifyListener() { |
| @Override |
| public void modifyText(ModifyEvent event) { |
| handleModify(event); |
| } |
| }); |
| this.styledText.addPaintObjectListener(new PaintObjectListener() { |
| @Override |
| public void paintObject(PaintObjectEvent event) { |
| handlePaintObject(event); |
| } |
| }); |
| this.styledText.addListener(SWT.Dispose, new Listener() { |
| @Override |
| public void handleEvent(Event event) { |
| StyleRange[] styles = TextEditor.this.styledText.getStyleRanges(0, |
| TextEditor.this.styledText.getCharCount(), false); |
| for (int i = 0; i < styles.length; i++) { |
| Object data = styles[i].data; |
| if (data != null) { |
| if (data instanceof Image) |
| ((Image) data).dispose(); |
| if (data instanceof Control) |
| ((Control) data).dispose(); |
| } |
| } |
| } |
| }); |
| this.shell.addControlListener(new ControlAdapter() { |
| @Override |
| public void controlResized(ControlEvent event) { |
| handleResize(event); |
| } |
| }); |
| } |
| |
| Image loadImage(Display display, String fileName) { |
| Image image = null; |
| try { |
| InputStream sourceStream = getClass().getResourceAsStream(fileName + ".ico"); //$NON-NLS-1$ |
| ImageData source = new ImageData(sourceStream); |
| ImageData mask = source.getTransparencyMask(); |
| image = new Image(display, source, mask); |
| sourceStream.close(); |
| } catch (IOException e) { |
| showError(getResourceString("Error"), e.getMessage()); //$NON-NLS-1$ |
| } |
| return image; |
| } |
| |
| void loadProfile(int profile) { |
| try { |
| switch (profile) { |
| case 1: { |
| String text = openFile(TextEditor.class.getResourceAsStream("text.txt")); //$NON-NLS-1$ |
| StyleRange[] styles = getStyles(TextEditor.class.getResourceAsStream("styles.txt")); //$NON-NLS-1$ |
| this.styledText.setText(text); |
| if (styles != null) |
| this.styledText.setStyleRanges(styles); |
| break; |
| } |
| case 2: { |
| this.styledText.setText(getResourceString("Profile2")); //$NON-NLS-1$ |
| break; |
| } |
| case 3: { |
| String text = openFile(TextEditor.class.getResourceAsStream("text4.txt")); //$NON-NLS-1$ |
| this.styledText.setText(text); |
| break; |
| } |
| case 4: { |
| this.styledText.setText(getResourceString("Profile4")); //$NON-NLS-1$ |
| break; |
| } |
| } |
| updateToolBar(); |
| } catch (Exception e) { |
| showError(getResourceString("Error"), e.getMessage()); //$NON-NLS-1$ |
| } |
| } |
| |
| String openFile(InputStream stream) throws IOException { |
| BufferedReader reader = new BufferedReader(new InputStreamReader(stream)); |
| StringBuffer buffer = new StringBuffer(); |
| String line; |
| String lineDelimiter = this.styledText.getLineDelimiter(); |
| while ((line = reader.readLine()) != null) { |
| buffer.append(line); |
| buffer.append(lineDelimiter); |
| } |
| return buffer.toString(); |
| } |
| |
| void releaseResources() { |
| this.iBold.dispose(); |
| this.iBold = null; |
| this.iItalic.dispose(); |
| this.iItalic = null; |
| this.iUnderline.dispose(); |
| this.iUnderline = null; |
| this.iStrikeout.dispose(); |
| this.iStrikeout = null; |
| this.iBorderStyle.dispose(); |
| this.iBorderStyle = null; |
| this.iBlockSelection.dispose(); |
| this.iBlockSelection = null; |
| this.iLeftAlignment.dispose(); |
| this.iLeftAlignment = null; |
| this.iRightAlignment.dispose(); |
| this.iRightAlignment = null; |
| this.iCenterAlignment.dispose(); |
| this.iCenterAlignment = null; |
| this.iJustifyAlignment.dispose(); |
| this.iJustifyAlignment = null; |
| this.iCut.dispose(); |
| this.iCut = null; |
| this.iCopy.dispose(); |
| this.iCopy = null; |
| this.iPaste.dispose(); |
| this.iPaste = null; |
| this.iTextForeground.dispose(); |
| this.iTextForeground = null; |
| this.iTextBackground.dispose(); |
| this.iTextBackground = null; |
| this.iBaselineUp.dispose(); |
| this.iBaselineUp = null; |
| this.iBaselineDown.dispose(); |
| this.iBaselineDown = null; |
| this.iBulletList.dispose(); |
| this.iBulletList = null; |
| this.iNumberedList.dispose(); |
| this.iNumberedList = null; |
| this.iLink.dispose(); |
| this.iLink = null; |
| |
| if (this.textFont != null) |
| this.textFont.dispose(); |
| this.textFont = null; |
| if (this.textForeground != null) |
| this.textForeground.dispose(); |
| this.textForeground = null; |
| if (this.textBackground != null) |
| this.textBackground.dispose(); |
| this.textBackground = null; |
| if (this.strikeoutColor != null) |
| this.strikeoutColor.dispose(); |
| this.strikeoutColor = null; |
| if (this.underlineColor != null) |
| this.underlineColor.dispose(); |
| this.underlineColor = null; |
| if (this.borderColor != null) |
| this.borderColor.dispose(); |
| this.borderColor = null; |
| |
| if (this.font != null) |
| this.font.dispose(); |
| this.font = null; |
| } |
| |
| void saveFile() { |
| if (this.fileName != null) { |
| FileWriter file = null; |
| try { |
| file = new FileWriter(this.fileName); |
| file.write(this.styledText.getText()); |
| file.close(); |
| } catch (IOException e) { |
| showError(getResourceString("Error"), e.getMessage()); |
| } finally { |
| try { |
| if (file != null) |
| file.close(); |
| } catch (IOException e) { |
| showError(getResourceString("Error"), e.getMessage()); |
| } |
| } |
| } |
| } |
| |
| void setBullet(int type) { |
| Point selection = this.styledText.getSelection(); |
| int lineStart = this.styledText.getLineAtOffset(selection.x); |
| int lineEnd = this.styledText.getLineAtOffset(selection.y); |
| StyleRange styleRange = new StyleRange(); |
| styleRange.metrics = new GlyphMetrics(0, 0, BULLET_WIDTH); |
| Bullet bullet = new Bullet(type, styleRange); |
| bullet.text = "."; |
| for (int lineIndex = lineStart; lineIndex <= lineEnd; lineIndex++) { |
| Bullet oldBullet = this.styledText.getLineBullet(lineIndex); |
| this.styledText.setLineBullet(lineIndex, 1, oldBullet != null ? null : bullet); |
| } |
| } |
| |
| void setLink() { |
| final Shell dialog = new Shell(this.shell, SWT.APPLICATION_MODAL | SWT.SHELL_TRIM); |
| dialog.setLayout(new GridLayout(2, false)); |
| dialog.setText(getResourceString("SetLink")); //$NON-NLS-1$ |
| Label label = new Label(dialog, SWT.NONE); |
| label.setText(getResourceString("URL")); //$NON-NLS-1$ |
| final Text text = new Text(dialog, SWT.SINGLE); |
| text.setLayoutData(new GridData(200, SWT.DEFAULT)); |
| if (this.link != null) { |
| text.setText(this.link); |
| text.selectAll(); |
| } |
| final Button okButton = new Button(dialog, SWT.PUSH); |
| okButton.setText(getResourceString("Ok")); //$NON-NLS-1$ |
| final Button cancelButton = new Button(dialog, SWT.PUSH); |
| cancelButton.setText(getResourceString("Cancel")); //$NON-NLS-1$ |
| Listener listener = new Listener() { |
| @Override |
| public void handleEvent(Event event) { |
| if (event.widget == okButton) { |
| TextEditor.this.link = text.getText(); |
| setStyle(UNDERLINE_LINK); |
| } |
| dialog.dispose(); |
| } |
| }; |
| okButton.addListener(SWT.Selection, listener); |
| cancelButton.addListener(SWT.Selection, listener); |
| dialog.setDefaultButton(okButton); |
| dialog.pack(); |
| dialog.open(); |
| while (!dialog.isDisposed()) { |
| if (!this.display.readAndDispatch()) { |
| this.display.sleep(); |
| } |
| } |
| } |
| |
| void setStyle(int style) { |
| int[] ranges = this.styledText.getSelectionRanges(); |
| int i = 0; |
| while (i < ranges.length) { |
| setStyle(style, ranges[i++], ranges[i++]); |
| } |
| updateStyleState(style, FOREGROUND); |
| updateStyleState(style, BACKGROUND); |
| updateStyleState(style, UNDERLINE); |
| updateStyleState(style, STRIKEOUT); |
| updateStyleState(style, BORDER); |
| } |
| |
| void setStyle(int style, int start, int length) { |
| if (length == 0) |
| return; |
| |
| /* Create new style range */ |
| StyleRange newRange = new StyleRange(); |
| if ((style & FONT) != 0) { |
| newRange.font = this.textFont; |
| } |
| if ((style & FONT_STYLE) != 0) { |
| newRange.fontStyle = style & FONT_STYLE; |
| } |
| if ((style & FOREGROUND) != 0) { |
| newRange.foreground = this.textForeground; |
| } |
| if ((style & BACKGROUND) != 0) { |
| newRange.background = this.textBackground; |
| } |
| if ((style & BASELINE_UP) != 0) |
| newRange.rise++; |
| if ((style & BASELINE_DOWN) != 0) |
| newRange.rise--; |
| if ((style & STRIKEOUT) != 0) { |
| newRange.strikeout = true; |
| newRange.strikeoutColor = this.strikeoutColor; |
| } |
| if ((style & UNDERLINE) != 0) { |
| newRange.underline = true; |
| newRange.underlineColor = this.underlineColor; |
| switch (style & UNDERLINE) { |
| case UNDERLINE_SINGLE: |
| newRange.underlineStyle = SWT.UNDERLINE_SINGLE; |
| break; |
| case UNDERLINE_DOUBLE: |
| newRange.underlineStyle = SWT.UNDERLINE_DOUBLE; |
| break; |
| case UNDERLINE_ERROR: |
| newRange.underlineStyle = SWT.UNDERLINE_ERROR; |
| break; |
| case UNDERLINE_SQUIGGLE: |
| newRange.underlineStyle = SWT.UNDERLINE_SQUIGGLE; |
| break; |
| case UNDERLINE_LINK: |
| newRange.underlineColor = null; |
| if (this.link != null && this.link.length() > 0) { |
| newRange.underlineStyle = SWT.UNDERLINE_LINK; |
| newRange.data = this.link; |
| } else { |
| newRange.underline = false; |
| } |
| break; |
| } |
| } |
| if ((style & BORDER) != 0) { |
| switch (style & BORDER) { |
| case BORDER_DASH: |
| newRange.borderStyle = SWT.BORDER_DASH; |
| break; |
| case BORDER_DOT: |
| newRange.borderStyle = SWT.BORDER_DOT; |
| break; |
| case BORDER_SOLID: |
| newRange.borderStyle = SWT.BORDER_SOLID; |
| break; |
| } |
| newRange.borderColor = this.borderColor; |
| } |
| |
| int newRangeStart = start; |
| int newRangeLength = length; |
| int[] ranges = this.styledText.getRanges(start, length); |
| StyleRange[] styles = this.styledText.getStyleRanges(start, length, false); |
| int maxCount = ranges.length * 2 + 2; |
| int[] newRanges = new int[maxCount]; |
| StyleRange[] newStyles = new StyleRange[maxCount / 2]; |
| int count = 0; |
| for (int i = 0; i < ranges.length; i += 2) { |
| int rangeStart = ranges[i]; |
| int rangeLength = ranges[i + 1]; |
| StyleRange range = styles[i / 2]; |
| if (rangeStart > newRangeStart) { |
| newRangeLength = rangeStart - newRangeStart; |
| newRanges[count] = newRangeStart; |
| newRanges[count + 1] = newRangeLength; |
| newStyles[count / 2] = newRange; |
| count += 2; |
| } |
| newRangeStart = rangeStart + rangeLength; |
| newRangeLength = (start + length) - newRangeStart; |
| |
| /* Create merged style range */ |
| StyleRange mergedRange = new StyleRange(range); |
| // Note: fontStyle is not copied by the constructor |
| mergedRange.fontStyle = range.fontStyle; |
| if ((style & FONT) != 0) { |
| mergedRange.font = newRange.font; |
| } |
| if ((style & FONT_STYLE) != 0) { |
| mergedRange.fontStyle = range.fontStyle ^ newRange.fontStyle; |
| } |
| if (mergedRange.font != null && ((style & FONT) != 0 || (style & FONT_STYLE) != 0)) { |
| boolean change = false; |
| FontData[] fds = mergedRange.font.getFontData(); |
| for (int j = 0; j < fds.length; j++) { |
| FontData fd = fds[j]; |
| if (fd.getStyle() != mergedRange.fontStyle) { |
| fds[j].setStyle(mergedRange.fontStyle); |
| change = true; |
| } |
| } |
| if (change) { |
| mergedRange.font = new Font(this.display, fds); |
| } |
| } |
| if ((style & FOREGROUND) != 0) { |
| mergedRange.foreground = newRange.foreground != range.foreground ? newRange.foreground : null; |
| } |
| if ((style & BACKGROUND) != 0) { |
| mergedRange.background = newRange.background != range.background ? newRange.background : null; |
| } |
| if ((style & BASELINE_UP) != 0) |
| mergedRange.rise++; |
| if ((style & BASELINE_DOWN) != 0) |
| mergedRange.rise--; |
| if ((style & STRIKEOUT) != 0) { |
| mergedRange.strikeout = !range.strikeout || range.strikeoutColor != newRange.strikeoutColor; |
| mergedRange.strikeoutColor = mergedRange.strikeout ? newRange.strikeoutColor : null; |
| } |
| if ((style & UNDERLINE) != 0) { |
| if ((style & UNDERLINE_LINK) != 0) { |
| if (this.link != null && this.link.length() > 0) { |
| mergedRange.underline = !range.underline || range.underlineStyle != newRange.underlineStyle |
| || range.data != newRange.data; |
| } else { |
| mergedRange.underline = false; |
| } |
| mergedRange.underlineColor = null; |
| } else { |
| mergedRange.underline = !range.underline || range.underlineStyle != newRange.underlineStyle |
| || range.underlineColor != newRange.underlineColor; |
| mergedRange.underlineColor = mergedRange.underline ? newRange.underlineColor : null; |
| } |
| mergedRange.underlineStyle = mergedRange.underline ? newRange.underlineStyle : SWT.NONE; |
| mergedRange.data = mergedRange.underline ? newRange.data : null; |
| } |
| if ((style & BORDER) != 0) { |
| if (range.borderStyle != newRange.borderStyle || range.borderColor != newRange.borderColor) { |
| mergedRange.borderStyle = newRange.borderStyle; |
| mergedRange.borderColor = newRange.borderColor; |
| } else { |
| mergedRange.borderStyle = SWT.NONE; |
| mergedRange.borderColor = null; |
| } |
| } |
| |
| newRanges[count] = rangeStart; |
| newRanges[count + 1] = rangeLength; |
| newStyles[count / 2] = mergedRange; |
| count += 2; |
| } |
| if (newRangeLength > 0) { |
| newRanges[count] = newRangeStart; |
| newRanges[count + 1] = newRangeLength; |
| newStyles[count / 2] = newRange; |
| count += 2; |
| } |
| if (0 < count && count < maxCount) { |
| int[] tmpRanges = new int[count]; |
| StyleRange[] tmpStyles = new StyleRange[count / 2]; |
| System.arraycopy(newRanges, 0, tmpRanges, 0, count); |
| System.arraycopy(newStyles, 0, tmpStyles, 0, count / 2); |
| newRanges = tmpRanges; |
| newStyles = tmpStyles; |
| } |
| this.styledText.setStyleRanges(start, length, newRanges, newStyles); |
| disposeRanges(styles); |
| } |
| |
| void showError(String title, String message) { |
| MessageBox messageBox = new MessageBox(this.shell, SWT.ICON_ERROR | SWT.CLOSE); |
| messageBox.setText(title); |
| messageBox.setMessage(message); |
| messageBox.open(); |
| } |
| |
| void updateStatusBar() { |
| int offset = this.styledText.getCaretOffset(); |
| int lineIndex = this.styledText.getLineAtOffset(offset); |
| String insertLabel = getResourceString(this.insert ? "Insert" : "Overwrite"); //$NON-NLS-1$ //$NON-NLS-2$ |
| this.statusBar.setText(getResourceString("Offset") //$NON-NLS-1$ |
| + offset + " " //$NON-NLS-1$ |
| + getResourceString("Line") //$NON-NLS-1$ |
| + lineIndex + "\t" //$NON-NLS-1$ |
| + insertLabel); |
| } |
| |
| void updateStyleState(int style, int changingStyle) { |
| if ((style & changingStyle) != 0) { |
| if ((style & changingStyle) == (this.styleState & changingStyle)) { |
| this.styleState &= ~changingStyle; |
| } else { |
| this.styleState &= ~changingStyle; |
| this.styleState |= style; |
| } |
| } |
| } |
| |
| void updateToolBar() { |
| this.styleState = 0; |
| this.link = null; |
| boolean bold = false, italic = false; |
| Font font = null; |
| |
| int offset = this.styledText.getCaretOffset(); |
| StyleRange range = offset > 0 ? this.styledText.getStyleRangeAtOffset(offset - 1) : null; |
| if (range != null) { |
| if (range.font != null) { |
| font = range.font; |
| FontData[] fds = font.getFontData(); |
| for (int i = 0; i < fds.length; i++) { |
| int fontStyle = fds[i].getStyle(); |
| if (!bold && (fontStyle & SWT.BOLD) != 0) |
| bold = true; |
| if (!italic && (fontStyle & SWT.ITALIC) != 0) |
| italic = true; |
| } |
| } else { |
| bold = (range.fontStyle & SWT.BOLD) != 0; |
| italic = (range.fontStyle & SWT.ITALIC) != 0; |
| } |
| if (range.foreground != null) { |
| this.styleState |= FOREGROUND; |
| if (this.textForeground != range.foreground) { |
| disposeResource(this.textForeground); |
| this.textForeground = range.foreground; |
| } |
| } |
| if (range.background != null) { |
| this.styleState |= BACKGROUND; |
| if (this.textBackground != range.background) { |
| disposeResource(this.textBackground); |
| this.textBackground = range.background; |
| } |
| } |
| if (range.underline) { |
| switch (range.underlineStyle) { |
| case SWT.UNDERLINE_SINGLE: |
| this.styleState |= UNDERLINE_SINGLE; |
| break; |
| case SWT.UNDERLINE_DOUBLE: |
| this.styleState |= UNDERLINE_DOUBLE; |
| break; |
| case SWT.UNDERLINE_SQUIGGLE: |
| this.styleState |= UNDERLINE_SQUIGGLE; |
| break; |
| case SWT.UNDERLINE_ERROR: |
| this.styleState |= UNDERLINE_ERROR; |
| break; |
| case SWT.UNDERLINE_LINK: |
| this.styleState |= UNDERLINE_LINK; |
| this.link = (String) range.data; |
| break; |
| } |
| if (range.underlineStyle != SWT.UNDERLINE_LINK) { |
| this.underlineSingleItem.setSelection((this.styleState & UNDERLINE_SINGLE) != 0); |
| this.underlineDoubleItem.setSelection((this.styleState & UNDERLINE_DOUBLE) != 0); |
| this.underlineErrorItem.setSelection((this.styleState & UNDERLINE_ERROR) != 0); |
| this.underlineSquiggleItem.setSelection((this.styleState & UNDERLINE_SQUIGGLE) != 0); |
| disposeResource(this.underlineColor); |
| this.underlineColor = range.underlineColor; |
| } |
| } |
| if (range.strikeout) { |
| this.styleState |= STRIKEOUT; |
| disposeResource(this.strikeoutColor); |
| this.strikeoutColor = range.strikeoutColor; |
| } |
| if (range.borderStyle != SWT.NONE) { |
| switch (range.borderStyle) { |
| case SWT.BORDER_SOLID: |
| this.styleState |= BORDER_SOLID; |
| break; |
| case SWT.BORDER_DASH: |
| this.styleState |= BORDER_DASH; |
| break; |
| case SWT.BORDER_DOT: |
| this.styleState |= BORDER_DOT; |
| break; |
| } |
| this.borderSolidItem.setSelection((this.styleState & BORDER_SOLID) != 0); |
| this.borderDashItem.setSelection((this.styleState & BORDER_DASH) != 0); |
| this.borderDotItem.setSelection((this.styleState & BORDER_DOT) != 0); |
| disposeResource(this.borderColor); |
| this.borderColor = range.borderColor; |
| } |
| } |
| |
| this.boldControl.setSelection(bold); |
| this.italicControl.setSelection(italic); |
| FontData fontData = font != null ? font.getFontData()[0] : this.styledText.getFont().getFontData()[0]; |
| int index = 0; |
| int count = this.fontNameControl.getItemCount(); |
| String fontName = fontData.getName(); |
| while (index < count) { |
| if (this.fontNameControl.getItem(index).equals(fontName)) { |
| this.fontNameControl.select(index); |
| break; |
| } |
| index++; |
| } |
| index = 0; |
| count = this.fontSizeControl.getItemCount(); |
| int fontSize = fontData.getHeight(); |
| while (index < count) { |
| int size = Integer.parseInt(this.fontSizeControl.getItem(index)); |
| if (fontSize == size) { |
| this.fontSizeControl.select(index); |
| break; |
| } |
| if (size > fontSize) { |
| this.fontSizeControl.add(String.valueOf(fontSize), index); |
| this.fontSizeControl.select(index); |
| break; |
| } |
| index++; |
| } |
| |
| disposeResource(this.textFont); |
| this.textFont = font; |
| int lineIndex = this.styledText.getLineAtOffset(offset); |
| int alignment = this.styledText.getLineAlignment(lineIndex); |
| this.leftAlignmentItem.setSelection((alignment & SWT.LEFT) != 0); |
| this.centerAlignmentItem.setSelection((alignment & SWT.CENTER) != 0); |
| this.rightAlignmentItem.setSelection((alignment & SWT.RIGHT) != 0); |
| boolean justify = this.styledText.getLineJustify(lineIndex); |
| this.justifyAlignmentItem.setSelection(justify); |
| } |
| } |
