1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
|
/*******************************************************************************
* Copyright (c) 2007 Nokia 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:
* Nokia - initial API and implementation
*******************************************************************************/
package org.eclipse.cdt.debug.ui.importexecutable;
import java.io.File;
import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.ICDescriptor;
import org.eclipse.cdt.core.ICDescriptorOperation;
import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.debug.core.ICDTLaunchConfigurationConstants;
import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.ResourcesPlugin;
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.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.IJobManager;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.debug.core.ILaunchConfigurationType;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.wizard.IWizardPage;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.ui.INewWizard;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.progress.UIJob;
public abstract class AbstractImportExecutableWizard extends Wizard implements INewWizard {
// The ImportExecutableWizard lets you select one or more executables and
// import them into the workspace. You can bring the executables into an
// existing project or have the wizard create a new project that
// will contains the executables and allow you to debug them. The wizard can
// also create a default launch configuration for you that's pre configured
// to debug the executables.
public static final String DEBUG_PROJECT_ID = "org.eclipse.cdt.debug"; //$NON-NLS-1$
protected ImportExecutablePageOne pageOne;
protected ImportExecutablePageTwo pageTwo;
private String parserID;
private void waitForJob(String name)
{
IJobManager jobMan = Platform.getJobManager();
Job[] jobs = jobMan.find(null);
for (int i = 0; i < jobs.length; i++) {
if (jobs[i].getName().equals(name)) {
try {
jobs[i].join();
} catch (InterruptedException e) {
}
}
}
}
private void waitForDescSave() {
String taskName = CCorePlugin.getResourceString("CDescriptorManager.async_updater"); //$NON-NLS-1$
waitForJob(taskName);
}
public void addBinaryParsers(IProject newProject) throws CoreException {
ICDescriptorOperation op = new ICDescriptorOperation() {
public void execute(ICDescriptor descriptor, IProgressMonitor monitor) throws CoreException {
descriptor.create(CCorePlugin.BINARY_PARSER_UNIQ_ID, parserID);
}
};
String[] parserIDs = pageOne.getSupportedBinaryParserIds();
for (int i = 0; i < parserIDs.length; i++) {
parserID = parserIDs[i];
CCorePlugin.getDefault().getCDescriptorManager().runDescriptorOperation(newProject.getProject(), op, null);
waitForDescSave();
}
}
/**
* Adds the executables to a new or existing project. The executables are
* added as external links.
*
* @param project -
* project receiving the executables
* @throws CoreException
*/
private void addExecutables(ICProject project) throws CoreException {
String[] executables = pageOne.getSelectedExecutables();
for (int i = 0; i < executables.length; i++) {
IPath location = Path.fromOSString(executables[i]);
String executableName = location.toFile().getName();
IFile exeFile = project.getProject().getFile(executableName);
if (!exeFile.exists())
exeFile.createLink(location, 0, null);
}
}
public void addPages() {
super.addPages();
pageOne = new ImportExecutablePageOne(this);
addPage(pageOne);
pageTwo = new ImportExecutablePageTwo(this);
addPage(pageTwo);
}
public IProject createCProjectForExecutable(String projectName) throws OperationCanceledException, CoreException {
IWorkspace workspace = ResourcesPlugin.getWorkspace();
IProject newProjectHandle = workspace.getRoot().getProject(projectName);
IProjectDescription description = workspace.newProjectDescription(newProjectHandle.getName());
description.setLocation(null);
IProject newProject = CCorePlugin.getDefault().createCProject(description, newProjectHandle, null,
DEBUG_PROJECT_ID);
return newProject;
}
public void createLaunchConfiguration(ICProject targetProject) throws CoreException {
ILaunchConfigurationWorkingCopy wc = this.getSelectedLaunchConfigurationType().newInstance(null,
this.getImportExecutablePage2().getNewConfigurationName());
setConfigurationDefaults(wc, targetProject);
final IStructuredSelection selection = new StructuredSelection(wc.doSave());
final String identifier = new String("org.eclipse.debug.ui.launchGroup.debug");
UIJob openLaunchConfigJob = new UIJob(Messages.AbstractImportExecutableWizard_CreateLaunchConfiguration) {
public IStatus runInUIThread(IProgressMonitor monitor) {
DebugUITools.openLaunchConfigurationDialogOnGroup(CUIPlugin.getActiveWorkbenchShell(), selection, identifier);
return Status.OK_STATUS;
}};
openLaunchConfigJob.schedule();
}
public abstract String getExecutableListLabel();
public ImportExecutablePageOne getImportExecutablePage() {
return pageOne;
}
public ImportExecutablePageTwo getImportExecutablePage2() {
return pageTwo;
}
public IWizardPage getNextPage(IWizardPage page) {
if (page == pageOne) {
pageTwo.checkExecutableSettings();
}
return super.getNextPage(page);
}
public abstract String getPageOneDescription();
public abstract String getPageOneTitle();
public ILaunchConfigurationType getSelectedLaunchConfigurationType() {
return pageTwo.getSelectedLaunchConfigurationType();
}
public String getDefaultWindowTitle() {
return Messages.AbstractImportExecutableWizard_windowTitle;
}
public void init(IWorkbench workbench, IStructuredSelection selection) {
setWindowTitle(getDefaultWindowTitle());
setNeedsProgressMonitor(true);
}
public boolean performFinish() {
ICProject targetProject = null;
try {
if (pageTwo.isCreateNewProjectSelected()) {
IProject newProject = createCProjectForExecutable(pageTwo
.getNewProjectName());
setupProject(newProject);
targetProject = CCorePlugin.getDefault().getCoreModel().create(
newProject);
} else {
targetProject = pageTwo.getExistingCProject();
}
addBinaryParsers(targetProject.getProject());
addExecutables(targetProject);
if (pageTwo.isCreateLaunchConfigurationSelected()) {
createLaunchConfiguration(targetProject);
}
} catch (OperationCanceledException e) {
} catch (CoreException e) {
}
return true;
}
/**
* Subclasses should override this method to modify the launch configuration
* created by the wizard. The default implementation sets up the project
* and program names.
* @param config the launch configuration created by the wizard
* @param targetProject
*/
public void setConfigurationDefaults(ILaunchConfigurationWorkingCopy config, ICProject project) {
config.setMappedResources(new IResource[] {project.getProject()});
config.setAttribute(ICDTLaunchConfigurationConstants.ATTR_PROJECT_NAME, project.getProject().getName());
config.setAttribute(ICDTLaunchConfigurationConstants.ATTR_PROGRAM_NAME, new File(getImportExecutablePage()
.getSelectedExecutables()[0]).getName());
}
public abstract void setupFileDialog(FileDialog dialog);
public void setupProject(IProject newProject) throws CoreException {
}
/**
* The wizard will only display launch configuration types that you support.
* This method will be called for each available type.
*
* @param type -
* the type of launch configuration
* @return - if the wizard supports this launch configuration type
*/
public abstract boolean supportsConfigurationType(
ILaunchConfigurationType type);
/**
* Return true if you want the wizard to ask the user to select
* the binary parser. Otherwise it will only use the default one.
* A subclass can specify the default parser by overriding
* getDefaultBinaryParserID.
* @return - If the binary parser selection combo should be displayed.
*/
public boolean userSelectsBinaryParser() {
return true;
}
/** Get the default binary parser the wizard will use to determine if
* single file selections are valid and to filter the list for multi
* file selection.
* @return
*/
public String[] getDefaultBinaryParserIDs() {
String defaultBinaryParserId = CCorePlugin.getDefault().getPluginPreferences().getDefaultString(CCorePlugin.PREF_BINARY_PARSER);
if (defaultBinaryParserId == null || defaultBinaryParserId.length() == 0) {
defaultBinaryParserId = CCorePlugin.DEFAULT_BINARY_PARSER_UNIQ_ID;
}
return new String[] { defaultBinaryParserId };
}
}
|
