@TestOnly
public void clearCodeStyleSettings() {
CodeStyleSettings cleanSettings = new CodeStyleSettings();
copyFrom(cleanSettings);
myAdditionalIndentOptions.clear(); // hack
myLoadedAdditionalIndentOptions = false;
}
private static void cleanupSwingDataStructures() throws Exception {
Class<?> aClass = Class.forName("javax.swing.KeyboardManager");
Method get = aClass.getMethod("getCurrentManager");
get.setAccessible(true);
Object manager = get.invoke(null);
{
Field mapF = aClass.getDeclaredField("componentKeyStrokeMap");
mapF.setAccessible(true);
Object map = mapF.get(manager);
((Map) map).clear();
}
{
Field mapF = aClass.getDeclaredField("containerMap");
mapF.setAccessible(true);
Object map = mapF.get(manager);
((Map) map).clear();
}
}
private void copyRootsFrom(LibraryImpl fromModel) {
myRoots.clear();
for (Map.Entry<OrderRootType, VirtualFilePointerContainer> entry :
fromModel.myRoots.entrySet()) {
OrderRootType rootType = entry.getKey();
VirtualFilePointerContainer container = entry.getValue();
VirtualFilePointerContainer clone = container.clone(myPointersDisposable);
myRoots.put(rootType, clone);
}
}
@Override
public void dispose() {
setRefreshVisible(false);
InlineProgressIndicator[] indicators =
getCurrentInlineIndicators().toArray(new InlineProgressIndicator[0]);
for (InlineProgressIndicator indicator : indicators) {
Disposer.dispose(indicator);
}
myInline2Original.clear();
myOriginal2Inlines.clear();
}
public void reloadProjectImpl(@NotNull final Project p, final boolean clearCopyToRestore) {
if (clearCopyToRestore) {
mySavedCopies.clear();
mySavedTimestamps.clear();
}
final Project[] project = {p};
ProjectReloadState.getInstance(project[0]).onBeforeAutomaticProjectReload();
final Application application = ApplicationManager.getApplication();
application.invokeLater(
new Runnable() {
@Override
public void run() {
LOG.debug("Reloading project.");
ProjectImpl projectImpl = (ProjectImpl) project[0];
if (projectImpl.isDisposed()) return;
IProjectStore projectStore = projectImpl.getStateStore();
final String location = projectImpl.getPresentableUrl();
final List<IFile> original;
try {
final IComponentStore.SaveSession saveSession = projectStore.startSave();
original = saveSession.getAllStorageFiles(true);
saveSession.finishSave();
} catch (IOException e) {
LOG.error(e);
return;
}
if (project[0].isDisposed() || ProjectUtil.closeAndDispose(project[0])) {
application.runWriteAction(
new Runnable() {
@Override
public void run() {
for (final IFile originalFile : original) {
restoreCopy(
LocalFileSystem.getInstance().refreshAndFindFileByIoFile(originalFile));
}
}
});
project[0] = null; // Let it go.
ProjectUtil.openProject(location, null, true);
}
}
},
ModalityState.NON_MODAL);
}
public void compile() throws CompilerException, CacheCorruptedException {
Application application = ApplicationManager.getApplication();
try {
if (!myFilesToCompile.isEmpty()) {
if (application.isUnitTestMode()) {
saveTestData();
}
compileModules(buildModuleToFilesMap(myFilesToCompile));
}
} catch (SecurityException e) {
throw new CompilerException(
CompilerBundle.message("error.compiler.process.not.started", e.getMessage()), e);
} catch (IllegalArgumentException e) {
throw new CompilerException(e.getMessage(), e);
} finally {
for (final VirtualFile file : myModuleToTempDirMap.values()) {
if (file != null) {
final File ioFile = new File(file.getPath());
FileUtil.asyncDelete(ioFile);
}
}
myModuleToTempDirMap.clear();
}
if (!myFilesToCompile.isEmpty()
&& myCompileContext.getMessageCount(CompilerMessageCategory.ERROR) == 0) {
// package-info.java hack
final List<TranslatingCompiler.OutputItem> outputs =
new ArrayList<TranslatingCompiler.OutputItem>();
ApplicationManager.getApplication()
.runReadAction(
new Runnable() {
public void run() {
for (final VirtualFile file : myFilesToCompile) {
if (PACKAGE_ANNOTATION_FILE_NAME.equals(file.getName())
&& !myProcessedPackageInfos.contains(file)) {
outputs.add(new OutputItemImpl(file));
}
}
}
});
if (!outputs.isEmpty()) {
mySink.add(null, outputs, VirtualFile.EMPTY_ARRAY);
}
}
}
@Override
@Nullable
public Project newProject(
final String projectName,
@NotNull String filePath,
boolean useDefaultProjectSettings,
boolean isDummy) {
filePath = toCanonicalName(filePath);
//noinspection ConstantConditions
if (LOG_PROJECT_LEAKAGE_IN_TESTS && ApplicationManager.getApplication().isUnitTestMode()) {
for (int i = 0; i < 42; i++) {
if (myProjects.size() < MAX_LEAKY_PROJECTS) break;
System.gc();
TimeoutUtil.sleep(100);
System.gc();
}
if (myProjects.size() >= MAX_LEAKY_PROJECTS) {
List<Project> copy = new ArrayList<Project>(myProjects.keySet());
myProjects.clear();
throw new TooManyProjectLeakedException(copy);
}
}
ProjectImpl project =
createProject(
projectName, filePath, false, ApplicationManager.getApplication().isUnitTestMode());
try {
initProject(project, useDefaultProjectSettings ? (ProjectImpl) getDefaultProject() : null);
if (LOG_PROJECT_LEAKAGE_IN_TESTS) {
myProjects.put(project, null);
}
return project;
} catch (final Exception e) {
LOG.info(e);
Messages.showErrorDialog(message(e), ProjectBundle.message("project.load.default.error"));
}
return null;
}
private void doRead(@NotNull final Element parentNode) {
ApplicationManager.getApplication()
.runReadAction(
new Runnable() {
@Override
@SuppressWarnings({"HardCodedStringLiteral"})
public void run() {
final Map<String, Breakpoint> nameToBreakpointMap =
new THashMap<String, Breakpoint>();
try {
final List groups = parentNode.getChildren();
for (final Object group1 : groups) {
final Element group = (Element) group1;
if (group.getName().equals(RULES_GROUP_NAME)) {
continue;
}
// skip already converted
if (group.getAttribute(CONVERTED_PARAM) != null) {
continue;
}
final String categoryName = group.getName();
final Key<Breakpoint> breakpointCategory =
BreakpointCategory.lookup(categoryName);
final String defaultPolicy =
group.getAttributeValue(DEFAULT_SUSPEND_POLICY_ATTRIBUTE_NAME);
final boolean conditionEnabled =
Boolean.parseBoolean(
group.getAttributeValue(
DEFAULT_CONDITION_STATE_ATTRIBUTE_NAME, "true"));
setBreakpointDefaults(
breakpointCategory,
new BreakpointDefaults(defaultPolicy, conditionEnabled));
Element anyExceptionBreakpointGroup;
if (!AnyExceptionBreakpoint.ANY_EXCEPTION_BREAKPOINT.equals(
breakpointCategory)) {
// for compatibility with previous format
anyExceptionBreakpointGroup =
group.getChild(
AnyExceptionBreakpoint.ANY_EXCEPTION_BREAKPOINT.toString());
// final BreakpointFactory factory =
// BreakpointFactory.getInstance(breakpointCategory);
// if (factory != null) {
for (Element breakpointNode : group.getChildren("breakpoint")) {
// Breakpoint breakpoint = factory.createBreakpoint(myProject,
// breakpointNode);
Breakpoint breakpoint = createBreakpoint(categoryName, breakpointNode);
breakpoint.readExternal(breakpointNode);
nameToBreakpointMap.put(breakpoint.getDisplayName(), breakpoint);
}
// }
} else {
anyExceptionBreakpointGroup = group;
}
if (anyExceptionBreakpointGroup != null) {
final Element breakpointElement = group.getChild("breakpoint");
if (breakpointElement != null) {
XBreakpointManager manager =
XDebuggerManager.getInstance(myProject).getBreakpointManager();
JavaExceptionBreakpointType type =
(JavaExceptionBreakpointType)
XDebuggerUtil.getInstance()
.findBreakpointType(JavaExceptionBreakpointType.class);
XBreakpoint<JavaExceptionBreakpointProperties> xBreakpoint =
manager.getDefaultBreakpoint(type);
Breakpoint breakpoint = createJavaBreakpoint(xBreakpoint);
breakpoint.readExternal(breakpointElement);
addBreakpoint(breakpoint);
}
}
}
} catch (InvalidDataException ignored) {
}
final Element rulesGroup = parentNode.getChild(RULES_GROUP_NAME);
if (rulesGroup != null) {
final List<Element> rules = rulesGroup.getChildren("rule");
for (Element rule : rules) {
// skip already converted
if (rule.getAttribute(CONVERTED_PARAM) != null) {
continue;
}
final Element master = rule.getChild(MASTER_BREAKPOINT_TAGNAME);
if (master == null) {
continue;
}
final Element slave = rule.getChild(SLAVE_BREAKPOINT_TAGNAME);
if (slave == null) {
continue;
}
final Breakpoint masterBreakpoint =
nameToBreakpointMap.get(master.getAttributeValue("name"));
if (masterBreakpoint == null) {
continue;
}
final Breakpoint slaveBreakpoint =
nameToBreakpointMap.get(slave.getAttributeValue("name"));
if (slaveBreakpoint == null) {
continue;
}
boolean leaveEnabled =
"true".equalsIgnoreCase(rule.getAttributeValue("leaveEnabled"));
XDependentBreakpointManager dependentBreakpointManager =
((XBreakpointManagerImpl) getXBreakpointManager())
.getDependentBreakpointManager();
dependentBreakpointManager.setMasterBreakpoint(
slaveBreakpoint.myXBreakpoint,
masterBreakpoint.myXBreakpoint,
leaveEnabled);
// addBreakpointRule(new EnableBreakpointRule(BreakpointManager.this,
// masterBreakpoint, slaveBreakpoint, leaveEnabled));
}
}
DebuggerInvocationUtil.invokeLater(
myProject,
new Runnable() {
@Override
public void run() {
updateBreakpointsUI();
}
});
}
});
myUIProperties.clear();
final Element props = parentNode.getChild("ui_properties");
if (props != null) {
final List children = props.getChildren("property");
for (Object child : children) {
Element property = (Element) child;
final String name = property.getAttributeValue("name");
final String value = property.getAttributeValue("value");
if (name != null && value != null) {
myUIProperties.put(name, value);
}
}
}
}
public void clear() {
myStorage.clear();
}