Through Eclipse Mars, the Java Reverse Engineering was available in the Papyrus extra plugins. Since Eclipse Neon, they are now in a separate Papyrus component, called Papyrus software designer.
The Java reverse tools allow Java files or packages to be reverse-engineered into a Papyrus class diagram.

== Installation instructions==
The Java features of Papyrus are available as part of the [http://wiki.eclipse.org/Papyrus_Software_Designer Papyrus Software Designer] extra feature.

You can install it by using the Papyrus Software Designer update-site:
* http://download.eclipse.org/modeling/mdt/papyrus/components/designer/
Or you can use the nightly build update site by choosing a job below and select the update site in its description:
* https://ci.eclipse.org/papyrus/view/Designer/

Then select "Papyrus Java profile, library and code generation (Incubation)" feature. You need JDT installed (which comes with most Eclipse packages).

[[Image:../java/InstallSWDesignerJavaFeature.png]]

== How to use Reverse ==
=== Using Command ===
==== Reverse-engineer a Java class ====
A Java class can be reverse-engineered into a Papyrus class diagram:
*open the class diagram,
*select a Java package from a project
* click the Reverse button [[File:ReverseButton.jpg]]

A UML class is created in Model Explorer. You can now add it into your diagram.
Note that all associated classes have also been added to the model. 

==== Reverse-engineer a package ====
A Java package (and all classes included) can be reverse-engineered into a Papyrus class diagram:
*open the class diagram,
*select a Java package from a project,
*click the Reverse button [[File:ReverseButton.jpg]]

Packages and classes have been created in Model Explorer. Your can now add them to your diagram.
Note that all associated classes have also been added to the model. 

==== Reverse-engineering settings ====
By default, a package named "generated" is created for reverse-engineering. You can choose another package name on the options menu.

[[Image:JavaReverseOptionsMenu.jpg]]   

This option menu allows one to:
* change the default package of the reverse-engineering,
* add or remove search path. The reverse generator search existing UML classes and regenerate them.
* add or remove creation path. The reverse generator search on existing Java classes to generate a UML class. Useful for creating Java imports (e.g.: String, Integer).

=== Using Drag & Drop ===
You can reverse-engineer a class or a package by just dragging & dropping it on a Papyrus diagram:
* Drag one or more classes and/or packages,
* Drop the selection into an open diagram.  

[[Image:JavaReverseDragAndDrop.png]]

A settings dialog is opened. You can modify settings (please see Reverse settings).
When you're reverse-engineering via the drag & drop method, you can also choose to display model, packages, and classes / interfaces / enumerations in the Papyrus diagram. To enable display, just click the check-boxes:  

[[Image:JavaReverseDnDPopUp.png]]

When you click on the ''OK'' button, your components are displayed in the Papyrus diagram. Note: while all selected components are reversed-engineered, only components which are selected, but not in the Papyrus diagram are displayed.  

[[Image:JavaReverseDnDResult.png]]

== Change default reverse-engineering settings ==
The Java code reverse-engineering plugin allows you to change default settings on eclipse preferences:
*Open ''Eclipse Preferences'',
*Search for the ''Papyrus'' section,
*Choose ''Java Code Reverse'' sub-section

In this preferences page, you can change:
*default search path values,
*default creation path values.
Note that there are default values; if you have changed these values for a project, your changes are saved, and default values are not used.

[[Image:JavaCodeReversePreferences.png]]

== Developer resources ==

* Git repo: http://git.eclipse.org/c/papyrus/org.eclipse.papyrus-designer.git
* Java plugins path: languages/java/
* Java reverse plugins:
** org.eclipse.papyrus.designer.languages.java.reverse.ui
*** Starting points when called from toolbar UI:
*** org.eclipse.papyrus.designer.languages.java.reverse.ui.handlers.JavaCodeReverseInJobHandler.doPrepareExecute(ExecutionEvent)
*** org.eclipse.papyrus.designer.languages.java.reverse.ui.handlers.JavaCodeReverseInJobHandler.doExecuteTransactionInJob(IProgressMonitor)
** org.eclipse.papyrus.designer.languages.java.reverse
*** Project explorer walker visits the project explorer resources recursively, until we reach a compilation unit called a "node" in this context.
**** org.eclipse.papyrus.designer.languages.java.reverse.ui.ProjectExplorerNodeWalkerWithIProgress.doSwitch(Object, SubMonitor)
**** org.eclipse.papyrus.designer.languages.java.reverse.ui.ProjectExplorerNodeWalkerWithIProgress.visitICompilationUnit(ICompilationUnit, SubMonitor)
*** Then we use a node visitor to visit its JDT elements.
***** org.eclipse.papyrus.designer.languages.java.reverse.ui.ReverseSelectedNodeVisitor.visitICompilationUnit(ICompilationUnit)
*** Which uses its compilation unit analyzer to analyze and create UML elements
**** org.eclipse.papyrus.designer.languages.java.reverse.umlparser.CompilationUnitAnalyser.processCompilationUnit(CompilationUnit)
*** The compilation unit analyzer uses other classes which are all in the following package:
**** org.eclipse.papyrus.designer.languages.java.reverse.umlparser
** Java Parser and JDT Parser
*** To reverse Java code, it is parsed by Java Parser and an AST is built.
*** Java Parser is embedded in: org.eclipse.papyrus.designer.languages.java.reverse.javaparser
*** We are also experimenting with JDT Parser (currently deactivated for the user)
*** JDT Parser files are in: org.eclipse.papyrus.designer.languages.java.reverse.jdt

[[Category:Modeling]]
[[Category:Papyrus]]
[[Category:Papyrus-Software-Designer]]
