| /******************************************************************************* |
| * Copyright (c) 2001 Rational Software Corp. and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Common Public License v0.5 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/cpl-v05.html |
| * |
| * Contributors: |
| * Rational Software - initial implementation |
| ******************************************************************************/ |
| package org.eclipse.cdt.ui.wizards; |
| |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.InputStream; |
| import java.lang.reflect.InvocationTargetException; |
| import java.text.MessageFormat; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| |
| import org.eclipse.cdt.core.CConventions; |
| import org.eclipse.cdt.core.model.CModelException; |
| import org.eclipse.cdt.core.model.CoreModel; |
| import org.eclipse.cdt.core.model.ICElement; |
| import org.eclipse.cdt.core.model.ICProject; |
| import org.eclipse.cdt.core.model.IOpenable; |
| import org.eclipse.cdt.core.model.IParent; |
| import org.eclipse.cdt.core.model.IStructure; |
| import org.eclipse.cdt.core.model.ITranslationUnit; |
| import org.eclipse.cdt.core.search.BasicSearchMatch; |
| import org.eclipse.cdt.core.search.BasicSearchResultCollector; |
| import org.eclipse.cdt.core.search.ICSearchConstants; |
| import org.eclipse.cdt.core.search.ICSearchPattern; |
| import org.eclipse.cdt.core.search.ICSearchScope; |
| import org.eclipse.cdt.core.search.SearchEngine; |
| import org.eclipse.cdt.internal.core.model.IWorkingCopy; |
| import org.eclipse.cdt.internal.ui.dialogs.StatusInfo; |
| import org.eclipse.cdt.internal.ui.dialogs.StatusUtil; |
| import org.eclipse.cdt.internal.ui.wizards.NewWizardMessages; |
| import org.eclipse.cdt.internal.ui.wizards.dialogfields.DialogField; |
| import org.eclipse.cdt.internal.ui.wizards.dialogfields.IDialogFieldListener; |
| import org.eclipse.cdt.internal.ui.wizards.dialogfields.IListAdapter; |
| import org.eclipse.cdt.internal.ui.wizards.dialogfields.IStringButtonAdapter; |
| import org.eclipse.cdt.internal.ui.wizards.dialogfields.LayoutUtil; |
| import org.eclipse.cdt.internal.ui.wizards.dialogfields.LinkToFileGroup; |
| import org.eclipse.cdt.internal.ui.wizards.dialogfields.ListDialogField; |
| import org.eclipse.cdt.internal.ui.wizards.dialogfields.SelectionButtonDialogFieldGroup; |
| import org.eclipse.cdt.internal.ui.wizards.dialogfields.Separator; |
| import org.eclipse.cdt.internal.ui.wizards.dialogfields.StringButtonDialogField; |
| import org.eclipse.cdt.internal.ui.wizards.dialogfields.StringDialogField; |
| import org.eclipse.cdt.ui.CSearchResultLabelProvider; |
| import org.eclipse.cdt.ui.CUIPlugin; |
| import org.eclipse.cdt.ui.CodeGeneration; |
| import org.eclipse.cdt.ui.PreferenceConstants; |
| import org.eclipse.core.resources.IContainer; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IResourceStatus; |
| import org.eclipse.core.resources.IWorkspaceRoot; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.core.runtime.OperationCanceledException; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.runtime.SubProgressMonitor; |
| import org.eclipse.jface.dialogs.ErrorDialog; |
| import org.eclipse.jface.dialogs.MessageDialog; |
| import org.eclipse.jface.operation.IRunnableWithProgress; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.wizard.WizardPage; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Event; |
| import org.eclipse.swt.widgets.Listener; |
| import org.eclipse.ui.actions.WorkspaceModifyOperation; |
| import org.eclipse.ui.dialogs.ContainerGenerator; |
| import org.eclipse.ui.dialogs.ElementListSelectionDialog; |
| import org.eclipse.ui.internal.WorkbenchMessages; |
| import org.eclipse.ui.internal.WorkbenchPlugin; |
| |
| /** |
| * Wizard page to create a new class. |
| * <p> |
| * Note: This class is not intended to be subclassed. To implement a different kind of |
| * a new class wizard page, extend <code>NewTypeWizardPage</code>. |
| * </p> |
| * |
| */ |
| |
| public class NewClassWizardPage extends WizardPage implements Listener { |
| // the page name |
| private final static String PAGE_NAME= "NewClassWizardPage"; |
| private final String HEADER_EXT = ".h"; |
| private final String BODY_EXT = ".cpp"; |
| |
| // the current resource selection |
| private IStructuredSelection currentSelection; |
| // cache of C Model current selection |
| private ICElement eSelection = null; |
| |
| // cache of newly-created files |
| private ITranslationUnit parentHeaderTU = null; |
| private ITranslationUnit parentBodyTU = null; |
| // the created class element |
| private /*IStructure*/ ICElement createdClass = null; |
| |
| private List elementsOfTypeClassInProject = null; |
| |
| // Controls |
| private StringDialogField fClassNameDialogField; |
| private StringButtonDialogField fBaseClassDialogField; |
| private SelectionButtonDialogFieldGroup fAccessButtons; |
| private SelectionButtonDialogFieldGroup fConstDestButtons; |
| private LinkToFileGroup linkedResourceGroupForHeader; |
| private LinkToFileGroup linkedResourceGroupForBody; |
| |
| private final int PUBLIC_INDEX= 0, PROTECTED_INDEX= 1, PRIVATE_INDEX= 2, DEFAULT_INDEX= 3; |
| |
| private IStatus fCurrStatus; |
| protected IStatus fClassNameStatus; |
| protected IStatus fBaseClassStatus; |
| |
| private boolean hasCppNature = false; |
| |
| BasicSearchResultCollector resultCollector; |
| SearchEngine searchEngine; |
| |
| // -------------------- Initialization ------------------ |
| public NewClassWizardPage(IStructuredSelection selection) { |
| super(PAGE_NAME); |
| currentSelection = selection; |
| hasCppNature = isSelectionCPP(currentSelection); |
| if(hasCppNature){ |
| initializePageControls(); |
| } |
| } |
| |
| protected void initializePageControls(){ |
| TypeFieldsAdapter adapter= new TypeFieldsAdapter(); |
| |
| fClassNameDialogField= new StringDialogField(); |
| fClassNameDialogField.setDialogFieldListener(adapter); |
| fClassNameDialogField.setLabelText(NewWizardMessages.getString("NewClassWizardPage.classname.label")); |
| |
| fBaseClassDialogField= new StringButtonDialogField(adapter); |
| fBaseClassDialogField.setDialogFieldListener(adapter); |
| fBaseClassDialogField.setLabelText(NewWizardMessages.getString("NewClassWizardPage.baseclass.label")); |
| fBaseClassDialogField.setButtonLabel(NewWizardMessages.getString("NewClassWizardPage.baseclass.button")); |
| |
| String[] buttonNames1= new String[] { |
| /* 0 == PUBLIC_INDEX */ NewWizardMessages.getString("NewClassWizardPage.baseclass.access.public"), |
| /* 1 == PROTECTED_INDEX */ NewWizardMessages.getString("NewClassWizardPage.baseclass.access.protected"), |
| /* 2 == PRIVATE_INDEX */ NewWizardMessages.getString("NewClassWizardPage.baseclass.access.private"), |
| /* 3 == DEFAULT_INDEX */ NewWizardMessages.getString("NewClassWizardPage.baseclass.access.access") |
| }; |
| fAccessButtons= new SelectionButtonDialogFieldGroup(SWT.RADIO, buttonNames1, 4); |
| fAccessButtons.setDialogFieldListener(adapter); |
| fAccessButtons.setLabelText(NewWizardMessages.getString("NewClassWizardPage.baseclass.access.label")); |
| fAccessButtons.setSelection(0, true); |
| |
| String[] buttonNames2= new String[] { |
| /* 0 == INLINE_INDEX */ NewWizardMessages.getString("NewClassWizardPage.constdest.inline"), |
| /* 1 == VIRTUAL_DEST_INDEX */ NewWizardMessages.getString("NewClassWizardPage.constdest.virtualdestructor"), |
| /* 2 == INCLUDE_GUARD_INDEX */ NewWizardMessages.getString("NewClassWizardPage.constdest.includeguard"), |
| }; |
| |
| fConstDestButtons= new SelectionButtonDialogFieldGroup(SWT.CHECK, buttonNames2, 3); |
| fConstDestButtons.setDialogFieldListener(adapter); |
| |
| linkedResourceGroupForHeader = new LinkToFileGroup(adapter, this); |
| linkedResourceGroupForHeader.setLabelText(NewWizardMessages.getString("NewClassWizardPage.files.header")); |
| linkedResourceGroupForBody = new LinkToFileGroup(adapter, this); |
| linkedResourceGroupForBody.setLabelText(NewWizardMessages.getString("NewClassWizardPage.files.body")); |
| |
| fClassNameStatus= new StatusInfo(); |
| fBaseClassStatus= new StatusInfo(); |
| |
| resultCollector = new BasicSearchResultCollector (); |
| searchEngine = new SearchEngine(); |
| } |
| |
| public void init() { |
| if(hasCppNature){ |
| fAccessButtons.setEnabled(false); |
| setPageComplete(false); |
| eSelection = getSelectionCElement(currentSelection); |
| }else { |
| StatusInfo status = new StatusInfo(); |
| status.setError(NewWizardMessages.getString("NewClassWizardPage.error.NotAvailableForNonCppProjects")); //$NON-NLS-1$ |
| updateStatus(status); |
| } |
| } |
| |
| // ----------------- Creating Controls -------------------- |
| /* (non-Javadoc) |
| * @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite) |
| */ |
| public void createControl(Composite parent) { |
| if(!hasCppNature) |
| { |
| setControl(new Composite(parent, SWT.NULL)); |
| return; |
| } |
| |
| int nColumns= 5; |
| |
| initializeDialogUnits(parent); |
| // top level group |
| Composite composite = new Composite(parent, SWT.NULL); |
| composite.setLayout(new GridLayout(nColumns, false)); |
| composite.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| |
| composite.setFont(parent.getFont()); |
| //WorkbenchHelp.setHelp(composite, IHelpContextIds.NEW_FILE_WIZARD_PAGE); |
| |
| createClassNameControls(composite, nColumns); |
| createBaseClassControls(composite, nColumns); |
| createModifierControls(composite, nColumns); |
| createSeparator(composite, nColumns); |
| createFilesControls(composite, nColumns); |
| |
| composite.layout(); |
| |
| setErrorMessage(null); |
| setMessage(null); |
| setControl(composite); |
| |
| } |
| |
| protected void createClassNameControls(Composite composite, int nColumns) { |
| fClassNameDialogField.doFillIntoGrid(composite, nColumns - 1); |
| DialogField.createEmptySpace(composite); |
| LayoutUtil.setWidthHint(fClassNameDialogField.getTextControl(null), getMaxFieldWidth()); |
| } |
| |
| protected void createBaseClassControls(Composite composite, int nColumns) { |
| fBaseClassDialogField.doFillIntoGrid(composite, nColumns); |
| LayoutUtil.setWidthHint(fBaseClassDialogField.getTextControl(null), getMaxFieldWidth()); |
| createAccessControls(composite, nColumns); |
| } |
| |
| protected void createAccessControls(Composite composite, int nColumns){ |
| LayoutUtil.setHorizontalSpan(fAccessButtons.getLabelControl(composite), 1); |
| |
| Control control= fAccessButtons.getSelectionButtonsGroup(composite); |
| GridData gd= new GridData(GridData.HORIZONTAL_ALIGN_FILL); |
| gd.horizontalSpan= nColumns - 2; |
| control.setLayoutData(gd); |
| |
| DialogField.createEmptySpace(composite); |
| |
| } |
| |
| protected void createModifierControls(Composite composite, int nColumns) { |
| LayoutUtil.setHorizontalSpan(fConstDestButtons.getLabelControl(composite), 1); |
| |
| Control control= fConstDestButtons.getSelectionButtonsGroup(composite); |
| GridData gd= new GridData(GridData.HORIZONTAL_ALIGN_FILL); |
| gd.horizontalSpan= nColumns - 1; |
| control.setLayoutData(gd); |
| |
| DialogField.createEmptySpace(composite); |
| } |
| |
| |
| protected void createFilesControls(Composite composite, int nColumns){ |
| linkedResourceGroupForHeader.doFillIntoGrid(composite, nColumns); |
| linkedResourceGroupForBody.doFillIntoGrid(composite, nColumns); |
| } |
| |
| /** |
| * Creates a separator line. Expects a <code>GridLayout</code> with at least 1 column. |
| * |
| * @param composite the parent composite |
| * @param nColumns number of columns to span |
| */ |
| protected void createSeparator(Composite composite, int nColumns) { |
| (new Separator(SWT.SEPARATOR | SWT.HORIZONTAL)).doFillIntoGrid(composite, nColumns, convertHeightInCharsToPixels(1)); |
| } |
| /** |
| * Returns the recommended maximum width for text fields (in pixels). This |
| * method requires that createContent has been called before this method is |
| * call. Subclasses may override to change the maximum width for text |
| * fields. |
| * |
| * @return the recommended maximum width for text fields. |
| */ |
| protected int getMaxFieldWidth() { |
| return convertWidthInCharsToPixels(40); |
| } |
| |
| // --------------------- listeners -------------------------- |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.swt.widgets.Listener#handleEvent(org.eclipse.swt.widgets.Event) |
| */ |
| public void handleEvent(Event event) { |
| |
| } |
| |
| private class TypeFieldsAdapter implements IStringButtonAdapter, IDialogFieldListener, IListAdapter { |
| |
| // -------- IStringButtonAdapter |
| public void changeControlPressed(DialogField field) { |
| classPageChangeControlPressed(field); |
| } |
| |
| // -------- IListAdapter |
| public void customButtonPressed(ListDialogField field, int index) { |
| classPageCustomButtonPressed(field, index); |
| } |
| |
| public void selectionChanged(ListDialogField field) {} |
| |
| // -------- IDialogFieldListener |
| public void dialogFieldChanged(DialogField field) { |
| classPageDialogFieldChanged(field); |
| } |
| |
| public void doubleClicked(ListDialogField field) { |
| } |
| } |
| |
| private void classPageChangeControlPressed(DialogField field) { |
| if (field == fBaseClassDialogField) { |
| BasicSearchMatch element= (BasicSearchMatch)chooseBaseClass(); |
| if (element != null) { |
| fBaseClassDialogField.setText(element.getName()); |
| } |
| } |
| } |
| |
| private void classPageCustomButtonPressed(DialogField field, int index) { |
| } |
| |
| /* |
| * A field on the type has changed. The fields' status and all dependend |
| * status are updated. |
| */ |
| private void classPageDialogFieldChanged(DialogField field) { |
| if(field == fClassNameDialogField){ |
| String text = fClassNameDialogField.getText(); |
| if(!linkedResourceGroupForHeader.linkCreated()){ |
| if (text.length() > 0) { |
| linkedResourceGroupForHeader.setText(text + HEADER_EXT); |
| } else { |
| linkedResourceGroupForHeader.setText(text); |
| } |
| } |
| if(!linkedResourceGroupForBody.linkCreated()){ |
| if (text.length() > 0) { |
| linkedResourceGroupForBody.setText(text + BODY_EXT); |
| } else{ |
| linkedResourceGroupForBody.setText(text); |
| } |
| } |
| fClassNameStatus = classNameChanged(); |
| } |
| |
| if(field == fBaseClassDialogField){ |
| if(fBaseClassDialogField.getText().length() >= 0) |
| { |
| fAccessButtons.setEnabled(true); |
| fBaseClassStatus = baseClassNameChanged(); |
| } |
| else{ |
| fAccessButtons.setEnabled(false); |
| } |
| } |
| doStatusUpdate(); |
| } |
| |
| // --------------- Helper methods for creating controls ----- |
| public boolean selectionIsCpp(){ |
| return hasCppNature; |
| } |
| |
| private boolean isSelectionCPP(IStructuredSelection sel){ |
| IProject project = null; |
| ICElement element = getSelectionCElement(sel); |
| if (element == null){ |
| IResource resource = getSelectionResourceElement(sel); |
| project = resource.getProject(); |
| }else { |
| project = element.getCProject().getProject(); |
| } |
| if (project != null) |
| return CoreModel.getDefault().hasCCNature(project); |
| else |
| return false; |
| } |
| |
| private ICElement getSelectionCElement(IStructuredSelection sel) { |
| if (!sel.isEmpty() && sel instanceof IStructuredSelection) { |
| List list= ((IStructuredSelection)sel).toList(); |
| if (list.size() == 1) { |
| Object element= list.get(0); |
| if (element instanceof ICElement) { |
| return (ICElement)element; |
| } |
| } |
| } |
| return null; |
| } |
| |
| private IResource getSelectionResourceElement(IStructuredSelection sel) { |
| if (!sel.isEmpty() && sel instanceof IStructuredSelection) { |
| List list= ((IStructuredSelection)sel).toList(); |
| if (list.size() == 1) { |
| Object element= list.get(0); |
| if (element instanceof IResource) { |
| if(element instanceof IFile){ |
| IFile file = (IFile)element; |
| return (IResource) file.getParent(); |
| }else { |
| return (IResource)element; |
| } |
| } |
| } |
| } |
| return null; |
| } |
| |
| private void getChildrenOfTypeClass(IParent parent, List elementsFound, IProgressMonitor monitor, int worked){ |
| ICElement[] elements = parent.getChildren(); |
| monitor.worked( worked ); |
| |
| for (int i = 0; i< elements.length; i++){ |
| ICElement element = (ICElement)elements[i]; |
| if(element.getElementType() == ICElement.C_CLASS){ |
| elementsFound.add(element); |
| } |
| if(element instanceof IParent){ |
| getChildrenOfTypeClass((IParent)element, elementsFound, monitor, worked+1); |
| } |
| } |
| } |
| |
| private void searchForClasses(ICProject cProject, List elementsFound, IProgressMonitor monitor, int worked){ |
| ICSearchPattern pattern = SearchEngine.createSearchPattern( "*", ICSearchConstants.CLASS, ICSearchConstants.DECLARATIONS, false ); |
| ICElement[] elements = new ICElement[1]; |
| elements[0] = cProject; |
| ICSearchScope scope = SearchEngine.createCSearchScope(elements, true); |
| |
| searchEngine.search(CUIPlugin.getWorkspace(), pattern, scope, resultCollector, false); |
| elementsFound.addAll(resultCollector.getSearchResults()); |
| } |
| |
| private List getClassElementsInProject(){ |
| return elementsOfTypeClassInProject; |
| } |
| |
| private List findClassElementsInProject(){ |
| if(eSelection == null){ |
| return new LinkedList(); |
| } |
| |
| if( elementsOfTypeClassInProject != null ){ |
| return elementsOfTypeClassInProject; |
| } |
| |
| elementsOfTypeClassInProject = new LinkedList(); |
| IRunnableWithProgress runnable= new IRunnableWithProgress() { |
| public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException { |
| if (monitor == null) { |
| monitor= new NullProgressMonitor(); |
| } |
| monitor.beginTask(NewWizardMessages.getString("NewClassWizardPage.operations.getProjectClasses"), 5); //$NON-NLS-1$ |
| try{ |
| ICProject cProject = eSelection.getCProject(); |
| searchForClasses(cProject, elementsOfTypeClassInProject, monitor, 1); |
| //getChildrenOfTypeClass((IParent)cProject, elementsOfTypeClassInProject, monitor, 1); |
| monitor.worked(5); |
| } finally{ |
| monitor.done(); |
| } |
| } |
| }; |
| |
| try { |
| getWizard().getContainer().run(false, true, runnable); |
| } catch (InvocationTargetException e) { |
| } catch (InterruptedException e) { |
| } |
| finally { |
| } |
| return elementsOfTypeClassInProject; |
| } |
| |
| protected Object chooseBaseClass(){ |
| // find the available classes in this project |
| List elementsFound = findClassElementsInProject(); |
| |
| ElementListSelectionDialog dialog = new ElementListSelectionDialog(getShell(), new CSearchResultLabelProvider()); |
| dialog.setTitle(NewWizardMessages.getString("BaseClassSelectionDialog.title")); //$NON-NLS-1$ |
| dialog.setMessage(NewWizardMessages.getString("BaseClassSelectionDialog.message")); //$NON-NLS-1$ |
| dialog.setElements(elementsFound.toArray()); |
| dialog.setFilter("*"); |
| |
| if (dialog.open() == ElementListSelectionDialog.OK) { |
| Object element= dialog.getFirstResult(); |
| return element; |
| } |
| return null; |
| } |
| |
| // ------------- getter methods for dialog controls ------------- |
| public String getNewClassName(){ |
| return fClassNameDialogField.getText(); |
| } |
| |
| public String getBaseClassName(){ |
| return fBaseClassDialogField.getText(); |
| } |
| |
| public boolean isIncludeGuard(){ |
| return fConstDestButtons.isSelected(2); |
| } |
| |
| public boolean isVirtualDestructor(){ |
| return fConstDestButtons.isSelected(1); |
| } |
| |
| public boolean isInline(){ |
| return fConstDestButtons.isSelected(0); |
| } |
| |
| public String getAccess(){ |
| if(fAccessButtons.isSelected(0)) |
| return "public"; |
| else if(fAccessButtons.isSelected(1)) |
| return "protected"; |
| else if(fAccessButtons.isSelected(2)) |
| return "private"; |
| else return ""; |
| } |
| |
| public ITranslationUnit getCreatedClassHeaderFile(){ |
| return parentHeaderTU; |
| } |
| |
| public ITranslationUnit getCreatedClassBodyFile(){ |
| return parentBodyTU; |
| } |
| |
| public /*IStructure*/ ICElement getCreatedClassElement(){ |
| return createdClass; |
| } |
| |
| public IStructure getBaseClassElement(){ |
| |
| return null; |
| } |
| // -------------- Create a new Class ---------------------- |
| |
| public boolean createClass(IProgressMonitor monitor){ |
| if (monitor == null) { |
| monitor= new NullProgressMonitor(); |
| } |
| monitor.beginTask(NewWizardMessages.getString("NewTypeWizardPage.operationdesc"), 10); //$NON-NLS-1$ |
| try{ |
| |
| String lineDelimiter= null; |
| lineDelimiter= System.getProperty("line.separator", "\n"); |
| |
| parentHeaderTU = createTranslationUnit(linkedResourceGroupForHeader); |
| parentBodyTU = createTranslationUnit(linkedResourceGroupForBody); |
| monitor.worked(1); |
| |
| if(parentHeaderTU != null){ |
| String header = constructHeaderFileContent(lineDelimiter); |
| IWorkingCopy headerWC = parentHeaderTU.getSharedWorkingCopy(null, CUIPlugin.getDefault().getDocumentProvider().getBufferFactory()); |
| headerWC.getBuffer().append(header); |
| synchronized(headerWC) { |
| headerWC.reconcile(); |
| headerWC.commit(true, monitor); |
| } |
| //createdClass= (IStructure)headerWC.getElement(getNewClassName()); |
| createdClass= headerWC.getElement(getNewClassName()); |
| } |
| if(parentBodyTU != null){ |
| String body = constructBodyFileContent(lineDelimiter); |
| IWorkingCopy bodyWC = parentBodyTU.getSharedWorkingCopy(null, CUIPlugin.getDefault().getDocumentProvider().getBufferFactory()); |
| bodyWC.getBuffer().append(body); |
| synchronized(bodyWC){ |
| bodyWC.reconcile(); |
| bodyWC.commit(true, monitor); |
| } |
| } |
| |
| return true; |
| }catch(CModelException e){ |
| MessageDialog.openError(getContainer().getShell(), WorkbenchMessages.getString("WizardNewFileCreationPage.internalErrorTitle"), WorkbenchMessages.format("WizardNewFileCreationPage.internalErrorMessage", new Object[] {e.getMessage()})); //$NON-NLS-2$ //$NON-NLS-1$ |
| return false; |
| }finally{ |
| monitor.done(); |
| } |
| |
| } |
| |
| protected ITranslationUnit createTranslationUnit(LinkToFileGroup linkedGroup){ |
| ITranslationUnit createdUnit = null; |
| IFile createdFile = null; |
| createdFile= createNewFile(linkedGroup); |
| // turn the file into a translation unit |
| if(createdFile != null){ |
| Object element= CoreModel.getDefault().create(createdFile); |
| if (element instanceof ITranslationUnit) |
| createdUnit = (ITranslationUnit) element; |
| } |
| |
| return createdUnit; |
| } |
| |
| protected IFile createNewFile(LinkToFileGroup linkedGroup) { |
| final IPath newFilePath = getContainerFullPath(linkedGroup); |
| final IFile newFileHandle = createFileHandle(newFilePath); |
| |
| if(newFileHandle.exists()){ |
| return newFileHandle; |
| } |
| |
| // create the new file and cache it if successful |
| final boolean linkedFile = linkedGroup.linkCreated(); |
| final IPath containerPath = getContainerPath(linkedGroup); |
| final InputStream initialContents = getInitialContents(); |
| |
| WorkspaceModifyOperation op = new WorkspaceModifyOperation() { |
| protected void execute(IProgressMonitor monitor) throws CoreException, |
| InterruptedException |
| { |
| try { |
| monitor.beginTask(WorkbenchMessages.getString("WizardNewFileCreationPage.progress"), 2000); //$NON-NLS-1$ |
| if(!(containerExists(containerPath))){ |
| ContainerGenerator generator = new ContainerGenerator(containerPath); |
| generator.generateContainer(new SubProgressMonitor(monitor, 1000)); |
| } |
| createFile(newFileHandle,initialContents, newFilePath, linkedFile, new SubProgressMonitor(monitor, 1000)); |
| } finally { |
| monitor.done(); |
| } |
| } |
| }; |
| |
| try { |
| getContainer().run(false, true, op); |
| } catch (InterruptedException e) { |
| return null; |
| } catch (InvocationTargetException e) { |
| if (e.getTargetException() instanceof CoreException) { |
| ErrorDialog.openError( |
| getContainer().getShell(), // Was Utilities.getFocusShell() |
| WorkbenchMessages.getString("WizardNewFileCreationPage.errorTitle"), //$NON-NLS-1$ |
| null, // no special message |
| ((CoreException) e.getTargetException()).getStatus()); |
| } |
| else { |
| // CoreExceptions are handled above, but unexpected runtime exceptions and errors may still occur. |
| WorkbenchPlugin.log(MessageFormat.format("Exception in {0}.getNewFile(): {1}", new Object[] {getClass().getName(), e.getTargetException()}));//$NON-NLS-1$ |
| MessageDialog.openError(getContainer().getShell(), WorkbenchMessages.getString("WizardNewFileCreationPage.internalErrorTitle"), WorkbenchMessages.format("WizardNewFileCreationPage.internalErrorMessage", new Object[] {e.getTargetException().getMessage()})); //$NON-NLS-2$ //$NON-NLS-1$ |
| } |
| return null; |
| } |
| |
| return newFileHandle; |
| } |
| protected IFile createFileHandle(IPath filePath) { |
| IFile newFile = null; |
| IWorkspaceRoot root= CUIPlugin.getWorkspace().getRoot(); |
| newFile = root.getFileForLocation(filePath); |
| if(newFile == null) |
| newFile = root.getFile(filePath); |
| |
| return newFile; |
| } |
| |
| protected void createFile(IFile fileHandle, InputStream contents, IPath targetPath, boolean linkedFile, IProgressMonitor monitor) throws CoreException { |
| if (contents == null) |
| contents = new ByteArrayInputStream(new byte[0]); |
| |
| try { |
| fileHandle.create(contents, false, monitor); |
| } |
| catch (CoreException e) { |
| // If the file already existed locally, just refresh to get contents |
| int code = e.getStatus().getCode(); |
| if (e.getStatus().getCode() == IResourceStatus.PATH_OCCUPIED) |
| fileHandle.refreshLocal(IResource.DEPTH_ZERO, null); |
| else |
| throw e; |
| } |
| |
| if (monitor.isCanceled()) |
| throw new OperationCanceledException(); |
| } |
| |
| // -------------Helper methods for creating the class ------- |
| protected IPath getSelectionPath(){ |
| if(eSelection == null){ |
| IResource resourceSelection = getSelectionResourceElement(currentSelection); |
| if(resourceSelection != null){ |
| return resourceSelection.getLocation().makeAbsolute(); |
| } |
| else |
| return null; |
| } |
| // if it is a file, return the parent path |
| if(eSelection instanceof ITranslationUnit) |
| return (eSelection.getParent().getPath()); |
| // if it is a root, project, or folder, return its path |
| if(eSelection instanceof IOpenable){ |
| return (eSelection.getPath()); |
| }else { |
| // if it is an element in a file, return its openable parent's path |
| ICElement current = eSelection.getParent(); |
| while (current != null){ |
| if ((current instanceof IOpenable) && !(current instanceof ITranslationUnit)){ |
| return current.getPath(); |
| } |
| current = current.getParent(); |
| } |
| return null; |
| } |
| } |
| |
| /* |
| * returns the path without the file name |
| */ |
| protected IPath getContainerPath(LinkToFileGroup linkedGroup) { |
| if(linkedGroup.linkCreated()){ |
| String pathName = linkedGroup.getResolvedPath(); |
| if((pathName == null) || (pathName.length() <1)) |
| return null; |
| IPath containerPath = new Path (pathName); |
| return containerPath.removeLastSegments(1).removeTrailingSeparator().makeAbsolute(); |
| }else { |
| return (getSelectionPath()); |
| } |
| } |
| |
| /* |
| * returns the path including the file name |
| */ |
| protected IPath getContainerFullPath(LinkToFileGroup linkedGroup) { |
| if(linkedGroup.linkCreated()){ |
| String pathName = linkedGroup.getResolvedPath(); |
| if (pathName == null || pathName.length() < 1) |
| return null; |
| else |
| //The user may not have made this absolute so do it for them |
| return (new Path(pathName)).makeAbsolute(); |
| } else { |
| String pathName = linkedGroup.getText(); |
| IPath containerPath = getSelectionPath(); |
| containerPath.addTrailingSeparator(); |
| return ((containerPath.append(pathName)).makeAbsolute()); |
| } |
| } |
| |
| protected boolean containerExists(IPath containerPath) { |
| IContainer container = null; |
| IWorkspaceRoot root= CUIPlugin.getWorkspace().getRoot(); |
| container = root.getContainerForLocation(containerPath); |
| if(container == null) |
| return false; |
| |
| return true; |
| } |
| |
| protected InputStream getInitialContents() { |
| return null; |
| } |
| |
| protected String getClassComment(ITranslationUnit parentTU) { |
| if (PreferenceConstants.getPreferenceStore().getBoolean(PreferenceConstants.CODEGEN_ADD_COMMENTS)) { |
| try { |
| StringBuffer className= new StringBuffer(); |
| className.append(getNewClassName()); |
| String comment= CodeGeneration.getClassComment(parentTU, className.toString(), String.valueOf('\n')); |
| if (comment != null && isValidComment(comment)) { |
| return comment; |
| } |
| } catch (CoreException e) { |
| CUIPlugin.getDefault().log(e); |
| } |
| } |
| return null; |
| } |
| |
| // ------------ Constructing File Contents ----------------- |
| protected String constructHeaderFileContent(String lineDelimiter){ |
| StringBuffer text = new StringBuffer(); |
| boolean extendingBase = false; |
| String baseClassName = getBaseClassName(); |
| String baseClassFileName = ""; |
| if((baseClassName != null) && (baseClassName.length() > 0)) |
| { |
| extendingBase = true; |
| List classElements = findClassElementsInProject(); |
| BasicSearchMatch baseClass = (BasicSearchMatch)findInList(baseClassName, null, classElements); |
| |
| // if(baseClass != null){ |
| // IPath baseClassFileLocation = baseClass.getLocation(); |
| // IPath newFilePath = getContainerFullPath(linkedResourceGroupForHeader); |
| // baseClassFileName = baseClassName + HEADER_EXT; |
| // } else { |
| baseClassFileName = baseClassName + HEADER_EXT; |
| // } |
| } |
| |
| if(isIncludeGuard()){ |
| text.append("#ifndef "); |
| text.append(getNewClassName().toUpperCase()); |
| text.append("_H"); |
| text.append(lineDelimiter); |
| text.append("#define "); |
| text.append(getNewClassName().toUpperCase()); |
| text.append("_H"); |
| text.append(lineDelimiter); |
| text.append(lineDelimiter); |
| } |
| |
| if(extendingBase){ |
| text.append("#include \""); |
| text.append(baseClassFileName); |
| text.append('\"'); |
| text.append(lineDelimiter); |
| text.append(lineDelimiter); |
| } |
| text.append("class "); |
| text.append(getNewClassName()); |
| if(extendingBase){ |
| text.append(" : "); |
| text.append(getAccess()); |
| text.append(" "); |
| text.append(baseClassName); |
| } |
| text.append("{"); |
| text.append(lineDelimiter); |
| |
| text.append("public:"); |
| text.append(lineDelimiter); |
| text.append(lineDelimiter); |
| |
| // constructor |
| text.append('\t'); |
| text.append(getNewClassName()); |
| text.append("()"); |
| if(isInline()){ |
| text.append(" {}"); |
| text.append(lineDelimiter); |
| }else { |
| text.append(";"); |
| text.append(lineDelimiter); |
| } |
| |
| // destructor |
| text.append('\t'); |
| if(isVirtualDestructor()){ |
| text.append("virtual "); |
| } |
| text.append("~"); |
| text.append(getNewClassName()); |
| text.append("()"); |
| if(isInline()){ |
| text.append(" {}"); |
| text.append(lineDelimiter); |
| }else { |
| text.append(";"); |
| text.append(lineDelimiter); |
| } |
| text.append("};"); |
| text.append(lineDelimiter); |
| |
| if(isIncludeGuard()){ |
| text.append(lineDelimiter); |
| text.append("#endif // "); |
| text.append(getNewClassName().toUpperCase()); |
| text.append("_H"); |
| text.append(lineDelimiter); |
| } |
| |
| return text.toString(); |
| } |
| |
| protected String constructBodyFileContent(String lineDelimiter){ |
| StringBuffer text = new StringBuffer(); |
| text.append("#include \""); |
| text.append(getCreatedClassHeaderFile().getElementName()); |
| text.append("\""); |
| text.append(lineDelimiter); |
| text.append(lineDelimiter); |
| |
| if(isInline()) |
| return text.toString(); |
| |
| // constructor |
| text.append(getNewClassName()); |
| text.append("::"); |
| text.append(getNewClassName()); |
| text.append("()"); |
| text.append(lineDelimiter); |
| text.append("{}"); |
| text.append(lineDelimiter); |
| |
| // destructor |
| text.append(getNewClassName()); |
| text.append("::~"); |
| text.append(getNewClassName()); |
| text.append("()"); |
| text.append(lineDelimiter); |
| text.append("{}"); |
| text.append(lineDelimiter); |
| return text.toString(); |
| } |
| |
| |
| // ------ validation -------- |
| protected void doStatusUpdate() { |
| // status of all used components |
| IStatus[] status= new IStatus[] { |
| fClassNameStatus, |
| fBaseClassStatus, |
| }; |
| |
| // the mode severe status will be displayed and the ok button enabled/disabled. |
| updateStatus(status); |
| } |
| |
| protected void updateStatus(IStatus[] status) { |
| updateStatus(StatusUtil.getMostSevere(status)); |
| } |
| |
| protected void updateStatus(IStatus status) { |
| fCurrStatus= status; |
| setPageComplete(!status.matches(IStatus.ERROR)); |
| StatusUtil.applyToStatusLine(this, status); |
| } |
| |
| protected boolean isValidComment(String template) { |
| return true; |
| } |
| |
| // status validation |
| /** |
| * Hook method that gets called when the class name has changed. The method validates the |
| * class name and returns the status of the validation. |
| * <p> |
| * Subclasses may extend this method to perform their own validation. |
| * </p> |
| * |
| * @return the status of the validation |
| */ |
| protected IStatus classNameChanged() { |
| StatusInfo status= new StatusInfo(); |
| String className= getNewClassName(); |
| // must not be empty |
| if (className.length() == 0) { |
| status.setError(NewWizardMessages.getString("NewClassWizardPage.error.EnterClassName")); //$NON-NLS-1$ |
| return status; |
| } |
| if (className.indexOf("::") != -1) { |
| status.setError(NewWizardMessages.getString("NewClassWizardPage.error.QualifiedName")); //$NON-NLS-1$ |
| return status; |
| } |
| IStatus val= CConventions.validateClassName(className); |
| if (val.getSeverity() == IStatus.ERROR) { |
| status.setError(NewWizardMessages.getFormattedString("NewClassWizardPage.error.InvalidClassName", val.getMessage())); //$NON-NLS-1$ |
| return status; |
| } else if (val.getSeverity() == IStatus.WARNING) { |
| status.setWarning(NewWizardMessages.getFormattedString("NewClassWizardPage.warning.ClassNameDiscouraged", val.getMessage())); //$NON-NLS-1$ |
| // continue checking |
| } |
| |
| // must not exist |
| List elementsFound = findClassElementsInProject(); |
| if(foundInList(getNewClassName(), getContainerPath(linkedResourceGroupForHeader), elementsFound)){ |
| status.setWarning(NewWizardMessages.getString("NewClassWizardPage.error.ClassNameExists")); //$NON-NLS-1$ |
| } |
| return status; |
| } |
| /** |
| * Hook method that gets called when the superclass name has changed. The method |
| * validates the superclass name and returns the status of the validation. |
| * <p> |
| * Subclasses may extend this method to perform their own validation. |
| * </p> |
| * |
| * @return the status of the validation |
| */ |
| protected IStatus baseClassNameChanged() { |
| String baseClassName = getBaseClassName(); |
| StatusInfo status= new StatusInfo(); |
| if (baseClassName.length() == 0) { |
| // accept the empty field (stands for java.lang.Object) |
| return status; |
| } |
| |
| // class name must follow the C/CPP convensions |
| IStatus val= CConventions.validateClassName(baseClassName); |
| if (val.getSeverity() == IStatus.ERROR) { |
| status.setError(NewWizardMessages.getString("NewClassWizardPage.error.InvalidBaseClassName")); //$NON-NLS-1$ |
| return status; |
| } |
| |
| // if class does not exist, give warning |
| List elementsFound = findClassElementsInProject(); |
| if(!foundInList(baseClassName, null, elementsFound)){ |
| status.setWarning(NewWizardMessages.getString("NewClassWizardPage.warning.BaseClassNotExists")); //$NON-NLS-1$ |
| } |
| return status; |
| } |
| |
| private Object findInList(String name, IPath path, List elements){ |
| Iterator i = elements.iterator(); |
| while (i.hasNext()){ |
| BasicSearchMatch element = (BasicSearchMatch)i.next(); |
| if(path != null){ |
| // check both the name and the path |
| if ((name.equals(element.getName())) && (path.makeAbsolute().equals(element.getLocation()))) |
| return element; |
| } else { |
| // we don't care about the path |
| if (name.equals(element.getName())) |
| return element; |
| } |
| } |
| return null; |
| } |
| |
| private boolean foundInList(String name, IPath path, List elements){ |
| if(findInList(name, path, elements) != null) |
| return true; |
| else |
| return false; |
| } |
| |
| } |
