Java tutorial
/******************************************************************************* * Copyright (c) 2003, 2011 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.wst.server.ui.internal.editor; import java.beans.PropertyChangeEvent; import java.beans.PropertyChangeListener; import java.util.*; import java.util.List; import org.eclipse.core.commands.operations.IUndoableOperation; import org.eclipse.core.resources.IFile; import org.eclipse.core.resources.IMarker; import org.eclipse.core.runtime.*; import org.eclipse.jface.action.*; import org.eclipse.jface.dialogs.IDialogConstants; import org.eclipse.jface.dialogs.MessageDialog; import org.eclipse.jface.viewers.ILabelProvider; import org.eclipse.jface.window.Window; import org.eclipse.osgi.util.NLS; import org.eclipse.swt.events.*; import org.eclipse.swt.widgets.*; import org.eclipse.ui.*; import org.eclipse.ui.part.MultiPageEditorPart; import org.eclipse.wst.server.core.*; import org.eclipse.wst.server.core.internal.Server; import org.eclipse.wst.server.core.internal.ServerWorkingCopy; import org.eclipse.wst.server.ui.ServerUICore; import org.eclipse.wst.server.ui.editor.*; import org.eclipse.wst.server.ui.internal.*; /** * A multi-page server resource editor. */ public class ServerEditor extends MultiPageEditorPart { /** * Internal part and shell activation listener */ class ActivationListener extends ShellAdapter implements IPartListener { private IWorkbenchPart fActivePart; private boolean fIsHandlingActivation = false; public void partActivated(IWorkbenchPart part) { fActivePart = part; handleActivation(); } public void partBroughtToTop(IWorkbenchPart part) { // do nothing } public void partClosed(IWorkbenchPart part) { // do nothing } public void partDeactivated(IWorkbenchPart part) { fActivePart = null; } public void partOpened(IWorkbenchPart part) { // do nothing } public void shellActivated(ShellEvent e) { handleActivation(); } private void handleActivation() { if (fIsHandlingActivation) return; if (fActivePart == ServerEditor.this) { fIsHandlingActivation = true; try { checkResourceState(); } finally { fIsHandlingActivation = false; } } } } class LifecycleListener implements IServerLifecycleListener { public void serverAdded(IServer oldServer) { // do nothing } public void serverChanged(IServer oldServer) { // do nothing } public void serverRemoved(IServer oldServer) { if (oldServer.equals(server.getOriginal())) { resourceDeleted = true; if (!isDirty()) { closeEditor(); } else { Display.getDefault().asyncExec(new Runnable() { public void run() { checkAndCloseEditorOnDeletedServer(); } }); } } } } protected IServerWorkingCopy server; protected String serverId; protected String serverName; protected GlobalCommandManager commandManager; protected PropertyChangeListener listener; protected IAction undoAction; protected IAction redoAction; protected TextAction cutAction; protected TextAction copyAction; protected TextAction pasteAction; protected boolean updatingActions; protected IAction[] editorActions; protected java.util.List<IEditorPart> serverPages; // on focus change flag protected boolean resourceDeleted; // input given to the contained pages protected IServerEditorPartInput editorPartInput; // status line and status protected IStatusLineManager status; protected StatusLineContributionItem statusItem; private ActivationListener activationListener = new ActivationListener(); protected LifecycleListener resourceListener; // used for disabling resource change check when saving through editor protected boolean isSaving = false; protected Map<IEditorPart, IServerEditorPartFactory> pageToFactory = new HashMap<IEditorPart, IServerEditorPartFactory>(); /** * ServerEditor constructor comment. */ public ServerEditor() { super(); ISharedImages sharedImages = PlatformUI.getWorkbench().getSharedImages(); undoAction = new Action() { public void run() { getCommandManager().undo(serverId); } }; undoAction.setEnabled(false); undoAction.setImageDescriptor(sharedImages.getImageDescriptor(ISharedImages.IMG_TOOL_UNDO)); //undoAction.setHoverImageDescriptor(sharedImages.getImageDescriptor(ISharedImages.IMG_TOOL_UNDO_HOVER)); //undoAction.setDisabledImageDescriptor(sharedImages.getImageDescriptor(ISharedImages.IMG_TOOL_UNDO_DISABLED)); redoAction = new Action() { public void run() { getCommandManager().redo(serverId); } }; redoAction.setEnabled(false); redoAction.setImageDescriptor(sharedImages.getImageDescriptor(ISharedImages.IMG_TOOL_REDO)); //redoAction.setHoverImageDescriptor(sharedImages.getImageDescriptor(ISharedImages.IMG_TOOL_REDO_HOVER)); //redoAction.setDisabledImageDescriptor(sharedImages.getImageDescriptor(ISharedImages.IMG_TOOL_REDO_DISABLED)); } /** * Close the editor correctly. */ protected void closeEditor() { Display.getDefault().asyncExec(new Runnable() { public void run() { getEditorSite().getPage().closeEditor(ServerEditor.this, false); } }); } protected void createActions() { List<IAction> actionList = new ArrayList<IAction>(); // add server actions if (server != null && server.getServerType() != null) { Iterator iterator = ServerEditorCore.getServerEditorActionFactories().iterator(); String id = server.getServerType().getId(); while (iterator.hasNext()) { ServerEditorActionFactory factory = (ServerEditorActionFactory) iterator.next(); if (factory.supportsServerElementType(id) && factory.shouldDisplay(server)) actionList.add(factory.createAction(getEditorSite(), editorPartInput)); } } editorActions = new IAction[actionList.size()]; actionList.toArray(editorActions); } public IServerEditorPartFactory getPageFactory(ServerEditorPart part) { try { return pageToFactory.get(part); } catch (Exception e) { // ignore } return null; } /** * Creates the pages of this multi-page editor. * <p> * Subclasses of <code>MultiPageEditor</code> must implement this method. * </p> */ protected void createPages() { try { int index = 0; serverPages = new ArrayList<IEditorPart>(); // add editor pages int pageCount = 0; String serverTypeId = null; if (server != null && server.getServerType() != null) serverTypeId = server.getServerType().getId(); Iterator iterator = ServerEditorCore.getServerEditorPageFactories().iterator(); while (iterator.hasNext()) { IServerEditorPartFactory factory = (IServerEditorPartFactory) iterator.next(); if (factory.supportsType(serverTypeId) && factory.shouldCreatePage(server)) { if (Trace.FINEST) { Trace.trace(Trace.STRING_FINEST, "Adding page: " + factory.getId() + " " + editorPartInput); } try { IEditorPart page = factory.createPage(); if (page != null) { pageToFactory.put(page, factory); index = addPage(page, editorPartInput); setPageText(index, factory.getName()); serverPages.add(page); pageCount++; } } catch (Exception e) { if (Trace.SEVERE) { Trace.trace(Trace.STRING_SEVERE, "Could not display editor page " + factory.getId(), e); } } } } if (pageCount > 0) setActivePage(0); // register for events that might change the cut/copy/paste actions int count = getPageCount(); for (int i = 0; i < count; i++) { Control control = getControl(i); registerEvents(control); } updateActions(); } catch (Exception e) { if (Trace.SEVERE) { Trace.trace(Trace.STRING_SEVERE, "Error creating server editor pages", e); } } } public void dispose() { if (activationListener != null) { IWorkbenchWindow window = getSite().getWorkbenchWindow(); window.getPartService().removePartListener(activationListener); Shell shell = window.getShell(); if (shell != null && !shell.isDisposed()) shell.removeShellListener(activationListener); activationListener = null; } if (resourceListener != null) ServerCore.removeServerLifecycleListener(resourceListener); if (serverName != null && !server.getName().equals(serverName)) { // only prompt if the server is in the workspace or there is a configuration if (server.getServerConfiguration() != null || ((Server) server).getFile() != null) { String title = Messages.editorServerEditor; String message = Messages.editorRenameFiles; if (MessageDialog.openQuestion(getEditorSite().getShell(), title, message)) try { ((ServerWorkingCopy) server).renameFiles(null); } catch (Exception e) { if (Trace.SEVERE) { Trace.trace(Trace.STRING_SEVERE, "Error renaming server", e); } } } } super.dispose(); if (commandManager != null) { commandManager.removePropertyChangeListener(listener); if (serverId != null) commandManager.releaseCommandManager(serverId); commandManager = null; } } /* (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) { // set the isSaving flag to true isSaving = true; // check pages for errors first java.util.List<String> errors = new ArrayList<String>(); Iterator iterator = serverPages.iterator(); int count = 0; int maxSeverity = -1; while (iterator.hasNext()) { IEditorPart part = (IEditorPart) iterator.next(); if (part instanceof ServerEditorPart) { IStatus[] status2 = ((ServerEditorPart) part).getSaveStatus(); if (status2 != null) { int size = status2.length; for (int i = 0; i < size; i++) { errors.add("[" + getPageText(count) + "] " + status2[i].getMessage()); maxSeverity = Math.max(maxSeverity, status2[i].getSeverity()); } } } count++; } if (!errors.isEmpty() && maxSeverity > IStatus.OK) { StringBuffer sb = new StringBuffer(); sb.append(Messages.errorEditorCantSave + "\n"); iterator = errors.iterator(); while (iterator.hasNext()) sb.append("\t" + ((String) iterator.next()) + "\n"); if (maxSeverity == IStatus.ERROR) { MessageDialog.openError(getEditorSite().getShell(), getPartName(), sb.toString()); monitor.setCanceled(true); // reset the isSaving flag isSaving = false; return; } else if (maxSeverity == IStatus.WARNING) MessageDialog.openWarning(getEditorSite().getShell(), getPartName(), sb.toString()); else // if (maxSeverity == IStatus.INFO) MessageDialog.openInformation(getEditorSite().getShell(), getPartName(), sb.toString()); } try { monitor = ProgressUtil.getMonitorFor(monitor); int ticks = 2000; int pages = serverPages == null ? 0 : serverPages.size(); int pagesTicks = (pages * 100); String name = ""; if (server != null) name = server.getName(); monitor.beginTask(NLS.bind(Messages.savingTask, name), ticks + pagesTicks); if (server != null) ticks /= 2; if (server != null) { iterator = serverPages.iterator(); while (iterator.hasNext()) { IEditorPart part = (IEditorPart) iterator.next(); part.doSave(ProgressUtil.getSubMonitorFor(monitor, 100)); } server.save(false, ProgressUtil.getSubMonitorFor(monitor, ticks)); getCommandManager().resourceSaved(serverId); commandManager.updateTimestamps(serverId); } ILabelProvider labelProvider = ServerUICore.getLabelProvider(); if (server != null) setPartName(labelProvider.getText(server)); labelProvider.dispose(); } catch (Exception e) { if (Trace.SEVERE) { Trace.trace(Trace.STRING_SEVERE, "Error saving server editor", e); } monitor.setCanceled(true); String title = Messages.editorSaveErrorDialog; String message = NLS.bind(Messages.editorSaveErrorMessage, e.getLocalizedMessage()); MessageDialog.openError(getEditorSite().getShell(), title, message); } finally { monitor.done(); } // reset the isSaving flag isSaving = false; } /* (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 } /** * Fire a property change event. * * @param i a property change value */ protected void firePropertyChange(int i) { if (i == ServerEditorPart.PROP_ERROR) updateStatusError(); super.firePropertyChange(i); } /** * Return the global command manager. * * @return the global command manager */ public GlobalCommandManager getCommandManager() { return commandManager; } /** * Return the redo action. * * @return org.eclipse.jface.action.Action */ public IAction getRedoAction() { return redoAction; } /** * Return the undo action. * * @return org.eclipse.jface.action.Action */ public IAction getUndoAction() { return undoAction; } /* (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 } /** * Update the cut, copy, and paste actions. */ public void updateActionsImpl() { if (updatingActions) return; updatingActions = true; Display.getDefault().asyncExec(new Runnable() { public void run() { updatingActions = false; updateActions(); } }); } /** * Update the cut, copy, and paste actions. */ public void updateActions() { cutAction.update(); copyAction.update(); pasteAction.update(); } /** * Update the cut, copy, and paste actions. */ protected void updateStatusLine() { if (statusItem != null) { boolean readOnly = false; if (server != null && commandManager.isReadOnly(serverId)) readOnly = true; if (readOnly) statusItem.setText(Messages.editorReadOnly); else statusItem.setText(Messages.editorWritable); } if (status != null) { StringBuffer sb = new StringBuffer(); boolean first = true; if (server != null) { IFile[] files = commandManager.getReadOnlyFiles(serverId); for (int i = 0; i < files.length; i++) { if (!first) sb.append(", "); sb.append(files[i].getName()); first = false; } } /*if (serverConfiguration != null) { IFile[] files = commandManager.getReadOnlyFiles(serverConfigurationId); for (int i = 0; i < files.length; i++) { if (!first) sb.append(", "); sb.append(files[i].getName()); first = false; } }*/ if (sb.length() > 1) status.setMessage(NLS.bind(Messages.editorReadOnlyFiles, sb.toString())); else status.setMessage(""); } } /** * */ public void updateStatusError() { if (status == null) return; String error = null; IEditorPart part = getActiveEditor(); if (part instanceof ServerEditorPart) error = ((ServerEditorPart) part).getErrorMessage(); Iterator iterator = serverPages.iterator(); int count = 0; while (error == null && iterator.hasNext()) { part = (IEditorPart) iterator.next(); if (part instanceof ServerEditorPart) { error = ((ServerEditorPart) part).getErrorMessage(); if (error != null) error = "[" + getPageText(count) + "] " + error; } count++; } status.setErrorMessage(error); } /** * */ protected void pageChange(int newPageIndex) { super.pageChange(newPageIndex); updateStatusError(); } /** * Set the status. * * @param status a status line manager * @param item a status contribution item */ public void setStatus(IStatusLineManager status, StatusLineContributionItem item) { this.status = status; this.statusItem = item; updateStatusError(); } /** * Register for key and traversal events to enable/disable the cut/copy/paste actions. */ protected void registerEvents(Control control) { if (control == null) return; if (control instanceof Text || control instanceof Combo) { // register the world... any of these actions could cause the state to change control.addTraverseListener(new TraverseListener() { public void keyTraversed(TraverseEvent event) { updateActionsImpl(); } }); control.addKeyListener(new KeyListener() { public void keyPressed(KeyEvent event) { updateActionsImpl(); } public void keyReleased(KeyEvent event) { updateActionsImpl(); } }); control.addMouseListener(new MouseListener() { public void mouseDown(MouseEvent event) { // do nothing } public void mouseUp(MouseEvent event) { updateActionsImpl(); } public void mouseDoubleClick(MouseEvent event) { updateActionsImpl(); } }); control.addFocusListener(new FocusListener() { public void focusGained(FocusEvent event) { updateActionsImpl(); } public void focusLost(FocusEvent event) { updateActionsImpl(); } }); if (control instanceof Text) { Text text = (Text) control; text.addModifyListener(new ModifyListener() { public void modifyText(ModifyEvent event) { updateActionsImpl(); } }); text.addSelectionListener(new SelectionListener() { public void widgetSelected(SelectionEvent event) { updateActionsImpl(); } public void widgetDefaultSelected(SelectionEvent event) { updateActionsImpl(); } }); } else { Combo combo = (Combo) control; combo.addModifyListener(new ModifyListener() { public void modifyText(ModifyEvent event) { updateActionsImpl(); } }); combo.addSelectionListener(new SelectionListener() { public void widgetSelected(SelectionEvent event) { updateActionsImpl(); } public void widgetDefaultSelected(SelectionEvent event) { updateActionsImpl(); } }); } } if (control instanceof Composite) { Control[] children = ((Composite) control).getChildren(); if (children != null) { int size = children.length; for (int i = 0; i < size; i++) registerEvents(children[i]); } } } /* (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 { commandManager = GlobalCommandManager.getInstance(); super.init(site, input); if (input instanceof IFileEditorInput) { IFileEditorInput fei = (IFileEditorInput) input; IFile file = fei.getFile(); if (file != null && file.exists()) { IServer server2 = ServerUIPlugin.findServer(file); if (server2 != null) serverId = server2.getId(); } if (serverId == null) { if (file == null) throw new PartInitException(NLS.bind(Messages.errorEditor, Messages.elementUnknownName)); throw new PartInitException(NLS.bind(Messages.errorEditor, file.getName())); } } else if (input instanceof IServerEditorInput) { IServerEditorInput sei = (IServerEditorInput) input; serverId = sei.getServerId(); } if (serverId != null) { commandManager.getCommandManager(serverId); server = commandManager.getServerResource(serverId); } ILabelProvider labelProvider = ServerUICore.getLabelProvider(); if (server != null) { setPartName(labelProvider.getText(server)); setTitleImage(labelProvider.getImage(server)); setTitleToolTip(serverId); serverName = server.getName(); } else setPartName("-"); labelProvider.dispose(); labelProvider = null; cutAction = new TextAction(site.getShell().getDisplay(), TextAction.CUT_ACTION); copyAction = new TextAction(site.getShell().getDisplay(), TextAction.COPY_ACTION); pasteAction = new TextAction(site.getShell().getDisplay(), TextAction.PASTE_ACTION); listener = new PropertyChangeListener() { public void propertyChange(PropertyChangeEvent event) { if (GlobalCommandManager.PROP_DIRTY.equals(event.getPropertyName())) { Object obj = event.getOldValue(); if (obj == serverId) firePropertyChange(PROP_DIRTY); } else if (GlobalCommandManager.PROP_UNDO.equals(event.getPropertyName())) { Object obj = event.getOldValue(); if (obj == serverId) updateUndoAction(); } else if (GlobalCommandManager.PROP_REDO.equals(event.getPropertyName())) { Object obj = event.getOldValue(); if (obj == serverId) updateRedoAction(); } else if (GlobalCommandManager.PROP_RELOAD.equals(event.getPropertyName())) { Object obj = event.getOldValue(); if (obj == serverId) { server = commandManager.getServerResource(serverId); refresh(); } } } }; if (server != null && commandManager.isDirty(serverId)) firePropertyChange(PROP_DIRTY); commandManager.addPropertyChangeListener(listener); // create editor input ServerResourceCommandManager serverCommandManager = null; if (server != null) serverCommandManager = new ServerResourceCommandManager(this, serverId, commandManager); editorPartInput = commandManager.getPartInput(serverId, serverCommandManager); createActions(); // add resource listener resourceListener = new LifecycleListener(); ServerCore.addServerLifecycleListener(resourceListener); IWorkbenchWindow window = getSite().getWorkbenchWindow(); window.getPartService().addPartListener(activationListener); window.getShell().addShellListener(activationListener); } /* (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() { if (commandManager != null) { if (server != null && commandManager.isDirty(serverId)) return true; } 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; } /** * Update the undo action. */ protected void updateUndoAction() { IUndoableOperation command = commandManager.getUndoCommand(serverId); if (command == null) { undoAction.setText(Messages.editorUndoDisabled); undoAction.setToolTipText(""); undoAction.setDescription(""); undoAction.setEnabled(false); } else { String text = NLS.bind(Messages.editorUndoEnabled, new Object[] { command.getLabel() }); undoAction.setText(text); undoAction.setToolTipText(command.getLabel()); undoAction.setDescription(command.getLabel()); undoAction.setEnabled(true); } } /** * Update the redo action. */ protected void updateRedoAction() { IUndoableOperation command = commandManager.getRedoCommand(serverId); if (command == null) { redoAction.setText(Messages.editorRedoDisabled); redoAction.setToolTipText(""); redoAction.setDescription(""); redoAction.setEnabled(false); } else { String text = NLS.bind(Messages.editorRedoEnabled, new Object[] { command.getLabel() }); redoAction.setText(text); redoAction.setToolTipText(command.getLabel()); redoAction.setDescription(command.getLabel()); redoAction.setEnabled(true); } } /** * Return the cut action. * * @return org.eclipse.jface.action.IAction */ public IAction getCutAction() { return cutAction; } /** * Return the copy action. * * @return org.eclipse.jface.action.IAction */ public IAction getCopyAction() { return copyAction; } /** * Return the paste action. * * @return org.eclipse.jface.action.IAction */ public IAction getPasteAction() { return pasteAction; } /** * Returns the editor actions. * * @return org.eclipse.jface.action.IAction */ public IAction[] getEditorActions() { return editorActions; } /** * Update the server pages with new input. */ protected void refresh() { // create editor input ServerResourceCommandManager serverCommandManager = null; if (server != null) serverCommandManager = new ServerResourceCommandManager(this, serverId, commandManager); editorPartInput = commandManager.getPartInput(serverId, serverCommandManager); Iterator iterator = serverPages.iterator(); while (iterator.hasNext()) { IEditorPart part = (IEditorPart) iterator.next(); try { part.init(part.getEditorSite(), editorPartInput); } catch (Exception e) { if (Trace.SEVERE) { Trace.trace(Trace.STRING_SEVERE, "Error refresh()ing editor part", e); } } } } /** * */ protected void promptReadOnlyServerFile(String id) { commandManager.setReadOnly(id, true); String title = Messages.editorResourceModifiedTitle; String message = Messages.editorReadOnlyMessage; MessageDialog.openInformation(getEditorSite().getShell(), title, message); } /** * */ protected void promptReloadServerFile(String id) { String title = Messages.editorResourceModifiedTitle; String message = Messages.editorServerModifiedMessage; if (MessageDialog.openQuestion(getEditorSite().getShell(), title, message)) { /*try { //wc.refreshLocal(IResource.DEPTH_ONE, new NullProgressMonitor()); //TODO: refresh local server } catch (Exception e) { Trace.trace(Trace.SEVERE, "Error refreshing server", e); }*/ commandManager.reload(id); } } /** * */ public void setFocus() { super.setFocus(); } void checkAndCloseEditorOnDeletedServer() { // check for deleted files if (resourceDeleted) { String title = Messages.editorResourceDeleteTitle; String message = null; if (server != null) message = NLS.bind(Messages.editorResourceDeleteServerMessage, server.getName()); String[] labels = new String[] { Messages.editorResourceDeleteSave, IDialogConstants.CLOSE_LABEL }; MessageDialog dialog = new MessageDialog(getEditorSite().getShell(), title, null, message, MessageDialog.INFORMATION, labels, 0); if (dialog.open() == 0) doSave(new NullProgressMonitor()); else closeEditor(); } resourceDeleted = false; } /** * */ protected void checkResourceState() { // do not check the resource state change if saving through the editor if (isSaving) { // do nothing return; } // check for deleted files checkAndCloseEditorOnDeletedServer(); // check for server changes if (serverId != null) { if (!commandManager.isDirty(serverId)) { if (commandManager.hasChanged(serverId)) { IServer newServer = ServerCore.findServer(serverId); if (newServer != null && ((Server) newServer).getTimestamp() > ((Server) server).getTimestamp()) commandManager.reload(serverId); else promptReloadServerFile(serverId); } } else { if (commandManager.hasChanged(serverId) && !commandManager.areFilesReadOnly(serverId)) promptReloadServerFile(serverId); else if (commandManager.areFilesReadOnly(serverId) && !commandManager.isReadOnly(serverId)) promptReadOnlyServerFile(serverId); } if (commandManager.isReadOnly(serverId) && !commandManager.areFilesReadOnly(serverId)) commandManager.setReadOnly(serverId, false); commandManager.updateTimestamps(serverId); } updateStatusLine(); } /** * Set the title tooltip. * * @return the title tooltip */ public String getTitleToolTip() { Server server2 = (Server) server; if (server != null && server2.getFile() != null) return server2.getFile().getFullPath().toString(); else if (server != null) return server.getName(); else return "error"; } public int getOrientation() { return Window.getDefaultOrientation(); } }