MDS/openide
1
0
Fork 0
mirror of https://gitflic.ru/project/openide/openide.git synced 2026-09-27 10:03:11 +07:00
Code Issues Packages Projects Releases Wiki Activity

old rearranger plugin is removed

Browse Source
This commit is contained in:
Denis.Zhdanov
2012-12-07 15:16:52 +04:00
parent 37d40fcaee
commit 186a170535
323 changed files with 0 additions and 33875 deletions
Download Patch File Download Diff File Expand all files Collapse all files
plugins/rearranger/rearranger.iml
-23
View File
@@ -1,23 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<module type="JAVA_MODULE" version="4">
<component name="NewModuleRootManager" inherit-compiler-output="true">
<exclude-output />
<content url="file://$MODULE_DIR$">
<sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
<sourceFolder url="file://$MODULE_DIR$/test/src" isTestSource="true" />
</content>
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
<orderEntry type="module" module-name="core-api" />
<orderEntry type="module" module-name="java-psi-api" />
<orderEntry type="library" scope="TEST" name="JUnit4" level="project" />
<orderEntry type="module" module-name="lang-api" />
<orderEntry type="module" module-name="openapi" />
<orderEntry type="module" module-name="java-impl" scope="TEST" />
<orderEntry type="module" module-name="testFramework-java" scope="TEST" />
<orderEntry type="module" module-name="idea-ui" />
<orderEntry type="module" module-name="java-indexing-api" />
<orderEntry type="library" scope="TEST" name="Groovy" level="project" />
</component>
</module>
plugins/rearranger/src/META-INF/plugin.xml
-46
View File
@@ -1,46 +0,0 @@
<idea-plugin url="http://confluence.jetbrains.com/display/IDEADEV/Rearranger+plugin">
<id>org.jetbrains.plugins.rearranger</id>
<name>Rearranger</name>
<description>
Rearranges (reorders) class and class member declarations according to a user-specified order and/or method call hierarchy;
generates section-marking comments;
provides several controls for spacing within and between methods and classes; and
permits the user to manually rearrange items.
</description>
<vendor url="http://www.jetbrains.com">JetBrains Inc.</vendor>
<depends>com.intellij.modules.lang</depends>
<extensions defaultExtensionNs="com.intellij">
<applicationService serviceImplementation="com.wrq.rearranger.Rearranger"/>
</extensions>
<actions>
<action id="Rearranger.Rearrange"
class="com.wrq.rearranger.RearrangerAction"
text="Rearranger"
description="Rearrange class and class member declarations according to a user-specified order.">
<!--<keyboard-shortcut first-keystroke="control alt shift R" keymap="$default"/>-->
<!--<add-to-group group-id="EditorPopupMenu" anchor="last"/>-->
<!--<add-to-group group-id="EditMenu" anchor="last"/>-->
</action>
<action id="Rearranger.ProjectTree"
class="com.wrq.rearranger.ProjectTreeActionHandler"
text="Rearranger"
description="Rearrange class and class member declarations according to a user-specified order.">
<!-- <add-to-group group-id="EditMenu" anchor="last"/> -->
<!--<add-to-group group-id="ProjectViewPopupMenu" anchor="last"/>-->
</action>
<action id="Rearranger.RearrangeLive"
class="com.wrq.rearranger.LiveRearrangerAction"
text="Live Rearranger"
description="Permits user to manually rearrange class and class member declarations.">
<!--<keyboard-shortcut first-keystroke="ctrl COMMA" keymap="$default"/>-->
<!--<add-to-group group-id="EditorPopupMenu" anchor="last"/>-->
<!--<add-to-group group-id="EditMenu" anchor="last"/>-->
</action>
</actions>
</idea-plugin>
plugins/rearranger/src/com/wrq/rearranger/LiveRearrangerAction.java
-36
View File
@@ -1,36 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger;
import com.intellij.openapi.editor.actionSystem.EditorAction;
/** Called by IDEA to instantiate the live rearranger action handler. */
public class LiveRearrangerAction
extends EditorAction
{
// --------------------------- CONSTRUCTORS ---------------------------
public LiveRearrangerAction() {
super(new LiveRearrangerActionHandler());
}
}
plugins/rearranger/src/com/wrq/rearranger/LiveRearrangerActionHandler.java
-206
View File
@@ -1,206 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger;
import com.intellij.openapi.actionSystem.DataConstants;
import com.intellij.openapi.actionSystem.DataContext;
import com.intellij.openapi.application.Application;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.editor.CaretModel;
import com.intellij.openapi.editor.Document;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.editor.actionSystem.EditorActionHandler;
import com.intellij.openapi.fileEditor.FileDocumentManager;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.openapi.wm.WindowManager;
import com.intellij.psi.PsiDocumentManager;
import com.intellij.psi.PsiFile;
import com.intellij.psi.PsiManager;
import com.wrq.rearranger.entry.ClassContentsEntry;
import com.wrq.rearranger.popup.ILiveRearranger;
import com.wrq.rearranger.popup.LiveRearrangerDialog;
import com.wrq.rearranger.popup.LiveRearrangerPopup;
import com.wrq.rearranger.rearrangement.Mover;
import com.wrq.rearranger.rearrangement.Parser;
import com.wrq.rearranger.ruleinstance.RuleInstance;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.util.CommentUtil;
import java.awt.*;
import java.util.List;
/** Supports manual rearrangement of a file. */
public final class LiveRearrangerActionHandler
extends EditorActionHandler
{
// ------------------------------------------------------- FIELDS ------------------------------------------------------
private static final Logger LOG = Logger.getInstance("#" + LiveRearrangerActionHandler.class.getName());
private static boolean inProgress = false;
private final static boolean useDialog = true; // set to false for Popup
// -------------------------- OTHER METHODS --------------------------
public final void execute(final Editor editor, final DataContext context) {
if (editor == null) {
return;
}
final Project project = (Project)context.getData(DataConstants.PROJECT);
LOG.debug("project=" + project);
LOG.debug("editor=" + editor);
final Document document = editor.getDocument();
final CaretModel caret = editor.getCaretModel();
int cursorOffset = caret.getOffset();
final PsiFile psiFile = getFile(editor, context);
if (!psiFile.getName().endsWith(".java")) {
LOG.debug("not a .java file -- skipping " + psiFile.getName());
return;
}
if (!RearrangerActionHandler.isFileWritable(psiFile)) {
LOG.debug("not a writable .java file -- skipping " + psiFile.getName());
return;
}
LOG.debug("inProgress=" + inProgress);
if (!useDialog) {
if (inProgress) {
return;
}
setInProgress(true);
}
buildLiveRearrangerData(project, document, psiFile, cursorOffset);
}
private static PsiFile getFile(final Editor editor,
final DataContext context)
{
final Project project = (Project)context.getData(DataConstants.PROJECT);
final Document document = editor.getDocument();
final FileDocumentManager fileDocumentManager = FileDocumentManager.getInstance();
final VirtualFile virtualFile = fileDocumentManager.getFile(document);
final PsiManager psiManager = PsiManager.getInstance(project);
return psiManager.findFile(virtualFile);
}
public static void setInProgress(boolean inProgress) {
LOG.debug("set inProgress=" + inProgress);
LiveRearrangerActionHandler.inProgress = inProgress;
}
/**
* must be called from within an IDEA read-action thread.
*
* @param project
* @param document
* @param psiFile
*/
void buildLiveRearrangerData(final Project project,
final Document document,
final PsiFile psiFile,
final int cursorOffset)
{
/**
* Per instructions from IntelliJ, we have to commit any changes to the document to the Psi
* tree.
*/
final PsiDocumentManager documentManager = PsiDocumentManager.getInstance(project);
documentManager.commitDocument(document);
final RearrangerSettings settings = new RearrangerSettings(); // use default settings with no rules
settings.setAskBeforeRearranging(true);
settings.setRearrangeInnerClasses(true);
if (useDialog) {
final Application application = ApplicationManager.getApplication();
application.runWriteAction(
new Runnable() {
public void run() {
liveRearrangeDocument(project, psiFile, settings, document, cursorOffset);
}
}
);
}
else {
final Runnable task = new Runnable() {
public void run() {
LOG.debug("liveRearrangeDocument task started");
liveRearrangeDocument(project, psiFile, settings, document, cursorOffset);
}
};
Thread t = new Thread(
new Runnable() {
public void run() {
LOG.debug("started thread " + Thread.currentThread().getName());
final Application application = ApplicationManager.getApplication();
application.runReadAction(
new Runnable() {
public void run() {
LOG.debug(
"enter application.runReadAction() on thread " +
Thread.currentThread().getName()
);
task.run();
LOG.debug(
"exit application.runReadAction() on thread " +
Thread.currentThread().getName()
);
}
}
);
}
}, "Live Rearranger parser"
);
t.start();
}
LOG.debug("exit buildLiveRearrangerData on thread " + Thread.currentThread().getName());
}
public final void liveRearrangeDocument(final Project project,
final PsiFile psiFile,
final RearrangerSettings settings,
final Document document,
final int cursorOffset)
{
LOG.debug("enter liveRearrangeDocument on thread " + Thread.currentThread().getName());
new CommentUtil(settings); // create CommentUtil singleton
final Window window = WindowManager.getInstance().suggestParentWindow(project);
ILiveRearranger fsp;
if (useDialog) {
fsp = new LiveRearrangerDialog(settings, psiFile, document, window, cursorOffset);
}
else {
fsp = new LiveRearrangerPopup(settings, psiFile, document, project, window, cursorOffset);
}
final Parser p = new Parser(project, settings, psiFile);
final List<ClassContentsEntry> outerClasses = p.parseOuterLevel();
if (outerClasses.size() > 0) {
final Mover mover = new Mover(outerClasses, settings);
final List<RuleInstance> resultRuleInstances = mover.rearrangeOuterClasses();
fsp.setResultRuleInstances(resultRuleInstances);
fsp.liveRearranger();
}
LOG.debug("exit liveRearrangeDocument on thread " + Thread.currentThread().getName());
}
}
plugins/rearranger/src/com/wrq/rearranger/ModifierConstants.java
-59
View File
@@ -1,59 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger;
/** Additional "modifier" flags, used to identify other boolean attributes of a field, method or class. */
public final class ModifierConstants {
// ------------------------------ FIELDS ------------------------------
/*
* dummy modifier values -- chosen to not conflict with other Java modifiers
*/
public static final int OVERRIDDEN = 0x2000;
public static final int CONSTRUCTOR = 0x4000;
public static final int CANONICAL = 0x200000;
public static final int OTHER_METHOD = 0x10000;
public static final int OVERRIDING = 0x20000;
public static final int IMPLEMENTING = 0x100000;
public static final int INIT_TO_ANON_CLASS = 0x40000;
public static final int INITIALIZER = 0x80000;
public static final int IMPLEMENTED = 0x400000;
public static final int ENUM = 0x800000;
private ModifierConstants() {
}
public static String toString(int constants) {
String result = "";
if ((constants & OVERRIDDEN) > 0) result += "OVERRIDDEN ";
if ((constants & CONSTRUCTOR) > 0) result += "CONSTRUCTOR ";
if ((constants & CANONICAL) > 0) result += "CANONICAL ";
if ((constants & OTHER_METHOD) > 0) result += "OTHER_METHOD ";
if ((constants & OVERRIDING) > 0) result += "OVERRIDING ";
if ((constants & IMPLEMENTED) > 0) result += "IMPLEMENTED ";
if ((constants & IMPLEMENTING) > 0) result += "IMPLEMENTING ";
if ((constants & INIT_TO_ANON_CLASS) > 0) result += "INIT_TO_ANON_CLASS ";
if ((constants & INITIALIZER) > 0) result += "INITIALIZER ";
if ((constants & ENUM) > 0) result += "ENUM ";
return result.trim();
}
}
plugins/rearranger/src/com/wrq/rearranger/ProjectTreeActionHandler.java
-330
View File
@@ -1,330 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger;
import com.intellij.openapi.actionSystem.AnAction;
import com.intellij.openapi.actionSystem.AnActionEvent;
import com.intellij.openapi.actionSystem.DataContext;
import com.intellij.openapi.actionSystem.PlatformDataKeys;
import com.intellij.openapi.application.Application;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.editor.Document;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.vfs.VfsUtilCore;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.openapi.vfs.VirtualFileVisitor;
import com.intellij.openapi.wm.WindowManager;
import com.intellij.psi.PsiDocumentManager;
import com.intellij.psi.PsiFile;
import com.intellij.psi.PsiManager;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.util.Constraints;
import org.jetbrains.annotations.NotNull;
import org.omg.CORBA.IntHolder;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;
/** Handles right-click in project view; applies rearrangement to a directory and its files recursively. */
public final class ProjectTreeActionHandler
extends AnAction
{
// ------------------------------ FIELDS ------------------------------
private static final Logger LOG = Logger.getInstance("#" + ProjectTreeActionHandler.class.getName());
// -------------------------- OTHER METHODS --------------------------
public final void actionPerformed(final AnActionEvent anActionEvent) {
LOG.debug("entered actionPerformed");
// we're being called on the Swing event dispatch thread. Spin off another thread to do the
// rearranging and let Swing's thread go.
Thread t = new Thread(
new Runnable() {
public void run() {
new RearrangeIt(anActionEvent.getDataContext()).run();
}
}, "RearrangerThread"
);
t.start();
}
// -------------------------- INNER CLASSES --------------------------
final class RearrangeIt
implements Runnable
{
final DataContext dc;
final Project project;
final JProgressBar bar = new JProgressBar(SwingConstants.HORIZONTAL);
final JLabel filename = new JLabel();
final class BoolHolder {
boolean value;
}
final class IntHolder {
public int n;
}
public RearrangeIt(final DataContext dc) {
this.dc = dc;
if (dc != null) {
this.project = (Project)dc.getData(PlatformDataKeys.PROJECT.getName());
}
else {
this.project = null;
}
}
public final void run() {
final VirtualFile virtualFile = (VirtualFile)dc.getData(PlatformDataKeys.VIRTUAL_FILE.getName());
if (virtualFile == null) {
LOG.debug("counted 0 files");
return;
}
final List<VirtualFile> files = new ArrayList<VirtualFile>();
final VirtualFileVisitor counter = new VirtualFileVisitor() {
@Override
public boolean visitFile(@NotNull VirtualFile file) {
if (!file.isDirectory()) {
LOG.debug((files.size() + 1) + ": file " + file.getName());
files.add(file);
}
return true;
}
};
ApplicationManager.getApplication().runReadAction(
new Runnable() {
public void run() {
VfsUtilCore.visitChildrenRecursively(virtualFile, counter);
}
}
);
LOG.debug("counted " + files.size() + " files");
final RearrangerActionHandler rah = new RearrangerActionHandler();
final PsiDocumentManager dm = PsiDocumentManager.getInstance(project);
final PsiManager pm = PsiManager.getInstance(project);
final BoolHolder cancelled = new BoolHolder();
final JDialog dialog = getProgressFrame(cancelled, files.size());
dialog.setVisible(true);
for (int currentCount = 0; currentCount < files.size(); currentCount++) {
if (cancelled.value) {
LOG.debug("cancelled rearrangement");
break;
}
final VirtualFile f = files.get(currentCount);
final int k = currentCount;
Runnable fn = new Runnable() {
public void run() {
final PsiFile psiFile = pm.findFile(f);
LOG.debug("SDT setting filename to " + psiFile.getName());
filename.setText(psiFile.getName());
filename.repaint();
}
};
Runnable r = new Runnable() {
public void run() {
final PsiFile psiFile = pm.findFile(f);
if (psiFile != null &&
psiFile.getName().endsWith(".java") &&
psiFile.isWritable())
{
LOG.debug("SDT rearranging file " + psiFile.getName());
final Document document = dm.getDocument(psiFile);
final Application application = ApplicationManager.getApplication();
application.runWriteAction(
new Runnable() {
public void run() {
final Application application = ApplicationManager.getApplication();
final Rearranger rearranger = application.getComponent(Rearranger.class);
RearrangerSettings settings = rearranger.getSettings();
settings = settings.deepCopy();
// avoid showing confirmation dialog for each file done
settings.setAskBeforeRearranging(false);
rah.runWriteActionRearrangement(project, document, psiFile, settings);
}
}
);
}
if (!cancelled.value) {
LOG.debug("SDT setting progress bar value to " + (k + 1));
bar.setValue(k + 1);
bar.repaint();
}
}
};
try {
SwingUtilities.invokeAndWait(fn);
SwingUtilities.invokeAndWait(r);
}
catch (InterruptedException e) {
LOG.error(e);
}
catch (InvocationTargetException e) {
LOG.error(e);
}
}
dialog.setVisible(false);
dialog.dispose();
}
final JDialog getProgressFrame(final BoolHolder cancelled, final int max) {
Object parent = null;
if (project != null) {
parent = WindowManager.getInstance().suggestParentWindow(project);
}
LOG.debug("suggested parent window=" + parent);
final JDialog dialog = parent == null ?
new JDialog() :
(parent instanceof JDialog ?
new JDialog((JDialog)parent) :
new JDialog((JFrame)parent));
final Container pane = dialog.getContentPane();
final JLabel rearrangingLabel = new JLabel("Rearranging files, please wait...");
final JPanel progressPanel = new JPanel(new GridBagLayout());
final Constraints constraints = new Constraints(GridBagConstraints.NORTHWEST);
constraints.newRow();
constraints.insets = new Insets(15, 15, 0, 0);
progressPanel.add(rearrangingLabel, constraints.weightedLastCol());
constraints.newRow();
bar.setMinimum(0);
bar.setMaximum(max);
bar.setPreferredSize(new Dimension(500, 15));
bar.setMinimumSize(new Dimension(500, 15));
bar.setStringPainted(true);
constraints.insets = new Insets(15, 15, 5, 15);
progressPanel.add(bar, constraints.weightedFirstCol());
constraints.insets = new Insets(9, 0, 5, 15);
final JButton cancelButton = new JButton("Cancel");
cancelButton.addActionListener(
new ActionListener() {
public void actionPerformed(final ActionEvent e) {
LOG.debug("cancel button pressed");
filename.setText("cancelling...");
cancelled.value = true;
}
}
);
progressPanel.add(cancelButton, constraints.weightedLastCol());
constraints.weightedLastRow();
constraints.insets = new Insets(0, 15, 15, 0);
filename.setSize(500, 15);
filename.setPreferredSize(new Dimension(500, 15));
// filename.setFont(new Font("dialog", Font.PLAIN, 12));
progressPanel.add(filename, constraints.weightedLastCol());
pane.add(progressPanel, BorderLayout.CENTER);
dialog.setTitle(Rearranger.COMPONENT_NAME);
dialog.addWindowListener(
new WindowListener() {
public void windowClosed(final WindowEvent e) {
//To change body of implemented methods use Options | File Templates.
}
public void windowActivated(final WindowEvent e) {
//To change body of implemented methods use Options | File Templates.
}
public void windowClosing(final WindowEvent e) {
LOG.debug("dialog closed, cancel Rearranger");
filename.setText("cancelling...");
cancelled.value = true;
}
public void windowDeactivated(final WindowEvent e) {
//To change body of implemented methods use Options | File Templates.
}
public void windowDeiconified(final WindowEvent e) {
//To change body of implemented methods use Options | File Templates.
}
public void windowIconified(final WindowEvent e) {
//To change body of implemented methods use Options | File Templates.
}
public void windowOpened(final WindowEvent e) {
//To change body of implemented methods use Options | File Templates.
}
}
);
dialog.pack();
return dialog;
}
}
// --------------------------- main() method ---------------------------
/**
* Test progress bar functionality. Read 10 "filenames" from console, pausing between each to update the
* progress bar dialog. Handle cancel button and dialog window close button properly.
*
* @param args
*/
public static void main(final String[] args) {
// test the progress bar.
final BufferedReader reader;
final ProjectTreeActionHandler ptah = new ProjectTreeActionHandler();
final RearrangeIt ri = ptah.new RearrangeIt(null);
final RearrangeIt.IntHolder cancelled = ri.new IntHolder();
reader = new BufferedReader(new InputStreamReader(System.in));
RearrangeIt.BoolHolder c = ri.new BoolHolder();
final JDialog dialog = ri.getProgressFrame(c, 10);
int count = 0;
dialog.pack();
dialog.setVisible(true);
while (count <= 10 && cancelled.n == 0) {
String s = null;
try {
s = reader.readLine();
}
catch (IOException e) {
e.printStackTrace();
}
if (cancelled.n == 0) {
ri.filename.setText(s);
count++;
ri.bar.setValue(count);
}
}
dialog.setVisible(false);
dialog.dispose();
System.exit(0);
}
}
plugins/rearranger/src/com/wrq/rearranger/Rearranger.java
-207
View File
@@ -1,207 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger;
import com.intellij.openapi.components.ApplicationComponent;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.options.Configurable;
import com.intellij.openapi.util.JDOMExternalizable;
import com.wrq.rearranger.configuration.RearrangerSettingsPanel;
import com.wrq.rearranger.settings.RearrangerSettings;
import org.jdom.Element;
import javax.swing.*;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.List;
/**
* The rearranger is an IntelliJ IDEA plugin that rearranges the order of class declarations and
* class member declarations within a Java file. The user configures an ordering of fields, methods, and classes.
* Subsequently, whenever the rearranger plugin is invoked on a Java file, the order of declarations is rearranged
* according to the configuration.
*/
public final class Rearranger
implements ApplicationComponent, Configurable, JDOMExternalizable
{
// ------------------------------ FIELDS ------------------------------
public static final String COMPONENT_NAME = "Rearranger";
public static final String VERSION = "5.5";
private static final Logger LOG = Logger.getInstance("#" + Rearranger.class.getName());
private transient RearrangerSettingsPanel preferencesPanel;
private RearrangerSettings settings = new RearrangerSettings();
private boolean haveReadExternalSettings;
// --------------------------- CONSTRUCTORS ---------------------------
public Rearranger() {
// logger.setAdditivity(false);
// logger.addAppender(new ConsoleAppender(new PatternLayout("[%7r] %6p - %30.30c - %m \n")));
// logger.setLevel(Level.DEBUG);
// logger.setLevel(Level.INFO);
LOG.debug("constructor called for " + COMPONENT_NAME + " plugin version " + VERSION);
preferencesPanel = null;
/**
* If the Reformat plugin is present, register for a callback after code reformatting
* takes place. This allows user to optimize imports, reformat code, and rearrange all
* with one keystroke.
*/
try {
if (Class.forName("org.intellij.psi.codeStyle.ReformatManager") != null) {
/**
* Reformat plugin is available. Hook it by calling code in RearrangeUtility.
* Do this dynamically using reflection so we don't get class loading problems.
*/
LOG.debug("found ReformatManager class, attempting to hook.");
/**
* if the Reformat plugin is present, obtain a reference to our RearrangerUtility class, which will register
* for callbacks from the Reformat plugin.
*/
Class rearrangerUtilityClass = Class.forName("org.intellij.psi.codeStyle.RearrangerUtility");
final Method hookit = rearrangerUtilityClass.getMethod("hookReformatPlugin", new Class[]{});
hookit.invoke(null, (Object)null);
}
}
catch (ClassNotFoundException e) {
/**
* no reformat plugin available. Just continue with normal rearranger plugin behavior.
*/
LOG.debug("did not find class org.intellij.psi.codeStyle.RearrangerUtility");
}
catch (NoSuchMethodException e) {
LOG.info(e.toString(), e);
}
catch (IllegalAccessException e) {
LOG.info(e.toString(), e);
}
catch (InvocationTargetException e) {
LOG.info(e.toString(), e);
}
}
// --------------------- GETTER / SETTER METHODS ---------------------
// End Methods of Interface JDOMExternalizable
public RearrangerSettings getSettings() {
return settings;
}
public void setSettings(RearrangerSettings settings) {
this.settings = settings;
}
// ------------------------ INTERFACE METHODS ------------------------
// --------------------- Interface BaseComponent ---------------------
public void initComponent() {
LOG.debug("initComponent()");
}
public void disposeComponent() {
LOG.debug("disposeComponent()");
}
// --------------------- Interface Configurable ---------------------
public String getDisplayName() {
return COMPONENT_NAME;
}
public String getHelpTopic() {
return null;
}
// --------------------- Interface JDOMExternalizable ---------------------
public void readExternal(final Element element) //throws InvalidDataException
{
LOG.debug("rearranger.readExternal()");
haveReadExternalSettings = true;
final List entries = element.getChildren(COMPONENT_NAME);
if (entries.size() > 0) {
LOG.debug("element 'Rearranger' seen; configuration loading");
final Element entry = (Element)entries.get(0);
LOG.debug("element has " + entry.getChildren().size() + " children");
settings.readExternal(entry);
}
}
public void writeExternal(final Element element) //throws WriteExternalException
{
LOG.debug("rearranger.writeExternal()");
final Element our_element = new Element(COMPONENT_NAME);
settings.writeExternal(our_element);
element.getChildren().clear();
element.addContent(our_element);
}
// --------------------- Interface NamedComponent ---------------------
public String getComponentName() {
return COMPONENT_NAME;
}
// --------------------- Interface UnnamedConfigurable ---------------------
public JComponent createComponent() {
LOG.debug("createComponent: haveReadExternalSettings=" + haveReadExternalSettings);
RearrangerSettings rs;
if (!haveReadExternalSettings) {
LOG.debug("createComponent: reading default settings");
rs = RearrangerSettings.getDefaultSettings();
if (rs == null) {
LOG.debug("createComponent: could not find default settings");
}
haveReadExternalSettings = true;
}
else {
rs = settings;
}
preferencesPanel = new RearrangerSettingsPanel(rs);
return preferencesPanel;
}
public boolean isModified() {
final boolean result = !preferencesPanel.settings.equals(settings);
LOG.debug("rearranger.isModified(): returning " + result);
return result;
}
public void apply() {
LOG.debug("rearranger.apply()");
settings = preferencesPanel.settings.deepCopy();
}
public void reset() {
LOG.debug("rearranger.reset()");
}
public void disposeUIResources() {
preferencesPanel = null;
}
}
plugins/rearranger/src/com/wrq/rearranger/RearrangerAction.java
-34
View File
@@ -1,34 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger;
import com.intellij.openapi.editor.actionSystem.EditorAction;
public final class RearrangerAction
extends EditorAction
{
// --------------------------- CONSTRUCTORS ---------------------------
public RearrangerAction() {
super(new RearrangerActionHandler());
}
}
plugins/rearranger/src/com/wrq/rearranger/RearrangerActionHandler.java
-227
View File
@@ -1,227 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger;
import com.intellij.openapi.actionSystem.DataContext;
import com.intellij.openapi.actionSystem.PlatformDataKeys;
import com.intellij.openapi.application.Application;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.command.CommandProcessor;
import com.intellij.openapi.components.ServiceManager;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.editor.Document;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.editor.actionSystem.EditorActionHandler;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.openapi.wm.WindowManager;
import com.intellij.psi.PsiDocumentManager;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
import com.wrq.rearranger.entry.ClassContentsEntry;
import com.wrq.rearranger.popup.FileStructurePopup;
import com.wrq.rearranger.rearrangement.Emitter;
import com.wrq.rearranger.rearrangement.Mover;
import com.wrq.rearranger.rearrangement.Parser;
import com.wrq.rearranger.rearrangement.Spacer;
import com.wrq.rearranger.ruleinstance.RuleInstance;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.util.CommentUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.awt.dnd.DragSource;
import java.util.List;
/** This class performs rearrangement actions requested by the user. */
public final class RearrangerActionHandler extends EditorActionHandler {
// ------------------------------ FIELDS ------------------------------
private static final Logger LOG = Logger.getInstance("#" + RearrangerActionHandler.class.getName());
private static int rightMargin;
private static int tabSize;
// -------------------------- STATIC METHODS --------------------------
public static int getRightMargin() {
return rightMargin;
}
public static int getTabSize() {
return tabSize;
}
// -------------------------- OTHER METHODS --------------------------
public final void execute(final Editor editor, final DataContext context) {
if (editor == null) {
return;
}
LOG.debug("enter RearrangerActionHandler.execute()");
final PsiFile psiFile = getFile(editor, context);
if (psiFile == null) {
return;
}
final Project project = PlatformDataKeys.PROJECT.getData(context);
final Document document = editor.getDocument();
LOG.debug("suggested tool window = " + WindowManager.getInstance().suggestParentWindow(project));
LOG.debug("drag source image supported = " + DragSource.isDragImageSupported());
if (!psiFile.getName().endsWith(".java")) {
LOG.debug("not a .java file -- skipping " + psiFile.getName());
return;
}
if (!psiFile.isWritable()) {
LOG.debug("not a writable .java file -- skipping " + psiFile.getName());
return;
}
rightMargin = editor.getSettings().getRightMargin(project);
tabSize = editor.getSettings().getTabSize(project);
LOG.debug("right margin=" + rightMargin + ", tabSize=" + tabSize);
final Application application = ApplicationManager.getApplication();
application.runWriteAction(new Runnable() {
public void run() {
final Rearranger rearranger = ServiceManager.getService(Rearranger.class);
final RearrangerSettings settings = rearranger.getSettings();
runWriteActionRearrangement(project, document, psiFile, settings);
}
}
);
}
@Nullable
private static PsiFile getFile(final Editor editor, final DataContext context) {
final Project project = PlatformDataKeys.PROJECT.getData(context);
if (project == null) {
return null;
}
return PsiDocumentManager.getInstance(project).getPsiFile(editor.getDocument());
}
/**
* must be called from within an IDEA write-action thread.
*
* @param project
* @param document
* @param psiFile
*/
void runWriteActionRearrangement(final Project project,
final Document document,
final PsiFile psiFile,
final RearrangerSettings settings)
{
/**
* Per instructions from IntelliJ, we have to commit any changes to the document to the Psi
* tree.
*/
final PsiDocumentManager documentManager = PsiDocumentManager.getInstance(project);
documentManager.commitDocument(document);
final WaitableBoolean wb = new WaitableBoolean();
if (psiFile != null &&
isFileWritable(psiFile) &&
psiFile.getName().endsWith(".java"))
{
LOG.debug("schedule rearranger task");
final Runnable task = new rearrangerTask(project, psiFile, settings, document, wb);
CommandProcessor.getInstance().executeCommand(project, task, "Rearrange", null);
}
try {
LOG.debug("wait for rearranger task to complete.");
wb.whenTrue();
}
catch (InterruptedException e) {
LOG.warn(e);
}
LOG.debug("end execute");
}
public static boolean isFileWritable(PsiElement element) {
VirtualFile file = element.getContainingFile().getVirtualFile();
return file != null && file.isWritable();
}
@SuppressWarnings("MethodMayBeStatic")
public final void rearrangeDocument(@NotNull final Project project,
@NotNull final PsiFile psiFile,
@NotNull final RearrangerSettings settings,
@NotNull final Document document)
{
LOG.debug("enter rearrangeDocument");
new CommentUtil(settings); // create CommentUtil singleton
final Parser p = new Parser(project, settings, psiFile);
final List<ClassContentsEntry> outerClasses = p.parseOuterLevel();
if (outerClasses.size() > 0) {
final Mover m = new Mover(outerClasses, settings);
final List<RuleInstance> resultRuleInstances = m.rearrangeOuterClasses();
boolean rearrange = true;
if (settings.isAskBeforeRearranging()) {
FileStructurePopup fsp = new FileStructurePopup(settings, resultRuleInstances, psiFile);
rearrange = fsp.displayRearrangement();
}
if (rearrange) {
final Emitter e = new Emitter(psiFile, resultRuleInstances, document);
e.emitRearrangedDocument();
}
}
LOG.debug("respacing document");
PsiDocumentManager.getInstance(project).commitDocument(document);
Spacer spacer = new Spacer(psiFile, document, settings);
if (spacer.respace()) {
PsiDocumentManager.getInstance(project).commitDocument(document);
}
LOG.debug("exit rearrangeDocument");
}
// -------------------------- INNER CLASSES --------------------------
final class rearrangerTask implements Runnable {
final Project project;
final PsiFile psiFile;
final RearrangerSettings settings;
final Document document;
final WaitableBoolean wb;
public rearrangerTask(final Project project,
final PsiFile psiFile,
final RearrangerSettings settings,
final Document document,
final WaitableBoolean wb)
{
this.project = project;
this.psiFile = psiFile;
this.settings = settings;
this.document = document;
this.wb = wb;
}
public final void run() {
try {
rearrangeDocument(project, psiFile, settings, document);
}
finally {
wb.set();
}
}
}
}
plugins/rearranger/src/com/wrq/rearranger/TestOverImpl.java
-58
View File
@@ -1,58 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger;
/** Test method attributes: overriding, implementing, overridden, implemented. */
abstract public class TestOverImpl
implements Runnable
{
public String toString() {
// overrides Object.toString()
return super.toString(); //To change body of overridden methods use File | Settings | File Templates.
}
public void run() {
// implements Runnable.run()
}
abstract void abstractMethod(); // is implemented
abstract void isntImplementedMethod();
void overrideableMethod() // is overridden
{
// do nothing
}
}
abstract class TestOverImpl2 extends TestOverImpl {
void abstractMethod() // implements
{
// implements abstractMethod()
}
void overrideableMethod() // overrides
{
super.overrideableMethod(); //To change body of overridden methods use File | Settings | File Templates.
}
}
plugins/rearranger/src/com/wrq/rearranger/WaitableBoolean.java
-69
View File
@@ -1,69 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger;
/**
* Class to permit a thread to wait until another thread has finished work and set the boolean
* to true.
*/
public final class WaitableBoolean {
// ------------------------------ FIELDS ------------------------------
private boolean value_;
private final Object lock_;
// --------------------------- CONSTRUCTORS ---------------------------
/**
* Make a new WaitableBoolean with the given initial value,
* and using its own internal lock.
*/
public WaitableBoolean() {
lock_ = this;
value_ = false;
}
// -------------------------- OTHER METHODS --------------------------
public final void set() {
set(true);
}
/** Set to newValue. */
public final void set(final boolean value) {
synchronized (lock_) {
lock_.notifyAll();
value_ = value;
}
}
/**
* wait until value is true, then run action if nonnull.
* The action is run with the synchronization lock held.
*/
public final void whenTrue() throws InterruptedException {
synchronized (lock_) {
while (!value_) lock_.wait();
}
}
}
plugins/rearranger/src/com/wrq/rearranger/configuration/ChoiceObject.java
-66
View File
@@ -1,66 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.configuration;
import com.wrq.rearranger.settings.attributeGroups.AttributeGroup;
import javax.swing.*;
/** Represents a labeled button that corresponds to a customized subpanel. */
public abstract class ChoiceObject {
// ------------------------------ FIELDS ------------------------------
protected AttributeGroup choiceObject;
protected AttributeGroup editingObject;
protected final String buttonName;
// --------------------------- CONSTRUCTORS ---------------------------
ChoiceObject(final String buttonName) {
this.buttonName = buttonName;
choiceObject = null;
editingObject = null;
}
// --------------------- GETTER / SETTER METHODS ---------------------
final AttributeGroup getChoiceObject() {
return choiceObject;
}
// ------------------------ CANONICAL METHODS ------------------------
public final String toString() {
return choiceObject.toString();
}
// -------------------------- OTHER METHODS --------------------------
void acceptEdited() {
choiceObject = editingObject;
editingObject = null;
}
abstract JPanel createJPanel();
abstract void createObject();
}
plugins/rearranger/src/com/wrq/rearranger/configuration/ChoicePanel.java
-155
View File
@@ -1,155 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.configuration;
import javax.swing.*;
import javax.swing.border.Border;
import javax.swing.border.TitledBorder;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
/**
* Panel which contains a number of buttons (choices) and a customized subpanel which corresponds to the chosen
* button.
*/
final class ChoicePanel
extends JPanel
{
// ------------------------------ FIELDS ------------------------------
private final ChoiceObject[] choices;
private int choice;
private final String choicePanelName;
// --------------------------- CONSTRUCTORS ---------------------------
ChoicePanel(final ChoiceObject[] choices,
final String choicePanelName)
{
super(new GridBagLayout());
this.choices = choices;
choice = 0;
this.choicePanelName = choicePanelName;
initializeChoices();
}
private void initializeChoices() {
for (ChoiceObject choice1 : choices) {
choice1.createObject();
}
choice = 0;
}
// ------------------------ CANONICAL METHODS ------------------------
public String toString() {
return choices[choice].toString();
}
// -------------------------- OTHER METHODS --------------------------
void configurePanel() {
final Border border = BorderFactory.createEmptyBorder();
final TitledBorder tb = new TitledBorder(border, choicePanelName);
setBorder(tb);
final GridBagConstraints constraints = new GridBagConstraints();
constraints.anchor = GridBagConstraints.NORTHWEST;
constraints.fill = GridBagConstraints.BOTH;
constraints.gridheight = 1;
constraints.weighty = 0;
final ButtonGroup group = new ButtonGroup();
final JRadioButton[] buttons = new JRadioButton[choices.length];
final JPanel[] panels = new JPanel[choices.length];
final Dimension max = new Dimension();
// make two columns of choice buttons to save some panel space.
for (int i = 0; i < choices.length; i++) {
buttons[i] = new JRadioButton(choices[i].buttonName);
group.add(buttons[i]);
constraints.gridx = i % 2;
constraints.gridy = i >> 1;
constraints.gridwidth = (i % 2 == 1) ?
GridBagConstraints.REMAINDER : 1;
constraints.weightx = (i % 2 == 1) ? 1 : 0;
add(buttons[i], constraints);
choices[i].editingObject = choices[i].choiceObject.deepCopy();
panels[i] = choices[i].createJPanel();
/**
* calculate largest dimension of any of the replaceable panels.
*/
final Dimension dimension = panels[i].getPreferredSize();
if (dimension.height > max.height) max.height = dimension.height;
if (dimension.width > max.width) max.width = dimension.width;
}
buttons[choice].setSelected(true);
constraints.gridheight = GridBagConstraints.REMAINDER;
constraints.gridwidth = 2;
constraints.weighty = 1;
constraints.gridx = 0;
constraints.gridy = (choices.length >> 1) + 1;
for (int i = 0; i < choices.length; i++) {
final int j = i;
panels[i].setPreferredSize(max);
buttons[i].addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
if (buttons[j].isSelected()) {
remove(choices.length);
add(panels[j], constraints);
panels[j].invalidate();
panels[j].repaint();
validate();
choice = j;
}
}
});
}
final JPanel beginning_panel = panels[choice];
add(beginning_panel, constraints);
}
void copyChoices(final ChoicePanel currentMsg) {
System.arraycopy(currentMsg.choices, 0, choices, 0, choices.length);
choice = currentMsg.choice;
}
void acceptEdited() {
for (ChoiceObject choice1 : choices) {
choice1.acceptEdited();
}
}
ChoiceObject getChoice() {
return choices[choice];
}
public ChoiceObject[] getChoices() {
return choices;
}
public void setChoice(int choice) {
this.choice = choice;
}
public String getChoicePanelName() {
return choicePanelName;
}
}
plugins/rearranger/src/com/wrq/rearranger/configuration/ClassMemberSettingsPane.java
-95
View File
@@ -1,95 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.configuration;
import com.wrq.rearranger.settings.CommentRule;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.settings.attributeGroups.FieldAttributes;
import com.wrq.rearranger.settings.attributeGroups.InnerClassAttributes;
import com.wrq.rearranger.settings.attributeGroups.InterfaceAttributes;
import com.wrq.rearranger.settings.attributeGroups.MethodAttributes;
import javax.swing.*;
/** UI code for Class Member (field, method, inner class) dialog. */
final class ClassMemberSettingsPane
extends SettingsPane
{
// --------------------------- CONSTRUCTORS ---------------------------
ClassMemberSettingsPane(final RearrangerSettings settings) {
super(settings, settings.getItemOrderAttributeList());
}
// -------------------------- OTHER METHODS --------------------------
ChoicePanel createChoicePanel() {
final ChoiceObject[] choices = new ChoiceObject[5];
int index = 0;
choices[index++] = new ChoiceObject("Field") {
void createObject() {
choiceObject = new FieldAttributes();
}
JPanel createJPanel() {
return ((FieldAttributes)editingObject).getFieldAttributes();
}
};
choices[index++] = new ChoiceObject("Method") {
void createObject() {
choiceObject = new MethodAttributes(settings.getDefaultGSDefinition());
}
JPanel createJPanel() {
return ((MethodAttributes)editingObject).getMethodAttributes();
}
};
choices[index++] = new ChoiceObject("Interface Methods") {
void createObject() {
choiceObject = new InterfaceAttributes();
}
JPanel createJPanel() {
return ((InterfaceAttributes)editingObject).getInterfaceAttributes();
}
};
choices[index++] = new ChoiceObject("Inner Class") {
void createObject() {
choiceObject = new InnerClassAttributes();
}
JPanel createJPanel() {
return ((InnerClassAttributes)editingObject).getInnerClassAttributes();
}
};
choices[index++] = new ChoiceObject("Separator Comment") {
void createObject() {
choiceObject = new CommentRule();
}
JPanel createJPanel() {
return ((CommentRule)editingObject).getCommentPanel();
}
};
return new ChoicePanel(choices, "Class Member Order");
}
}
plugins/rearranger/src/com/wrq/rearranger/configuration/ClassOrderSettingsPane.java
-65
View File
@@ -1,65 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.configuration;
import com.wrq.rearranger.settings.CommentRule;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.settings.attributeGroups.ClassAttributes;
import javax.swing.*;
/** UI code for Outer Class order dialog. */
final class ClassOrderSettingsPane
extends SettingsPane
{
// --------------------------- CONSTRUCTORS ---------------------------
public ClassOrderSettingsPane(final RearrangerSettings settings) {
super(settings, settings.getClassOrderAttributeList());
}
// -------------------------- OTHER METHODS --------------------------
ChoicePanel createChoicePanel() {
final ChoiceObject[] choices = new ChoiceObject[2];
choices[0] = new ChoiceObject("Class") {
void createObject() {
choiceObject = new ClassAttributes();
}
JPanel createJPanel() {
return ((ClassAttributes)editingObject).getClassAttributesPanel();
}
};
choices[1] = new ChoiceObject("Separator Comment") {
void createObject() {
choiceObject = new CommentRule();
}
JPanel createJPanel() {
return ((CommentRule)editingObject).getCommentPanel();
}
};
final ChoicePanel panel = new ChoicePanel(choices, "Outer Class Order");
return panel;
}
}
plugins/rearranger/src/com/wrq/rearranger/configuration/ExtractedMethodsPane.java
-428
View File
@@ -1,428 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.configuration;
import com.wrq.rearranger.settings.CommentRule;
import com.wrq.rearranger.settings.RelatedMethodsSettings;
import com.wrq.rearranger.util.Constraints;
import javax.swing.*;
import javax.swing.border.Border;
import javax.swing.border.TitledBorder;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
/** Configuration settings for handling ordering of extracted methods. */
public class ExtractedMethodsPane {
// --------------------------- main() method ---------------------------
// ---------- START Level 1 ----------
// ---------- START Level 2 ----------
JPanel getExtractedMethodsPane(final RelatedMethodsSettings rms) {
final JPanel containerPanel = new JPanel(new GridBagLayout());
final Constraints constraints = new Constraints(GridBagConstraints.NORTHWEST);
constraints.fill = GridBagConstraints.BOTH;
constraints.weightedLastRow();
final JTabbedPane pane = new JTabbedPane();
final JPanel relatedMethodsArrangementPane = getExtractedMethodsArrangementPane(rms);
final JPanel relatedMethodsCommentsPane = getRelatedMethodsCommentsPane(rms);
pane.addTab("Arrangement", null, relatedMethodsArrangementPane,
"Options controlling arrangement of extracted methods");
pane.addTab("Comments", null, relatedMethodsCommentsPane,
"Extracted method comments");
pane.setSelectedIndex(0);
containerPanel.add(pane, constraints.weightedLastCol());
return containerPanel;
}
// ---------- START Level 3 ----------
private JPanel getExtractedMethodsArrangementPane(final RelatedMethodsSettings rms) {
final JPanel pane = new JPanel(new GridBagLayout());
final JPanel innerPanel = new JPanel(new GridBagLayout());
final Border border = BorderFactory.createEtchedBorder();
final TitledBorder tb = new TitledBorder(border, "Options controlling arrangement of extracted methods");
innerPanel.setBorder(tb);
final Constraints constraints = new Constraints(GridBagConstraints.NORTHWEST);
JPanel traversalOrderPanel = getTraversalOrderPanel(rms);
JPanel orderingPanel = getOrderingPanel(rms);
JPanel extractedPanel = getExtractedPanel(rms);
innerPanel.add(getMoveMethodsPanel(rms, new JPanel[]{traversalOrderPanel, orderingPanel, extractedPanel}),
constraints.weightedLastCol());
constraints.newRow();
constraints.insets = new Insets(0, 20, 0, 0);
innerPanel.add(traversalOrderPanel, constraints.weightedLastCol());
constraints.newRow();
innerPanel.add(orderingPanel, constraints.weightedLastCol());
constraints.weightedLastRow();
innerPanel.add(extractedPanel, constraints);
Dimension d = innerPanel.getPreferredSize();
innerPanel.setPreferredSize(d);
innerPanel.setMaximumSize(d);
constraints.fill = GridBagConstraints.NONE;
constraints.gridx = constraints.gridy = 0;
pane.add(innerPanel, constraints);
return pane;
}
// ---------- START Level 4 ----------
JPanel getTraversalOrderPanel(final RelatedMethodsSettings rms) {
final JPanel traversalOrderPanel = new JPanel(new GridBagLayout());
final Constraints constraints = new Constraints(GridBagConstraints.NORTHWEST);
constraints.fill = GridBagConstraints.BOTH;
constraints.weightedLastRow();
{
constraints.insets = new Insets(5, 5, 5, 0);
JLabel performLabel = new JLabel("Perform");
traversalOrderPanel.add(performLabel, constraints.firstCol());
}
{
final JComboBox traversalOrderBox = new JComboBox(new String[]{"depth first", "breadth first"});
traversalOrderPanel.add(traversalOrderBox, constraints.nextCol());
traversalOrderBox.setSelectedIndex(1);
Dimension d = traversalOrderBox.getPreferredSize();
d.width += 3;
traversalOrderBox.setPreferredSize(d);
traversalOrderBox.setSelectedIndex(rms.isDepthFirstOrdering() ? 0 : 1);
traversalOrderBox.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
rms.setDepthFirstOrdering(traversalOrderBox.getSelectedIndex() == 0);
}
});
}
{
JLabel remainderLabel = new JLabel("ordering on nested method calls");
traversalOrderPanel.add(remainderLabel, constraints.lastCol());
}
return traversalOrderPanel;
}
JPanel getOrderingPanel(final RelatedMethodsSettings rms) {
final JPanel orderingPanel = new JPanel(new GridBagLayout());
final Border border = BorderFactory.createEtchedBorder();
final TitledBorder tb = new TitledBorder(border, "Ordering options");
orderingPanel.setBorder(tb);
final Constraints constraints = new Constraints(GridBagConstraints.NORTHWEST);
final JRadioButton invocationButton = new JRadioButton("Place in order of invocation");
final JRadioButton originalButton = new JRadioButton("Retain original order");
final JRadioButton alphabetizeButton = new JRadioButton("Alphabetize");
ButtonGroup group = new ButtonGroup();
group.add(invocationButton);
group.add(originalButton);
group.add(alphabetizeButton);
orderingPanel.add(invocationButton, constraints.weightedLastCol());
constraints.newRow();
orderingPanel.add(originalButton, constraints.weightedLastCol());
constraints.weightedLastRow();
orderingPanel.add(alphabetizeButton, constraints.weightedLastCol());
switch (rms.getOrdering()) {
case RelatedMethodsSettings.INVOCATION_ORDER:
invocationButton.setSelected(true);
break;
case RelatedMethodsSettings.RETAIN_ORIGINAL_ORDER:
originalButton.setSelected(true);
break;
case RelatedMethodsSettings.ALPHABETICAL_ORDER:
alphabetizeButton.setSelected(true);
break;
}
invocationButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (invocationButton.isSelected()) {
rms.setOrdering(RelatedMethodsSettings.INVOCATION_ORDER);
}
}
});
originalButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (originalButton.isSelected()) {
rms.setOrdering(RelatedMethodsSettings.RETAIN_ORIGINAL_ORDER);
}
}
});
alphabetizeButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (alphabetizeButton.isSelected()) {
rms.setOrdering(RelatedMethodsSettings.ALPHABETICAL_ORDER);
}
}
});
return orderingPanel;
}
JPanel getExtractedPanel(final RelatedMethodsSettings rms) {
final JPanel extractedPanel = new JPanel(new GridBagLayout());
final Constraints constraints = new Constraints(GridBagConstraints.NORTHWEST);
constraints.insets = new Insets(5, 5, 5, 0);
JLabel label = new JLabel("Consider a non-private method as an extracted method:");
extractedPanel.add(label, constraints.weightedLastCol());
constraints.insets = new Insets(0, 15, 0, 0);
final JRadioButton neverButton = new JRadioButton("never");
constraints.newRow();
extractedPanel.add(neverButton, constraints.weightedLastCol());
final JRadioButton oneButton = new JRadioButton("when it is called by only one method in the class");
constraints.newRow();
extractedPanel.add(oneButton, constraints.weightedLastCol());
final JRadioButton moreButton = new JRadioButton("when it has one or more callers in the class");
constraints.weightedLastRow();
extractedPanel.add(moreButton, constraints.weightedLastCol());
ButtonGroup g = new ButtonGroup();
g.add(neverButton);
g.add(oneButton);
g.add(moreButton);
switch (rms.getNonPrivateTreatment()) {
case RelatedMethodsSettings.NON_PRIVATE_EXTRACTED_NEVER:
neverButton.setSelected(true);
break;
case RelatedMethodsSettings.NON_PRIVATE_EXTRACTED_ONE_CALLER:
oneButton.setSelected(true);
break;
case RelatedMethodsSettings.NON_PRIVATE_EXTRACTED_ANY_CALLERS:
moreButton.setSelected(true);
break;
}
neverButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (neverButton.isSelected()) {
rms.setNonPrivateTreatment(RelatedMethodsSettings.NON_PRIVATE_EXTRACTED_NEVER);
}
}
});
oneButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (oneButton.isSelected()) {
rms.setNonPrivateTreatment(RelatedMethodsSettings.NON_PRIVATE_EXTRACTED_ONE_CALLER);
}
}
});
moreButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (moreButton.isSelected()) {
rms.setNonPrivateTreatment(RelatedMethodsSettings.NON_PRIVATE_EXTRACTED_ANY_CALLERS);
}
}
});
return extractedPanel;
}
JPanel getMoveMethodsPanel(final RelatedMethodsSettings rms, final JPanel[] dependentPanels) {
final JPanel moveMethodsPanel = new JPanel(new GridBagLayout());
final Constraints constraints = new Constraints(GridBagConstraints.NORTHWEST);
constraints.weightedLastRow();
{
constraints.insets = new Insets(5, 5, 5, 0);
final JCheckBox moveBox = new JCheckBox("Move extracted methods below");
moveBox.setSelected(rms.isMoveExtractedMethods());
moveBox.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
rms.setMoveExtractedMethods(moveBox.isSelected());
enableComponents(moveMethodsPanel, moveBox.isSelected());
enableOtherComponents(dependentPanels, moveBox.isSelected());
}
});
moveMethodsPanel.add(moveBox, constraints.firstCol());
}
{
final JComboBox firstLastBox = new JComboBox(new String[]{"first", "last"});
firstLastBox.setSelectedIndex(0);
Dimension d = firstLastBox.getPreferredSize();
d.width += 3;
firstLastBox.setPreferredSize(d);
firstLastBox.setSelectedIndex(rms.isBelowFirstCaller() ? 0 : 1);
firstLastBox.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
rms.setBelowFirstCaller(firstLastBox.getSelectedIndex() == 0);
}
});
moveMethodsPanel.add(firstLastBox, constraints.nextCol());
}
{
constraints.insets = new Insets(8, 5, 5, 0);
JLabel usageLabel = new JLabel("usage");
moveMethodsPanel.add(usageLabel, constraints.weightedLastCol());
}
enableComponents(moveMethodsPanel, rms.isMoveExtractedMethods());
enableOtherComponents(dependentPanels, rms.isMoveExtractedMethods());
return moveMethodsPanel;
}
// ---------- START Level 5 ----------
private void enableComponents(JPanel pane, boolean selected) {
for (int i = 1; i < pane.getComponents().length; i++) {
pane.getComponents()[i].setEnabled(selected);
}
}
private void enableOtherComponents(JPanel[] otherPanels, boolean selected) {
for (JPanel otherPanel : otherPanels) {
enablePanel(otherPanel, selected);
}
}
// ---------- START Level 6 ----------
private void enablePanel(JPanel otherPanel, boolean selected) {
for (int i = 0; i < otherPanel.getComponents().length; i++) {
Component c = otherPanel.getComponents()[i];
if (c instanceof JPanel) {
enablePanel((JPanel)c, selected);
}
else {
c.setEnabled(selected);
}
}
}
// ---------- END Level 6 ----------
// ---------- END Level 5 ----------
// ---------- END Level 4 ----------
private JPanel getRelatedMethodsCommentsPane(final RelatedMethodsSettings rms) {
JPanel rmcPanel = new JPanel(new GridBagLayout());
final Constraints constraints = new Constraints(GridBagConstraints.NORTHWEST);
constraints.fill = GridBagConstraints.BOTH;
constraints.gridwidth = 1;
constraints.gridheight = 1;
constraints.weightx = 0.0d;
constraints.weighty = 0.0d;
JLabel commentTypeLabel = new JLabel("Emit comment at");
final JComboBox commentType = new JComboBox(new String[]{
"top level",
"each level",
"each method",
"family change (up level, or next sibling has children)"
});
commentType.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
rms.setCommentType(commentType.getSelectedIndex());
}
});
commentType.setSelectedIndex(rms.getCommentType());
JLabel legendLabel = new JLabel("Comment Substitutions: use");
JLabel legendLabel_1 = new JLabel("%TL% for top level method");
JLabel legendLabel_2 = new JLabel("%MN% for method name");
JLabel legendLabel_4 = new JLabel("%LV% for level number");
JLabel legendLabel_3 = new JLabel("%AM% for all method names");
JLabel precedingCommentLabel = new JLabel("Preceding Comment:");
JLabel trailingCommentLabel = new JLabel("Trailing Comment:");
JPanel precedingCommentPanel = getCommentAreaPanel(rms.getPrecedingComment());
JPanel trailingCommentPanel = getCommentAreaPanel(rms.getTrailingComment());
constraints.insets = new Insets(3, 5, 0, 0);
rmcPanel.add(commentTypeLabel, constraints.firstCol());
rmcPanel.add(commentType, constraints.lastCol());
JPanel legendPanel = new JPanel(new GridBagLayout());
{
final Border border = BorderFactory.createEtchedBorder();
legendPanel.setBorder(border);
final Constraints legendConstraints = new Constraints(GridBagConstraints.NORTHWEST);
legendConstraints.fill = GridBagConstraints.BOTH;
legendConstraints.insets = new Insets(5, 5, 0, 0);
legendPanel.add(legendLabel, legendConstraints.firstCol());
legendConstraints.insets = new Insets(5, 5, 0, 5);
legendPanel.add(legendLabel_1, legendConstraints.nextCol());
legendPanel.add(legendLabel_2, legendConstraints.lastCol());
legendConstraints.newRow();
legendConstraints.firstCol(); // skip first column
legendConstraints.insets = new Insets(5, 5, 5, 5);
legendPanel.add(legendLabel_3, legendConstraints.nextCol());
legendPanel.add(legendLabel_4, legendConstraints.lastCol());
}
constraints.newRow();
constraints.insets = new Insets(5, 5, 0, 5);
rmcPanel.add(legendPanel, constraints.weightedLastCol());
constraints.newRow();
rmcPanel.add(precedingCommentLabel, constraints.weightedLastCol());
constraints.weightedNewRow(0.50d);
rmcPanel.add(precedingCommentPanel, constraints.weightedLastCol());
constraints.newRow();
rmcPanel.add(trailingCommentLabel, constraints.weightedLastCol());
constraints.weightedNewRow(0.50d);
constraints.insets = new Insets(5, 5, 5, 5);
rmcPanel.add(trailingCommentPanel, constraints.weightedLastCol());
constraints.lastRow();
rmcPanel.add(rms.getCommentFillString().getCommentFillStringPanel(), constraints.weightedLastCol());
return rmcPanel;
}
// ---------- START Level 4 ----------
private JPanel getCommentAreaPanel(final CommentRule comment) {
JPanel commentPanel = new JPanel(new GridBagLayout());
final Constraints constraints = new Constraints(GridBagConstraints.NORTHWEST);
constraints.fill = GridBagConstraints.BOTH;
constraints.weightedLastRow();
final JTextArea commentArea = new JTextArea(4, 40);
commentArea.setText(comment.getCommentText());
final JScrollPane scrollPane = new JScrollPane(commentArea);
scrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
scrollPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
commentPanel.add(scrollPane, constraints.weightedFirstCol());
commentArea.getDocument().addDocumentListener(new DocumentListener() {
public void changedUpdate(final DocumentEvent e) {
comment.setCommentText(commentArea.getText());
}
public void insertUpdate(final DocumentEvent e) {
comment.setCommentText(commentArea.getText());
}
public void removeUpdate(final DocumentEvent e) {
comment.setCommentText(commentArea.getText());
}
});
return commentPanel;
}
// ---------- END Level 4 ----------
// ---------- END Level 3 ----------
// ---------- END Level 2 ----------
// ---------- END Level 1 ----------
}
plugins/rearranger/src/com/wrq/rearranger/configuration/IListManagerObject.java
-35
View File
@@ -1,35 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.configuration;
import javax.swing.*;
/** Describes objects that can be handled by ListManager. */
public interface IListManagerObject {
String getDescription();
void setDescription(String description);
JPanel getPanel();
IListManagerObject deepcopy();
}
plugins/rearranger/src/com/wrq/rearranger/configuration/IListManagerObjectFactory.java
-31
View File
@@ -1,31 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.configuration;
import java.util.List;
/** Handles creation and removal of list manager objects. */
public interface IListManagerObjectFactory {
IListManagerObject create(String name);
List getObjectList();
}
plugins/rearranger/src/com/wrq/rearranger/configuration/IntTextField.java
-94
View File
@@ -1,94 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.configuration;
import javax.swing.*;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import javax.swing.text.DefaultFormatterFactory;
import javax.swing.text.NumberFormatter;
import java.awt.*;
import java.text.NumberFormat;
/**
* A JTextField tied to a numeric field. Initialize the JTextField from the field and update
* the field whenever the JTextField's text changes.
*/
public class IntTextField
extends JFormattedTextField
{
public interface IGetSet {
public int get();
public void set(int value);
}
public IntTextField(final IGetSet getset, final Integer minimum, final Integer maximum) {
final NumberFormat integerInstance = NumberFormat.getIntegerInstance();
int maxDigits = 2;
if (maximum != null && (maximum) > 99) {
maxDigits = maximum.toString().length();
}
integerInstance.setMaximumIntegerDigits(maxDigits);
integerInstance.setMinimumIntegerDigits(1);
setFormatterFactory(new DefaultFormatterFactory(new NumberFormatter(integerInstance)));
setValue(maximum != null ? maximum : new Integer("88"));
final Dimension d = getPreferredSize();
d.width += 3;
setPreferredSize(d);
setValue(getset.get());
setFocusLostBehavior(JFormattedTextField.COMMIT_OR_REVERT);
setText("" + getValue());
getDocument().addDocumentListener(new DocumentListener() {
private void setit() {
try {
// allow empty string, else must be valid number
if (getText().length() != 0) {
int value = Integer.parseInt(getText());
if (minimum != null) {
if (value < (minimum)) value = (minimum);
}
if (maximum != null) {
if (value > (maximum)) value = (maximum);
}
getset.set(value);
}
}
catch (NumberFormatException e) {
// leave value alone
}
}
public void insertUpdate(DocumentEvent e) {
setit();
}
public void removeUpdate(DocumentEvent e) {
setit();
}
public void changedUpdate(DocumentEvent e) {
setit();
}
});
}
}
plugins/rearranger/src/com/wrq/rearranger/configuration/ListManager.java
-303
View File
@@ -1,303 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.configuration;
import com.wrq.rearranger.util.IconUtil;
import javax.swing.*;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
/**
* Generic manager for a panel with a list combo box, add/delete/copy buttons,
* a name field, and a subpanel to get contents of current item.
*/
public class ListManager
extends JPanel
{
JLabel nameLabel;
JTextField name;
JButton addButton;
JButton removeButton;
JButton copyButton;
JList list;
GridBagConstraints constraints;
final IListManagerObjectFactory factory;
IListManagerObject currentObject;
boolean buttonPressInProgress;
private JButton makeButton(String iconName) {
Icon icon = IconUtil.getIcon(iconName);
JButton result = new JButton(icon);
result.setPreferredSize(new Dimension(icon.getIconWidth(), icon.getIconHeight()));
return result;
}
public ListManager(final IListManagerObjectFactory factory, String nameLabelText) {
super(new GridBagLayout());
this.factory = factory;
currentObject = null;
nameLabel = new JLabel(nameLabelText);
name = new JTextField(3);
addButton = makeButton("general/add");
removeButton = makeButton("general/remove");
copyButton = makeButton("general/copy");
list = new JList(new DefaultListModel());
/**
* declare callback handlers for buttons.
*/
addButton.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
buttonPressInProgress = true;
currentObject = factory.create(getUniqueName("unnamed"));
factory.getObjectList().add(currentObject);
((DefaultListModel)list.getModel()).addElement(currentObject);
list.setSelectedIndex(list.getModel().getSize() - 1);
updateListSelection();
buttonPressInProgress = false;
}
}
);
removeButton.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
buttonPressInProgress = true;
DefaultListModel dlm = ((DefaultListModel)list.getModel());
int selectedIndex = list.getSelectedIndex();
IListManagerObject lmo = (IListManagerObject)dlm.getElementAt(selectedIndex);
factory.getObjectList().remove(lmo);
dlm.remove(selectedIndex);
if (selectedIndex >= dlm.getSize()) {
selectedIndex = dlm.getSize() - 1;
}
list.setSelectedIndex(selectedIndex);
currentObject =
(IListManagerObject)(selectedIndex < 0 ? null : dlm.getElementAt(selectedIndex));
updateListSelection();
buttonPressInProgress = false;
}
}
);
copyButton.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
buttonPressInProgress = true;
DefaultListModel dlm = ((DefaultListModel)list.getModel());
int selectedIndex = list.getSelectedIndex();
IListManagerObject lmo = (IListManagerObject)dlm.getElementAt(selectedIndex);
currentObject = lmo.deepcopy();
currentObject.setDescription(getUniqueName(lmo.getDescription()));
dlm.addElement(currentObject);
list.setSelectedIndex(list.getModel().getSize() - 1);
updateListSelection();
buttonPressInProgress = false;
}
}
);
name.getDocument().addDocumentListener(
new DocumentListener() {
private void updateList() {
if (buttonPressInProgress) {
return;
}
String newText = name.getText();
final IListManagerObject listObject = (IListManagerObject)list.getSelectedValue();
if (listObject != null) {
listObject.setDescription(newText);
}
int index = list.getSelectedIndex();
DefaultListModel dlm = ((DefaultListModel)list.getModel());
dlm.setElementAt(listObject, index);
validate();
}
public void changedUpdate(DocumentEvent e) {
updateList();
}
public void insertUpdate(DocumentEvent e) {
updateList();
}
public void removeUpdate(DocumentEvent e) {
updateList();
}
}
);
list.addListSelectionListener(
new ListSelectionListener() {
public void valueChanged(ListSelectionEvent e) {
if (buttonPressInProgress) {
return; // list selection changes due to add/remove/copy button handled elsewhere
}
buttonPressInProgress = true;
int selectedIndex = list.getSelectedIndex();
DefaultListModel dlm = ((DefaultListModel)list.getModel());
currentObject =
(IListManagerObject)(selectedIndex < 0 ? null : ((java.lang.Object)dlm.getElementAt(selectedIndex)));
updateListSelection();
buttonPressInProgress = false;
}
}
);
}
public final JPanel getPane() {
constraints = new GridBagConstraints();
constraints.anchor = GridBagConstraints.NORTHWEST;
constraints.fill = GridBagConstraints.NONE;
constraints.gridwidth = 1;
constraints.gridheight = GridBagConstraints.REMAINDER;
constraints.weightx = 0.0d;
constraints.weighty = 0.0d;
constraints.gridy = constraints.gridx = 0;
constraints.insets = new Insets(0, 0, 0, 5);
JPanel buttonPanel = new JPanel(new GridBagLayout());
buttonPanel.setBorder(BorderFactory.createEtchedBorder()); // todo remove
addButton.setBorderPainted(false);
removeButton.setBorderPainted(false);
copyButton.setBorderPainted(false);
buttonPanel.add(addButton, constraints);
constraints.gridx++;
buttonPanel.add(removeButton, constraints);
constraints.gridx++;
// constraints.gridwidth = GridBagConstraints.REMAINDER;
// constraints.weightx = 1;
buttonPanel.add(copyButton, constraints);
constraints = new GridBagConstraints();
constraints.anchor = GridBagConstraints.NORTHWEST;
constraints.fill = GridBagConstraints.NONE;
constraints.gridwidth = 1;
constraints.gridheight = 1;
constraints.weightx = 0.0d;
constraints.weighty = 0.0d;
constraints.gridy = constraints.gridx = 0;
constraints.insets = new Insets(3, 3, 3, 3);
add(buttonPanel, constraints);
buttonPanel.setPreferredSize(buttonPanel.getPreferredSize()); // todo determine effect if any
constraints.gridx++;
add(nameLabel, constraints);
constraints.gridx++;
constraints.gridwidth = GridBagConstraints.REMAINDER;
constraints.weightx = 1;
constraints.fill = GridBagConstraints.HORIZONTAL;
add(name, constraints);
list.getSelectionModel().setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
// addButton.setEnabled(true);
JScrollPane scrollPane = new JScrollPane(list);
Dimension d = buttonPanel.getPreferredSize();
d.width = d.width * 5 / 3;
scrollPane.setPreferredSize(d);
scrollPane.setMinimumSize(d);
for (Object object : factory.getObjectList()) {
((DefaultListModel)list.getModel()).addElement(object);
}
list.setSelectedIndex(list.getModel().getSize() - 1);
constraints.gridheight = GridBagConstraints.REMAINDER;
constraints.gridwidth = 1;
constraints.gridx = 0;
constraints.gridy++;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.fill = GridBagConstraints.VERTICAL;
add(scrollPane, constraints);
constraints.gridx++;
constraints.gridwidth = GridBagConstraints.REMAINDER;
constraints.fill = GridBagConstraints.BOTH;
constraints.weightx = 1;
constraints.weighty = 1;
final JPanel contents = new JPanel();
contents.setBorder(BorderFactory.createEtchedBorder()); // todo remove
add(contents, constraints);
updateListSelection();
validate();
return this;
}
/**
* Enable add/remove/copy buttons and fill in name of selected list item. Called whenever
* the list selection changes.
*/
private void updateListSelection() {
if (list.getModel().getSize() > 0) {
name.setEnabled(true);
nameLabel.setEnabled(true);
name.setText(((IListManagerObject)list.getSelectedValue()).getDescription());
removeButton.setEnabled(true);
copyButton.setEnabled(true);
}
else {
name.setEnabled(false);
nameLabel.setEnabled(false);
removeButton.setEnabled(false);
copyButton.setEnabled(false);
name.setText("");
}
remove(getComponentCount() - 1);
final JPanel contents = new JPanel();
contents.setBorder(BorderFactory.createEtchedBorder()); // todo remove
add(currentObject == null ? contents : ((javax.swing.JPanel)currentObject.getPanel()), constraints);
validate();
}
public String getUniqueName(String name) {
String result;
if (name != null) {
// test initially supplied name; if not duplicate, return it.
if (!dupName(name)) {
return name;
}
}
result = (name == null) ? "unnamed" : name;
int suffix = 0;
String testName;
do {
suffix++;
testName = result + "_" + suffix;
}
while (dupName(testName));
return testName;
}
/**
* @param name
* @return true if the supplied name is identical to any other primary method name.
*/
public boolean dupName(String name) {
for (int i = 0; i < list.getModel().getSize(); i++) {
IListManagerObject lmo = (IListManagerObject)list.getModel().getElementAt(i);
if (lmo.getDescription().equals(name)) {
return true;
}
}
return false; //To change body of created methods use File | Settings | File Templates.
}
}
plugins/rearranger/src/com/wrq/rearranger/configuration/MethodSpec.java
-227
View File
@@ -1,227 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.configuration;
import com.intellij.ui.DocumentAdapter;
import com.wrq.rearranger.util.Constraints;
import javax.swing.*;
import javax.swing.event.DocumentEvent;
import java.awt.*;
import java.text.NumberFormat;
/**
* Getters and setters are defined by their method names (eg., beginning with "get"), number of parameters,
* return type, and body contents. This class provides support for these common rule attributes.
* Other attributes, like number of parameters or return type, are already specified in MethodAttributes.
*/
public class MethodSpec {
/**
* pattern for property name. Must contain one or more regular expression groups, one of which will be
* regarded as the property. Will be matched against the candidate method's name.
*/
String propertyPattern;
/** Group number which identifies which regex group contains the pattern. */
int propertyGroup;
/** true if first letter of property should be lowercased. */
boolean lowercaseFirstLetterOfProperty;
/** if true, the property name must match a field in the class, else the method will not match. */
boolean propertyMustMatchField;
/**
* pattern of method body (excluding comments and newline characters). Substitutions will be performed
* in this pattern before matching against the method's body as follows:
* <pre>
* %PATTERN% this method's pattern
* %TYPE% this method's type
* %PARAMNAME<n>% name of parameter <n>, <n> = 1, 2, 3, ...
* $PARAMTYPE<n>% type of parameter <n>, <n> = 1, 2, 3, ...
* $PARENT% parent's property
* </pre>
*/
String body;
/** true if body matching should be done against method body stripped of comments. */
boolean ignoreComments;
/**
* value of "parent property", which is the property of the field or method executing this rule.
* If this is the top level rule (not being called by another rule to associate methods matching this
* rule with the parent), then there is no parent property.
*/
final String parentProperty;
public MethodSpec(String parentProperty) {
this.parentProperty = parentProperty;
}
public String getPropertyPattern() {
return propertyPattern;
}
public void setPropertyPattern(String propertyPattern) {
this.propertyPattern = propertyPattern;
}
public int getPropertyGroup() {
return propertyGroup;
}
public void setPropertyGroup(int propertyGroup) {
this.propertyGroup = propertyGroup;
}
public boolean isLowercaseFirstLetterOfProperty() {
return lowercaseFirstLetterOfProperty;
}
public void setLowercaseFirstLetterOfProperty(boolean lowercaseFirstLetterOfProperty) {
this.lowercaseFirstLetterOfProperty = lowercaseFirstLetterOfProperty;
}
public boolean isPropertyMustMatchField() {
return propertyMustMatchField;
}
public void setPropertyMustMatchField(boolean propertyMustMatchField) {
this.propertyMustMatchField = propertyMustMatchField;
}
public String getBody() {
return body;
}
public void setBody(String body) {
this.body = body;
}
public boolean isIgnoreComments() {
return ignoreComments;
}
public void setIgnoreComments(boolean ignoreComments) {
this.ignoreComments = ignoreComments;
}
boolean isMatch() {
return false; // todo
}
private JFormattedTextField getIntField(int initialValue) {
final NumberFormat integerInstance = NumberFormat.getIntegerInstance();
integerInstance.setMaximumIntegerDigits(2);
integerInstance.setMinimumIntegerDigits(1);
final JFormattedTextField intField = new JFormattedTextField(integerInstance);
intField.setValue(new Integer("88"));
final Dimension d = intField.getPreferredSize();
d.width += 3;
intField.setPreferredSize(d);
intField.setValue(initialValue);
intField.setFocusLostBehavior(JFormattedTextField.COMMIT_OR_REVERT);
return intField;
}
public JPanel getPanel() {
JPanel panel = new JPanel(new GridBagLayout());
Constraints constraints = new Constraints();
constraints.insets = new Insets(3, 3, 3, 3);
JLabel propertyPatternLabel = new JLabel("Property pattern:");
propertyPatternLabel.setToolTipText("Regex pattern which method name must match; " +
"parenthesize portion which will be regarded as the method's property" +
", e.g. \"(get|is|has)([A-Z]\\w*)\"");
panel.add(propertyPatternLabel, constraints.firstCol());
constraints.fill = GridBagConstraints.HORIZONTAL;
final JTextField propertyPatternField = new JTextField(this.propertyPattern);
propertyPatternField.getDocument().addDocumentListener(
new DocumentAdapter() {
protected void textChanged(DocumentEvent event) {
propertyPattern = propertyPatternField.getText();
}
}
);
panel.add(propertyPatternField, constraints.weightedLastCol(0.5));
constraints.newRow();
constraints.fill = GridBagConstraints.NONE;
final JLabel propertyGroupLabel = new JLabel("Property group number:");
propertyGroupLabel.setToolTipText("Regular expression parenthesized group corresponding to the property name");
panel.add(propertyGroupLabel, constraints.firstCol());
final JFormattedTextField propertyGroupField = getIntField(propertyGroup);
panel.add(propertyGroupField, constraints.nextCol());
constraints.newRow();
JCheckBox lowerCase = new JCheckBox("Lowercase first letter of property");
lowerCase.setToolTipText("If selected, lower cases the first letter of the property found in the regular expression");
panel.add(lowerCase, constraints.lastCol());
constraints.newRow();
JCheckBox mustMatch = new JCheckBox("Property must match field name");
mustMatch.setToolTipText("If selected, the property name derived from the regular expression must match the " +
"name of a field in the same class as the method; if no such field exists, the " +
"method will not match the rule");
panel.add(mustMatch, constraints.lastCol());
// propertyGroupField.get
constraints.newRow();
JLabel bodyLabel = new JLabel("Body:");
bodyLabel.setToolTipText("Regex pattern for method body (excluding comments);\n" +
"use \"%FN%\" for field name, \"%P1%\" for param 1, etc.");
constraints.fill = GridBagConstraints.NONE;
panel.add(bodyLabel, constraints.firstCol());
JCheckBox stripComments = new JCheckBox("Strip comments");
stripComments.setToolTipText("If selected, comments will be stripped from the method body before attempting" +
" to match the supplied expression");
panel.add(stripComments, constraints.lastCol());
constraints.weightedLastRow();
constraints.fill = GridBagConstraints.BOTH;
JTextArea body = new JTextArea(4, 40);
JScrollPane sp = new JScrollPane(body);
panel.add(sp, constraints.weightedLastCol());
return panel;
}
public MethodSpec deepcopy() {
MethodSpec result = new MethodSpec(parentProperty);
result.body = body;
result.ignoreComments = ignoreComments;
result.lowercaseFirstLetterOfProperty = lowercaseFirstLetterOfProperty;
result.propertyGroup = propertyGroup;
result.propertyMustMatchField = propertyMustMatchField;
result.propertyPattern = propertyPattern;
result.body = body;
return result;
}
public static void main(String[] args) {
MethodSpec ms = new MethodSpec(null);
final JDialog frame = new JDialog((Frame)null, "SwingApplication");
final GridBagConstraints constraints = new GridBagConstraints();
constraints.anchor = GridBagConstraints.NORTHWEST;
constraints.fill = GridBagConstraints.BOTH;
constraints.weightx = 1.0d;
constraints.weighty = 1.0d;
constraints.gridwidth = GridBagConstraints.REMAINDER;
constraints.gridx = 0;
constraints.gridy = 0;
frame.getContentPane().setLayout(new GridBagLayout());
frame.getContentPane().add(ms.getPanel(), constraints);
//Finish setting up the frame, and show it.
frame.pack();
frame.setResizable(true);
frame.setModal(true);
frame.setVisible(true);
}
}
plugins/rearranger/src/com/wrq/rearranger/configuration/RearrangerSettingsPanel.java
-566
View File
@@ -1,566 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.configuration;
import com.wrq.rearranger.Rearranger;
import com.wrq.rearranger.settings.CommentRule;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.settings.attributeGroups.AttributeGroup;
import com.wrq.rearranger.settings.attributeGroups.RegexUtil;
import com.wrq.rearranger.util.CommentUtil;
import com.wrq.rearranger.util.Constraints;
import javax.swing.*;
import javax.swing.border.Border;
import javax.swing.border.TitledBorder;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.PatternSyntaxException;
/** Code for top level configuration panel. */
public final class RearrangerSettingsPanel
extends JPanel
{
// ------------------------------ FIELDS ------------------------------
public RearrangerSettings settings;
// --------------------------- CONSTRUCTORS ---------------------------
// ---------- START Level 1 ----------
public RearrangerSettingsPanel(final RearrangerSettings externalSettings) {
RearrangerSettings settings = externalSettings.deepCopy();
setLayout(new GridBagLayout());
createSettingsPanel(settings);
}
// ---------- START Level 2 ----------
private void createSettingsPanel(RearrangerSettings settings) {
this.settings = settings;
final Constraints constraints = new Constraints(GridBagConstraints.NORTHWEST);
constraints.fill = GridBagConstraints.BOTH;
constraints.weightedLastRow();
while (getComponents().length > 0) {
remove(0);
}
add(getSettingsPanel(), constraints.weightedLastCol());
validate();
}
// ---------- START Level 3 ----------
private JPanel getSettingsPanel() {
final JPanel containerPanel = new JPanel(new GridBagLayout());
final Constraints constraints = new Constraints(GridBagConstraints.NORTHWEST);
constraints.fill = GridBagConstraints.BOTH;
constraints.weightedLastRow();
final JTabbedPane pane = new JTabbedPane();
final SettingsPane classMemberSettingsPane = new ClassMemberSettingsPane(settings);
final SettingsPane classOrderSettingsPane = new ClassOrderSettingsPane(settings);
final SpacingPane spacingPane = new SpacingPane(settings);
final ExtractedMethodsPane extractedMethodsSettings = new ExtractedMethodsPane();
final JPanel generalSettingsPane = getGeneralSettingsPane();
final RelatedByNamePane rbnp = new RelatedByNamePane(settings.getExtractedMethodsSettings().getRbnms());
pane.addTab(
"Class Member Order",
null,
classMemberSettingsPane.getPane(),
"Options controlling arrangement of fields, methods and inner classes"
);
pane.addTab(
"Outer Class Order",
null,
classOrderSettingsPane.getPane(),
"Options controlling arrangement of outer classes"
);
pane.addTab(
"Extracted Methods",
null,
extractedMethodsSettings.getExtractedMethodsPane(settings.getExtractedMethodsSettings()),
"Options controlling arrangement of extracted methods"
);
pane.addTab(
"General",
null,
generalSettingsPane,
"General options"
);
pane.addTab(
"Spacing",
null,
spacingPane.getPane(),
"Options controlling number of blank lines before and after braces"
);
pane.addTab(
"Configuration",
null,
getConfigurationPane(),
"Load, save, clear configuration, or set to default"
);
// pane.addTab("Related By Name", null, // todo - add when ready; replace "Extracted Methods" pane above
// rbnp.getPane(), "Global definitions for methods related by name (\"getters/setters\")");
pane.setSelectedIndex(0);
containerPanel.add(pane, constraints.weightedLastCol());
return containerPanel;
}
// ---------- START Level 4 ----------
private JPanel getGeneralSettingsPane() {
final JPanel gsPanel = new JPanel(new GridBagLayout());
final Border border = BorderFactory.createEtchedBorder();
gsPanel.setBorder(border);
final GridBagConstraints constraints = new GridBagConstraints();
constraints.fill = GridBagConstraints.BOTH;
constraints.anchor = GridBagConstraints.NORTHWEST;
constraints.gridwidth = 1;
constraints.gridheight = 1;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.gridx = constraints.gridy = 0;
constraints.insets = new Insets(5, 5, 0, 0);
final JCheckBox getterSetterBox = new JCheckBox("Keep getters/setters together");
getterSetterBox.setSelected(settings.isKeepGettersSettersTogether());
final JCheckBox gettersSettersWithPropertyBox = new JCheckBox("Keep getters/setters with property");
gettersSettersWithPropertyBox.setSelected(settings.isKeepGettersSettersWithProperty());
gettersSettersWithPropertyBox.setEnabled(settings.isKeepGettersSettersTogether());
final JCheckBox overloadedMethodsBox = new JCheckBox("Keep overloaded methods/constructors together");
overloadedMethodsBox.setSelected(settings.isKeepOverloadedMethodsTogether());
final JLabel overloadOrderLabel = new JLabel("Ordering of constructors and overloaded methods:");
final JComboBox overloadOrderBox = new JComboBox(
new String[]{
"Retain original order",
"Order by number of parameters (ascending)",
"Order by number of parameters (descending)"
}
);
overloadOrderLabel.setEnabled(settings.isKeepOverloadedMethodsTogether());
overloadOrderBox.setEnabled(settings.isKeepOverloadedMethodsTogether());
overloadOrderBox.setSelectedIndex(settings.getOverloadedOrder());
overloadedMethodsBox.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
settings.setKeepOverloadedMethodsTogether(overloadedMethodsBox.isSelected());
overloadOrderLabel.setEnabled(settings.isKeepOverloadedMethodsTogether());
overloadOrderBox.setEnabled(settings.isKeepOverloadedMethodsTogether());
}
}
);
final JCheckBox confirmBox = new JCheckBox("Confirm before rearranging");
confirmBox.setSelected(settings.isAskBeforeRearranging());
confirmBox.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
settings.setAskBeforeRearranging(confirmBox.isSelected());
}
}
);
final JCheckBox rearrangeInnerClasses = new JCheckBox("Rearrange contents of inner classes");
rearrangeInnerClasses.setSelected(settings.isRearrangeInnerClasses());
rearrangeInnerClasses.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
settings.setRearrangeInnerClasses(rearrangeInnerClasses.isSelected());
}
});
gsPanel.add(getterSetterBox, constraints);
constraints.gridy++;
gsPanel.add(gettersSettersWithPropertyBox, constraints);
constraints.gridy++;
// constraints.insets = new Insets(0, 0, 0, 0);
gsPanel.add(overloadedMethodsBox, constraints);
constraints.gridy++;
constraints.insets = new Insets(0, 30, 3, 0);
gsPanel.add(overloadOrderLabel, constraints);
constraints.gridy++;
constraints.insets = new Insets(0, 30, 10, 0);
constraints.fill = GridBagConstraints.NONE;
gsPanel.add(overloadOrderBox, constraints);
constraints.fill = GridBagConstraints.BOTH;
constraints.gridy++;
constraints.insets = new Insets(5, 5, 0, 0);
gsPanel.add(confirmBox, constraints);
constraints.gridy++;
gsPanel.add(rearrangeInnerClasses, constraints);
constraints.gridy++;
//
constraints.gridwidth = GridBagConstraints.REMAINDER;
constraints.anchor = GridBagConstraints.NORTHWEST;
constraints.fill = GridBagConstraints.BOTH;
constraints.weightx = 1.0d;
constraints.weighty = 0.0d;
final JPanel gsDefaultPane = settings.getDefaultGSDefinition().getGSDefinitionPanel();
constraints.insets = new Insets(5, 5, 0, 5);
constraints.gridx = 1;
int oldGridy = constraints.gridy;
constraints.gridheight = constraints.gridy;
constraints.gridy = 0;
Border b = gsDefaultPane.getBorder();
TitledBorder tb = BorderFactory.createTitledBorder(b, "Default Getter/Setter Definition");
gsDefaultPane.setBorder(tb);
gsPanel.add(gsDefaultPane, constraints);
constraints.gridy = oldGridy;
//
constraints.gridx = 0;
constraints.gridwidth = 1;
constraints.gridheight = 1;
constraints.gridy++;
constraints.weightx = 0; // was 1
constraints.insets = new Insets(5, 5, 0, 0);
final JLabel commentLabel = new JLabel("Comment pattern:");
final JButton createPatternButton = new JButton("Generate pattern");
final JButton verifyCommentsButton = new JButton("Verify comments against pattern");
gsPanel.add(commentLabel, constraints);
constraints.gridx++;
constraints.anchor = GridBagConstraints.NORTH;
gsPanel.add(createPatternButton, constraints);
constraints.anchor = GridBagConstraints.NORTHEAST;
constraints.gridx++;
constraints.gridwidth = GridBagConstraints.REMAINDER;
constraints.weightx = 1; // was 0
constraints.insets = new Insets(5, 0, 0, 5);
constraints.fill = GridBagConstraints.NONE; // new line
gsPanel.add(verifyCommentsButton, constraints);
constraints.fill = GridBagConstraints.BOTH;
constraints.gridx = 0;
constraints.anchor = GridBagConstraints.NORTHWEST;
constraints.insets = new Insets(5, 5, 5, 5);
constraints.gridy++;
constraints.weighty = 1.0d;
constraints.gridheight = GridBagConstraints.REMAINDER;
final JTextArea commentArea = new JTextArea(4, 40);
commentArea.setText(settings.getGlobalCommentPattern());
constraints.gridheight = GridBagConstraints.REMAINDER;
final JScrollPane scrollPane = new JScrollPane(commentArea);
scrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
scrollPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
gsPanel.add(scrollPane, constraints);
getterSetterBox.addActionListener(
new ActionListener() {
public void actionPerformed(final ActionEvent e) {
settings.setKeepGettersSettersTogether(getterSetterBox.isSelected());
gettersSettersWithPropertyBox.setEnabled(settings.isKeepGettersSettersTogether());
}
}
);
gettersSettersWithPropertyBox.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
settings.setKeepGettersSettersWithProperty(gettersSettersWithPropertyBox.isSelected());
}
});
overloadOrderBox.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
settings.setOverloadedOrder(overloadOrderBox.getSelectedIndex());
}
}
);
commentArea.getDocument().addDocumentListener(
new DocumentListener() {
public void changedUpdate(final DocumentEvent e) {
settings.setGlobalCommentPattern(commentArea.getText());
}
public void insertUpdate(final DocumentEvent e) {
settings.setGlobalCommentPattern(commentArea.getText());
}
public void removeUpdate(final DocumentEvent e) {
settings.setGlobalCommentPattern(commentArea.getText());
}
}
);
createPatternButton.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
String t = commentArea.getText();
if (t.length() > 0) {
int result = JOptionPane.showConfirmDialog(
null, "This will replace the existing comment pattern with the generated pattern." +
" Are you sure?",
"Replace existing pattern",
JOptionPane.YES_NO_CANCEL_OPTION
);
if (result != 0) return;
}
String s = generateCommentPattern(settings);
commentArea.setText(s);
}
}
);
verifyCommentsButton.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
checkCommentsAgainstGlobalPattern(settings);
}
}
);
return gsPanel;
}
// ---------- START Level 5 ----------
private String generateCommentPattern(RearrangerSettings settings) {
new CommentUtil(settings);
String result = RegexUtil.combineExpressions(CommentUtil.getCommentStrings());
return result;
}
/**
* Compare all comments specified by the user against the global comment pattern. If all match, then
* the global pattern will catch all the user's comments and remove them before rearranging and inserting
* new ones. If any don't match, bring up a dialog box listing them.
*
* @param settings current Rearranger settings.
*/
public void checkCommentsAgainstGlobalPattern(RearrangerSettings settings) {
String pattern = settings.getGlobalCommentPattern();
if (pattern == null || pattern.trim().length() == 0) {
JOptionPane.showMessageDialog(
null, "No global comment pattern exists!"
, "Verify Comments Against Pattern",
JOptionPane.WARNING_MESSAGE
);
return;
}
try {
" ".matches(pattern);
}
catch (PatternSyntaxException pse) {
JOptionPane.showMessageDialog(
null,
"Invalid global pattern:" + pse.toString(),
"Verify Comments Against Pattern",
JOptionPane.ERROR_MESSAGE
);
return;
}
int nCommentsSeen = 0;
List<String> mismatches = new ArrayList<String>();
// first check all rules in the class order settings panes.
nCommentsSeen =
checkAttributeListForErrors(settings.getClassOrderAttributeList(), nCommentsSeen, pattern, mismatches);
// now check all the class member attributes.
nCommentsSeen =
checkAttributeListForErrors(settings.getItemOrderAttributeList(), nCommentsSeen, pattern, mismatches);
// now check all comments for extracted methods. Expand keywords to make the match realistic.
CommentRule rule = settings.getExtractedMethodsSettings().getPrecedingComment();
String preceding = rule.getCommentText();
if (preceding != null && preceding.trim().length() > 0) {
nCommentsSeen++;
checkExtractedComment(rule, "Preceding", pattern, mismatches);
}
rule = settings.getExtractedMethodsSettings().getTrailingComment();
String trailing = rule.getCommentText();
if (preceding != null && preceding.trim().length() > 0) {
nCommentsSeen++;
checkExtractedComment(rule, "Trailing", pattern, mismatches);
}
/**
* if any strings mismatch, display a dialog showing them; otherwise display a dialog indicating that
* everything is ok.
*/
if (nCommentsSeen == 0) {
JOptionPane.showMessageDialog(
null, "No user-defined comments have been configured"
, "Verify Comments Against Pattern",
JOptionPane.PLAIN_MESSAGE
);
}
else if (mismatches.size() == 0) {
JOptionPane.showMessageDialog(
null,
nCommentsSeen +
" user-defined comments seen; " +
"all match the global comment pattern",
"Verify Comments Against Pattern",
JOptionPane.PLAIN_MESSAGE
);
}
else {
mismatches.add(0, nCommentsSeen + " user-defined comments seen; following comments did not match:");
JOptionPane.showMessageDialog(
null, mismatches.toArray(),
"Verify Comments Against Pattern", JOptionPane.WARNING_MESSAGE
);
}
}
// ---------- START Level 6 ----------
private int checkAttributeListForErrors(List<AttributeGroup> list,
int nCommentsSeen,
String pattern,
List<String> mismatches)
{
int index = 0;
for (AttributeGroup group : list) {
index++;
nCommentsSeen += group.getCommentCount();
if (!group.commentsMatchGlobalPattern(pattern)) {
List badComments = group.getOffendingPatterns(pattern);
for (Object badComment : badComments) {
mismatches.add("Class Member item #" + index + ": \"" + badComment + "\"");
}
}
}
return nCommentsSeen;
}
private void checkExtractedComment(final CommentRule commentRule,
final String which,
String pattern,
List<String> mismatches)
{
String comment = commentRule.getCommentText();
if (comment.length() == 0) return;
// make some 'typical' substitutions for wildcard expansion to check against pattern.
// hand-expand the %FS% (fill string) because the fill string could contain special characters that
// replaceAll interprets and changes.
String expanded = comment.replaceAll("%LV%", "12");
expanded = expanded.replaceAll("%TL%", "topLevelMethod()");
expanded = expanded.replaceAll("%MN%", "methodName()");
expanded = expanded.replaceAll("%AM%", "method1().[method1A(),method1B()]");
expanded = expanded.replaceAll("%IF%", "Interface_ExampleName0");
expanded = RegexUtil.replaceAllFS(expanded, commentRule.getCommentFillString().getFillString());
if (!expanded.matches(pattern)) {
mismatches.add(which + " comment for extracted methods: \"" + comment + "\"");
}
}
// ---------- END Level 6 ----------
// ---------- END Level 5 ----------
private JPanel getConfigurationPane() {
final JPanel gcPanel = new JPanel(new GridBagLayout());
Constraints constraints = new Constraints(GridBagConstraints.NORTHWEST);
constraints.fill = GridBagConstraints.HORIZONTAL;
constraints.insets = new Insets(5, 5, 0, 5);
final JButton clearConfig = new JButton("Clear configuration");
final JButton loadDefaultConfig = new JButton("Load default configuration");
final JButton readConfig = new JButton("Read configuration from file...");
final JButton writeConfig = new JButton("Write configuration to file...");
clearConfig.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
createSettingsPanel(new RearrangerSettings());
}
});
loadDefaultConfig.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
RearrangerSettings defaultSettings = RearrangerSettings.getDefaultSettings();
if (defaultSettings == null) {
JOptionPane.showMessageDialog(null, "Could not obtain default configuration.",
"No default configuration available", JOptionPane.WARNING_MESSAGE);
}
else {
createSettingsPanel(defaultSettings);
}
}
});
readConfig.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
JFileChooser fc = new JFileChooser();
int returnVal = fc.showOpenDialog(null);
if (returnVal == JFileChooser.APPROVE_OPTION) {
File file = fc.getSelectedFile();
RearrangerSettings fileSettings = RearrangerSettings.getSettingsFromFile(file);
if (fileSettings == null) {
JOptionPane.showMessageDialog(null, "Could not read configuration.",
"File or file contents invalid", JOptionPane.WARNING_MESSAGE);
}
else {
createSettingsPanel(fileSettings);
}
}
}
});
writeConfig.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
JFileChooser fc = new JFileChooser();
int returnVal = fc.showSaveDialog(null);
if (returnVal == JFileChooser.APPROVE_OPTION) {
File file = fc.getSelectedFile();
settings.writeSettingsToFile(file);
}
}
});
gcPanel.add(clearConfig, constraints.weightedLastCol());
constraints.newRow();
gcPanel.add(loadDefaultConfig, constraints.weightedLastCol());
constraints.newRow();
gcPanel.add(readConfig, constraints.weightedLastCol());
constraints.newRow();
gcPanel.add(writeConfig, constraints.weightedLastCol());
// now create outer panel so that buttons aren't stretched across creation.
JPanel outerPanel = new JPanel(new GridBagLayout());
constraints = new Constraints(GridBagConstraints.NORTHWEST);
constraints.weightedLastRow();
outerPanel.add(gcPanel, constraints.weightedLastCol());
JPanel extraPanel = new JPanel(new GridBagLayout());
final Border border = BorderFactory.createEtchedBorder();
extraPanel.setBorder(border);
constraints = new Constraints(GridBagConstraints.SOUTHEAST);
extraPanel.add(outerPanel, constraints.firstCol());
constraints.weightedNewRow();
constraints.firstCol(); // skip first column
extraPanel.add(new JLabel(), constraints.weightedNextCol());
constraints.lastRow();
constraints.firstCol(); // skip first column
constraints.nextCol(); // skip second column
constraints.weightx = constraints.weighty = 0;
constraints.insets = new Insets(5, 5, 5, 5);
JLabel version = new JLabel("Rearranger plugin, version " + Rearranger.VERSION);
extraPanel.add(version, constraints.lastCol());
return extraPanel;
}
// --------------------------- main() method ---------------------------
// ---------- END Level 4 ----------
// ---------- END Level 3 ----------
// ---------- END Level 2 ----------
// ---------- END Level 1 ----------
}
plugins/rearranger/src/com/wrq/rearranger/configuration/RelatedByNamePane.java
-217
View File
@@ -1,217 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.configuration;
import com.wrq.rearranger.settings.PrimaryMethodSetting;
import com.wrq.rearranger.settings.RelatedByNameMethodsSettings;
import javax.swing.*;
import java.util.List;
/** Configuration settings for handling ordering of extracted methods. */
public class RelatedByNamePane {
RelatedByNameMethodsSettings rbnms;
public RelatedByNamePane(RelatedByNameMethodsSettings rbnms) {
this.rbnms = rbnms;
}
public final JPanel getPane() {
IListManagerObjectFactory lmof = new IListManagerObjectFactory() {
public IListManagerObject create(String name) {
PrimaryMethodSetting pms = new PrimaryMethodSetting();
pms.setDescription(name);
return pms;
}
public List getObjectList() {
return rbnms.getMethodList();
}
};
ListManager result = new ListManager(lmof, "Primary method name:");
// constraints = new GridBagConstraints();
// constraints.anchor = GridBagConstraints.NORTHWEST;
// constraints.fill = GridBagConstraints.NONE;
// constraints.gridwidth = 1;
// constraints.gridheight = 1;
// constraints.weightx = 0.0d;
// constraints.weighty = 0.0d;
// constraints.gridy = constraints.gridx = 0;
// constraints.insets = new Insets(3, 3, 3, 3);
// addButton.setBorderPainted(false);
// removeButton.setBorderPainted(false);
// copyButton.setBorderPainted(false);
// containerPanel.add(addButton, constraints);
// constraints.gridx++;
// containerPanel.add(removeButton, constraints);
// constraints.gridx++;
// containerPanel.add(copyButton, constraints);
// constraints.gridx++;
// containerPanel.add(nameLabel, constraints);
// constraints.gridx++;
// constraints.gridwidth = GridBagConstraints.REMAINDER;
// constraints.weightx = 1;
// constraints.fill = GridBagConstraints.HORIZONTAL;
// containerPanel.add(name, constraints);
// /**
// * declare callback handlers for buttons.
// */
// addButton.addActionListener(new ActionListener()
// {
// public void actionPerformed(ActionEvent e)
// {
// PrimaryMethodSetting pms = new PrimaryMethodSetting();
// pms.setName("unnamed");
// ((DefaultListModel)rbnmlist.getModel()).addElement(pms);
// rbnmlist.setSelectedIndex(rbnmlist.getModel().getSize() - 1);
// updateListSelection();
// }
// });
// removeButton.addActionListener(new ActionListener()
// {
// public void actionPerformed(ActionEvent e)
// {
// DefaultListModel dlm = ((DefaultListModel)rbnmlist.getModel());
// int selectedIndex = rbnmlist.getSelectedIndex();
// PrimaryMethodSetting pms = (PrimaryMethodSetting) dlm.getElementAt(selectedIndex);
// rbnms.getMethodList().remove(pms);
// dlm.remove(selectedIndex);
// if (selectedIndex >= dlm.getSize()) {
// selectedIndex = dlm.getSize() - 1;
// }
// rbnmlist.setSelectedIndex(selectedIndex);
// updateListSelection();
// }
// });
// copyButton.addActionListener(new ActionListener()
// {
// public void actionPerformed(ActionEvent e)
// {
// DefaultListModel dlm = ((DefaultListModel)rbnmlist.getModel());
// int selectedIndex = rbnmlist.getSelectedIndex();
// PrimaryMethodSetting pms = (PrimaryMethodSetting) dlm.getElementAt(selectedIndex);
// dlm.addElement(pms.deepcopy());
// rbnmlist.setSelectedIndex(rbnmlist.getModel().getSize() - 1);
// updateListSelection();
// }
// });
// rbnmlist.getSelectionModel().setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
// addButton.setEnabled(true);
// name.getDocument().addDocumentListener(new DocumentListener()
// {
// private void updateList()
// {
// String newText = name.getText();
// final PrimaryMethodSetting primaryMethodSetting = (PrimaryMethodSetting)rbnmlist.getSelectedValue();
// primaryMethodSetting.setName(newText);
// int index = rbnmlist.getSelectedIndex();
// DefaultListModel dlm = ((DefaultListModel)rbnmlist.getModel());
// dlm.remove(index);
// dlm.add(index, primaryMethodSetting);
// rbnmlist.setSelectedIndex(index);
// }
// public void changedUpdate(DocumentEvent e)
// {
// updateList();
// }
//
// public void insertUpdate(DocumentEvent e)
// {
// updateList();
// }
//
// public void removeUpdate(DocumentEvent e)
// {
// updateList();
// }
// });
// JScrollPane scrollPane = new JScrollPane(rbnmlist);
// scrollPane.setPreferredSize(new Dimension(80, 300));
// ListIterator li = rbnms.getMethodList().listIterator();
// while (li.hasNext())
// {
// PrimaryMethodSetting pms = (PrimaryMethodSetting) li.next();
// ((DefaultListModel)rbnmlist.getModel()).addElement(pms);
// }
// rbnmlist.setSelectedIndex(rbnmlist.getModel().getSize() - 1);
// constraints.gridheight = GridBagConstraints.REMAINDER;
// constraints.gridx = 0;
// constraints.gridy++;
// constraints.gridwidth = 3;
// constraints.weightx = .2;
// constraints.weighty = 1;
// constraints.fill = GridBagConstraints.BOTH;
// containerPanel.add(scrollPane, constraints);
// constraints.gridx += 3;
// constraints.gridwidth = GridBagConstraints.REMAINDER;
// constraints.fill = GridBagConstraints.BOTH;
// constraints.weightx = .8;
// containerPanel.add(getPrimaryMethodPanel(), constraints);
// updateListSelection();
return result.getPane();
}
/**
* Enable add/remove/copy buttons and fill in name of selected list item. Called whenever
* the list selection changes.
*/
// private void updateListSelection()
// {
// if (rbnmlist.getModel().getSize() > 0)
// {
// rbnmlist.setSelectedIndex(0);
// name.setEnabled(true);
// nameLabel.setEnabled(true);
// name.setText(((PrimaryMethodSetting) rbnmlist.getSelectedValue()).getName());
// removeButton.setEnabled(true);
// copyButton.setEnabled(true);
// }
// else
// {
// name.setEnabled(false);
// nameLabel.setEnabled(false);
// removeButton.setEnabled(false);
// copyButton.setEnabled(false);
// name.setText("");
// }
// containerPanel.remove(containerPanel.getComponentCount() - 1);
// containerPanel.add(getPrimaryMethodPanel(), constraints);
// containerPanel.validate();
// }
/**
* Get a primary method panel based on values for the currently selected primary item.
* @return
*/
// private JPanel getPrimaryMethodPanel()
// {
// PrimaryMethodSetting pms = (PrimaryMethodSetting) rbnmlist.getSelectedValue();
// if (pms == null) {
// return new JPanel(); // empty
// }
// else {
// return pms.getPanel();
// }
// }
// ---------- START Level 4 ----------
}
plugins/rearranger/src/com/wrq/rearranger/configuration/SettingsPane.java
-549
View File
@@ -1,549 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.configuration;
import com.intellij.ui.DoubleClickListener;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.settings.attributeGroups.AttributeGroup;
import com.wrq.rearranger.settings.attributeGroups.PrioritizedRule;
import com.wrq.rearranger.settings.attributeGroups.Rule;
import com.wrq.rearranger.util.Constraints;
import javax.swing.*;
import javax.swing.border.Border;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.table.*;
import java.awt.*;
import java.awt.event.*;
import java.util.ArrayList;
import java.util.List;
/** Code common to dialog managing creation and maintenance of a list of rules. */
public abstract class SettingsPane {
// ------------------------------ FIELDS ------------------------------
public static final int SEQUENCE_COLUMN = 0;
public static final int PRIORITY_COLUMN = 1;
public static final int DESCRIPTION_COLUMN = 2;
public static final int NUM_COLUMNS = 3;
protected final RearrangerSettings settings;
private final List<AttributeGroup> list;
private List<ChoicePanel> modelData;
private JTable jTable;
private AbstractTableModel model;
private JPanel pane;
// --------------------------- CONSTRUCTORS ---------------------------
SettingsPane(final RearrangerSettings settings, List<AttributeGroup> list) {
this.settings = settings;
this.list = list;
modelData = new ArrayList<ChoicePanel>(list.size());
createConfigurationPane();
}
private void createConfigurationPane() {
pane = new JPanel(new GridBagLayout());
final Border border = BorderFactory.createEmptyBorder();
pane.setBorder(border);
final Constraints constraints = new Constraints(GridBagConstraints.NORTHWEST);
constraints.weightedNewRow();
constraints.fill = GridBagConstraints.BOTH;
constraints.insets = new Insets(10, 10, 10, 10);
pane.add(createScrollableTablePanel(), constraints.weightedFirstCol());
pane.add(createAddRemovePanel(), constraints.nextCol());
}
private JPanel createScrollableTablePanel() {
final JPanel cmlPanel = new JPanel(new GridBagLayout());
final Constraints constraints = new Constraints(GridBagConstraints.NORTHWEST);
constraints.weightedLastRow();
constraints.fill = GridBagConstraints.BOTH;
final JTextField priorityField = new JTextField();
priorityField.setHorizontalAlignment(JTextField.RIGHT);
TableCellEditor priorityEditor = new DefaultCellEditor(priorityField);
model = new AbstractTableModel() {
public int getColumnCount() {
return NUM_COLUMNS; // sequence, priority, rule description
}
public int getRowCount() {
return list.size();
}
public Object getValueAt(int rowIndex, int columnIndex) {
switch (columnIndex) {
case SEQUENCE_COLUMN:
return rowIndex + 1;
case PRIORITY_COLUMN:
ChoicePanel cp = (modelData.get(rowIndex));
Rule rule = cp.getChoice().getChoiceObject();
return new Priority(rule.getPriority());
case DESCRIPTION_COLUMN:
return list.get(rowIndex).toString();
}
return null;
}
public String getColumnName(int column) {
switch (column) {
case SEQUENCE_COLUMN:
return "Seq";
case PRIORITY_COLUMN:
return "Pri";
case DESCRIPTION_COLUMN:
return "Rule";
}
return null;
}
public Class getColumnClass(int columnIndex) {
switch (columnIndex) {
case SEQUENCE_COLUMN:
return Integer.class;
case PRIORITY_COLUMN:
return Priority.class;
case DESCRIPTION_COLUMN:
return String.class;
}
return Object.class;
}
public boolean isCellEditable(int rowIndex, int columnIndex) {
if (columnIndex == PRIORITY_COLUMN && rowIndex >= 0) {
ChoicePanel cp = (modelData.get(rowIndex));
Rule rule = cp.getChoice().getChoiceObject();
if (rule instanceof PrioritizedRule) {
return true;
}
}
return false;
}
public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
if (columnIndex == PRIORITY_COLUMN) {
ChoicePanel cp = (modelData.get(rowIndex));
Rule rule = cp.getChoice().getChoiceObject();
if (rule instanceof PrioritizedRule) {
int priority;
try {
priority = (new Integer((String)aValue));
}
catch (NumberFormatException nfe) {
return;
}
if (priority > 0 && priority < 100) {
rule.setPriority(priority);
fireTableCellUpdated(rowIndex, columnIndex);
}
}
}
}
};
TableCellRenderer priorityRenderer = new DefaultTableCellRenderer() {
protected void setValue(Object value) {
Priority p = (Priority)value;
if (p.priority <= 0) {
setText("n/a");
setHorizontalAlignment(JLabel.CENTER);
}
else {
setText("" + p.priority + " ");
setHorizontalAlignment(JLabel.RIGHT);
}
}
};
TableSorter sorter = new TableSorter(model) {
public void sortByColumn(int column, boolean ascending) {
if (column == SEQUENCE_COLUMN ||
column == PRIORITY_COLUMN)
{
super.sortByColumn(column, ascending);
}
}
public boolean defaultSortOrderAscending(int column) {
switch (column) {
case SEQUENCE_COLUMN:
return true;
case PRIORITY_COLUMN:
return false;
}
return true;
}
};
jTable = new JTable(sorter);
sorter.addMouseListenerToHeaderInTable(jTable);
jTable.setShowHorizontalLines(false);
jTable.setShowVerticalLines(true);
jTable.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
jTable.setDragEnabled(false);
jTable.setRowSelectionAllowed(true);
jTable.setColumnSelectionAllowed(false);
jTable.setPreferredScrollableViewportSize(jTable.getPreferredSize());
jTable.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
TableColumnModel tcm = jTable.getColumnModel();
tcm.getColumn(0).setPreferredWidth(new JLabel("SEQ").getWidth() * 3);
tcm.getColumn(1).setPreferredWidth(new JLabel("MMM").getWidth() * 3);
tcm.getColumn(1).setCellRenderer(priorityRenderer);
tcm.getColumn(1).setCellEditor(priorityEditor);
final JScrollPane scrollPane = new JScrollPane(jTable);
for (AttributeGroup ca : list) {
modelData.add(createOptionsPaneMsg(ca));
}
if (list.size() > 0) {
jTable.getSelectionModel().setSelectionInterval(0, 0);
}
cmlPanel.add(scrollPane, constraints.weightedLastCol());
setTableColumnWidths();
return cmlPanel;
}
/**
* @param ca FieldAttributes, MethodAttributes, InnerClassAttributes, or CommentRule object
* @return ItemPanel corresponding to the value of param.
*/
private ChoicePanel createOptionsPaneMsg(final AttributeGroup ca) {
final ChoicePanel result = createChoicePanel();
for (int i = 0; i < result.getChoices().length; i++) {
final AttributeGroup choiceObject = result.getChoices()[i].getChoiceObject();
if (ca.getClass() == choiceObject.getClass()) {
result.setChoice(i);
result.getChoice().choiceObject = ca;
break;
}
}
return result;
}
abstract ChoicePanel createChoicePanel();
private void setTableColumnWidths() {
int columnCount = jTable.getColumnCount();
TableColumnModel tcm = jTable.getColumnModel();
final int SPARE = 24;
for (int i = 0; i < columnCount; i++) {
int width = calculateColumnWidth(i);
width += SPARE;
TableColumn column = tcm.getColumn(i);
column.setMinWidth(width);
if (i < columnCount - 1) {
column.setMaxWidth(width);
}
}
}
private int calculateColumnWidth(int columnIndex) {
int result = 0;
int rowCount = jTable.getRowCount();
for (int i = 0; i < rowCount; i++) {
TableCellRenderer tcr = jTable.getCellRenderer(i, columnIndex);
Component comp = tcr.getTableCellRendererComponent(
jTable,
jTable.getValueAt(i, columnIndex),
true, true, i, columnIndex
);
int compWidth = comp.getPreferredSize().width;
if (compWidth > result) {
result = compWidth;
}
}
TableCellRenderer tcr = jTable.getColumnModel().getColumn(columnIndex).getHeaderRenderer();
if (tcr == null) {
tcr = jTable.getDefaultRenderer(String.class);
}
Component comp = tcr.getTableCellRendererComponent(
jTable,
model.getColumnName(columnIndex), true, true, -1, columnIndex
);
int compWidth = comp.getPreferredSize().width;
if (compWidth > result) {
result = compWidth;
}
if (columnIndex == DESCRIPTION_COLUMN) {
if (result < 400) result = 400;
}
return result;
}
private JPanel createAddRemovePanel() {
final JPanel addRemovePanel = new JPanel(new GridBagLayout());
final Constraints constraints = new Constraints(GridBagConstraints.NORTH);
constraints.fill = GridBagConstraints.HORIZONTAL;
constraints.insets = new Insets(0, 0, 10, 0);
final JButton addButton = new JButton("Add");
final JButton editButton = new JButton("Edit");
final JButton removeButton = new JButton("Remove");
final JButton duplicateButton = new JButton("Duplicate");
final JButton moveUpButton = new JButton("Move up");
final JButton moveDownButton = new JButton("Move down");
addRemovePanel.add(addButton, constraints.firstCol());
constraints.newRow();
addRemovePanel.add(editButton, constraints.firstCol());
constraints.newRow();
addRemovePanel.add(duplicateButton, constraints.firstCol());
constraints.newRow();
addRemovePanel.add(removeButton, constraints.firstCol());
constraints.newRow();
addRemovePanel.add(moveUpButton, constraints.firstCol());
constraints.weightedNewRow();
constraints.insets = new Insets(0, 0, 0, 0);
addRemovePanel.add(moveDownButton, constraints.firstCol());
if (jTable.getSelectedRow() < 0) {
editButton.setEnabled(false);
duplicateButton.setEnabled(false);
removeButton.setEnabled(false);
moveUpButton.setEnabled(false);
moveDownButton.setEnabled(false);
}
if (jTable.getSelectedRow() == 0) {
moveUpButton.setEnabled(false);
}
if (jTable.getSelectedRowCount() > 0 &&
jTable.getSelectedRows()[jTable.getSelectedRowCount() - 1] == jTable.getModel().getRowCount() - 1)
{
moveDownButton.setEnabled(false);
}
jTable.getSelectionModel().addListSelectionListener(
new ListSelectionListener() {
public void valueChanged(final ListSelectionEvent e) {
if (e.getValueIsAdjusting() || (e.getFirstIndex() < 0)) {
return;
}
final int index = jTable.getSelectedRow();
final boolean selectionExists = index >= 0;
editButton.setEnabled(selectionExists);
duplicateButton.setEnabled(selectionExists);
removeButton.setEnabled(selectionExists);
moveUpButton.setEnabled(selectionExists && index > 0);
int lastSelectedRow = 0;
if (selectionExists) {
lastSelectedRow = jTable.getSelectedRows()[jTable.getSelectedRowCount() - 1];
}
moveDownButton.setEnabled(selectionExists &&
lastSelectedRow < jTable.getModel().getRowCount() - 1);
}
}
);
jTable.addKeyListener(new KeyAdapter() {
public void keyPressed(KeyEvent e) {
if (e.getKeyCode() == KeyEvent.VK_ENTER) {
int index = jTable.getSelectedRow();
editRow(addRemovePanel);
jTable.getSelectionModel().setLeadSelectionIndex(index);
}
}
});
addButton.addActionListener(
new ActionListener() {
public void actionPerformed(final ActionEvent e) {
// add new rule after last selected rule
final int currentIndex;
if (jTable.getSelectedRowCount() <= 0) {
currentIndex = 0;
}
else {
currentIndex = jTable.getSelectedRows()[jTable.getSelectedRowCount() - 1] + 1;
}
final ChoicePanel choicePanel = getOptionsPaneMsg(null);
final JOptionPane op = new JOptionPane(
choicePanel,
JOptionPane.PLAIN_MESSAGE,
JOptionPane.OK_CANCEL_OPTION,
null, null, null
);
final JDialog jd = op.createDialog(addRemovePanel, choicePanel.getChoicePanelName());
jd.setVisible(true);
final Object result = op.getValue();
if (result != null &&
((Integer)result) == JOptionPane.OK_OPTION)
{
final ChoicePanel value = (ChoicePanel)op.getMessage();
value.acceptEdited();
modelData.add(currentIndex, value);
list.add(currentIndex, ((com.wrq.rearranger.settings.attributeGroups.AttributeGroup)value.getChoice().getChoiceObject()));
model.fireTableRowsInserted(currentIndex, currentIndex);
jTable.getSelectionModel().setSelectionInterval(currentIndex, currentIndex);
}
setTableColumnWidths();
}
}
);
editButton.addActionListener(
new ActionListener() {
public void actionPerformed(final ActionEvent e) {
editRow(addRemovePanel);
}
}
);
new DoubleClickListener() {
@Override
protected boolean onDoubleClick(MouseEvent e) {
editRow(addRemovePanel);
return true;
}
}.installOn(jTable);
duplicateButton.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
// duplicate all selected rows as a block
AttributeGroup[] newRules = new AttributeGroup[jTable.getSelectedRowCount()];
for (int row = 0; row < jTable.getSelectedRowCount(); row++) {
final int currentIndex = jTable.getSelectedRows()[row];
final ChoicePanel choicePanel = (modelData.get(currentIndex));
AttributeGroup rule = choicePanel.getChoice().getChoiceObject();
AttributeGroup newRule = rule.deepCopy();
newRules[row] = newRule;
}
// now insert the new rows at the correct place
final int offset = jTable.getSelectedRows()[jTable.getSelectedRowCount() - 1] + 1;
for (int row = 0; row < newRules.length; row++) {
final AttributeGroup newRule = newRules[row];
modelData.add(row + offset, createOptionsPaneMsg(newRule));
list.add(row + offset, newRule);
model.fireTableRowsInserted(row + offset, row + offset);
}
}
}
);
removeButton.addActionListener(
new ActionListener() {
public void actionPerformed(final ActionEvent e) {
// remove a block of rules.
final int currentIndex = jTable.getSelectedRow();
if (currentIndex >= 0) {
final int first = jTable.getSelectedRows()[0];
final int last = jTable.getSelectedRows()[jTable.getSelectedRowCount() - 1];
for (int i = first; i <= last; i++) {
list.remove(currentIndex);
modelData.remove(currentIndex);
}
model.fireTableRowsDeleted(currentIndex, currentIndex);
int newSelIndex = (currentIndex >= model.getRowCount())
? model.getRowCount() - 1
: currentIndex;
jTable.getSelectionModel().setSelectionInterval(newSelIndex, newSelIndex);
setTableColumnWidths();
}
}
}
);
moveUpButton.addActionListener(
new ActionListener() {
public void actionPerformed(final ActionEvent e) {
final int first = jTable.getSelectedRows()[0];
if (first <= 0) return;
final int last = jTable.getSelectedRows()[jTable.getSelectedRowCount() - 1];
for (int i = first; i <= last; i++) {
list.add(i - 1, list.remove(i));
modelData.add(i - 1, modelData.remove(i));
model.fireTableRowsUpdated(i - 1, i);
}
jTable.getSelectionModel().setSelectionInterval(first - 1, last - 1);
}
}
);
moveDownButton.addActionListener(
new ActionListener() {
public void actionPerformed(final ActionEvent e) {
final int first = jTable.getSelectedRows()[0];
final int last = jTable.getSelectedRows()[jTable.getSelectedRowCount() - 1];
if (last + 1 >= jTable.getModel().getRowCount()) return;
for (int i = last; i >= first; i--) {
list.add(i + 1, (list.remove(i)));
modelData.add(i + 1, (modelData.remove(i)));
model.fireTableRowsUpdated(i, i + 1);
}
jTable.getSelectionModel().setSelectionInterval(first + 1, last + 1);
}
}
);
return addRemovePanel;
}
private ChoicePanel getOptionsPaneMsg(final ChoicePanel currentMsg) {
final ChoicePanel result = createChoicePanel();
if (currentMsg != null) {
result.copyChoices(currentMsg);
}
result.configurePanel();
return result;
}
private void editRow(final JPanel addRemovePanel) {
// edit first row of all rows selected
final int currentIndex = jTable.getSelectedRow();
final ChoicePanel o = modelData.get(currentIndex);
final ChoicePanel choicePanel = getOptionsPaneMsg(o);
final JOptionPane op = new JOptionPane(
choicePanel,
JOptionPane.PLAIN_MESSAGE,
JOptionPane.OK_CANCEL_OPTION,
null, null, null
);
final JDialog jd = op.createDialog(addRemovePanel, choicePanel.getChoicePanelName());
jd.setVisible(true);
final Object result = op.getValue();
if (result != null &&
((Integer)result) == JOptionPane.OK_OPTION)
{
final ChoicePanel value = (ChoicePanel)op.getMessage();
value.acceptEdited();
modelData.set(currentIndex, value);
list.set(currentIndex, ((com.wrq.rearranger.settings.attributeGroups.AttributeGroup)value.getChoice().getChoiceObject()));
model.fireTableRowsUpdated(currentIndex, currentIndex);
}
setTableColumnWidths();
}
// --------------------- GETTER / SETTER METHODS ---------------------
public final JPanel getPane() {
return pane;
}
// -------------------------- INNER CLASSES --------------------------
class Priority {
int priority;
public Priority(int priority) {
this.priority = priority;
}
public String toString() {
return "" + priority;
}
}
}
plugins/rearranger/src/com/wrq/rearranger/configuration/SpacingPane.java
-145
View File
@@ -1,145 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.configuration;
import com.wrq.rearranger.settings.ForceBlankLineSetting;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.util.Constraints;
import javax.swing.*;
import javax.swing.border.Border;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.text.NumberFormat;
/** UI code for Spacing rules dialog. */
public class SpacingPane {
// ------------------------------ FIELDS ------------------------------
private final RearrangerSettings settings;
// --------------------------- CONSTRUCTORS ---------------------------
public SpacingPane(RearrangerSettings settings) {
this.settings = settings;
}
// -------------------------- OTHER METHODS --------------------------
public JPanel getPane() {
final JPanel panel = new JPanel(new GridBagLayout());
final Border border = BorderFactory.createEtchedBorder();
panel.setBorder(border);
final Constraints constraints = new Constraints(GridBagConstraints.NORTHWEST);
constraints.gridwidth = GridBagConstraints.REMAINDER;
constraints.weightx = 1.0d;
constraints.insets = new Insets(3, 3, 0, 0);
panel.add(getForceBlankLinePanel(settings.getAfterClassLBrace()), constraints.weightedLastCol());
constraints.newRow();
panel.add(getForceBlankLinePanel(settings.getBeforeClassRBrace()), constraints.weightedLastCol());
constraints.newRow();
panel.add(getForceBlankLinePanel(settings.getAfterClassRBrace()), constraints.weightedLastCol());
constraints.newRow();
panel.add(getForceBlankLinePanel(settings.getBeforeMethodLBrace()), constraints.weightedLastCol());
constraints.newRow();
panel.add(getForceBlankLinePanel(settings.getAfterMethodLBrace()), constraints.weightedLastCol());
constraints.newRow();
panel.add(getForceBlankLinePanel(settings.getBeforeMethodRBrace()), constraints.weightedLastCol());
constraints.newRow();
panel.add(getForceBlankLinePanel(settings.getAfterMethodRBrace()), constraints.weightedLastCol());
constraints.newRow();
panel.add(getForceBlankLinePanel(settings.getNewLinesAtEOF()), constraints.weightedLastCol());
constraints.weightedLastRow();
final JCheckBox insideBlockBox = new JCheckBox("Remove initial and final blank lines inside code block");
insideBlockBox.setSelected(settings.isRemoveBlanksInsideCodeBlocks());
panel.add(insideBlockBox, constraints.weightedLastCol());
insideBlockBox.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
settings.setRemoveBlanksInsideCodeBlocks(insideBlockBox.isSelected());
}
});
return panel;
}
private JPanel getForceBlankLinePanel(final ForceBlankLineSetting fbl) {
final JPanel panel = new JPanel(new GridBagLayout());
final Constraints constraints = new Constraints();
constraints.fill = GridBagConstraints.BOTH;
constraints.lastRow();
final JCheckBox forceBox = new JCheckBox("Force");
forceBox.setSelected(fbl.isForce());
panel.add(forceBox, constraints.weightedFirstCol());
final NumberFormat integerInstance = NumberFormat.getIntegerInstance();
integerInstance.setMaximumIntegerDigits(2);
integerInstance.setMinimumIntegerDigits(1);
final JFormattedTextField nBlankLines = new JFormattedTextField(integerInstance);
nBlankLines.setValue(new Integer("88"));
Dimension d = nBlankLines.getPreferredSize();
d.width += 3;
nBlankLines.setPreferredSize(d);
nBlankLines.setValue(fbl.getnBlankLines());
nBlankLines.setFocusLostBehavior(JFormattedTextField.COMMIT_OR_REVERT);
constraints.insets = new Insets(0, 3, 0, 0);
panel.add(nBlankLines, constraints.weightedNextCol());
nBlankLines.addPropertyChangeListener("value", new PropertyChangeListener() {
public void propertyChange(final PropertyChangeEvent evt) {
int n = ((Number)nBlankLines.getValue()).intValue();
if (n < 0) {
n = 0;
nBlankLines.setValue(n);
}
fbl.setnBlankLines(n);
}
});
String labelText = "blank lines " +
(fbl.isBefore() ? "before" : "after");
switch (fbl.getObject()) {
case ForceBlankLineSetting.CLASS_OBJECT:
labelText += " class ";
break;
case ForceBlankLineSetting.METHOD_OBJECT:
labelText += " method ";
break;
}
labelText += fbl.isOpenBrace() ? "open brace \"{\""
: "close brace \"}\"";
if (fbl.getObject() == ForceBlankLineSetting.EOF_OBJECT) {
labelText = "newline characters at end of file";
}
final JLabel blankLineLabel = new JLabel(labelText);
panel.add(blankLineLabel, constraints.lastCol());
nBlankLines.setEnabled(forceBox.isSelected());
blankLineLabel.setEnabled(forceBox.isSelected());
forceBox.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
fbl.setForce(forceBox.isSelected());
nBlankLines.setEnabled(forceBox.isSelected());
blankLineLabel.setEnabled(forceBox.isSelected());
}
});
return panel;
}
}
plugins/rearranger/src/com/wrq/rearranger/configuration/StringTextArea.java
-58
View File
@@ -1,58 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.configuration;
import javax.swing.*;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
/**
* A JTextArea tied to a String field of this class. Initialize the JTextField from the field and update
* the field whenever the JTextField's text changes.
*/
public abstract class StringTextArea
extends JTextArea
{
abstract public void setValue(String value);
abstract public String getValue();
public StringTextArea() {
super();
setText(getValue());
getDocument().addDocumentListener(new DocumentListener() {
public void insertUpdate(DocumentEvent e) {
setValue(getText());
}
public void removeUpdate(DocumentEvent e) {
setValue(getText());
}
public void changedUpdate(DocumentEvent e) {
setValue(getText());
}
});
}
}
plugins/rearranger/src/com/wrq/rearranger/configuration/StringTextField.java
-56
View File
@@ -1,56 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.configuration;
import javax.swing.*;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
/**
* A JTextField tied to a String field of this class. Initialize the JTextField from the field and update
* the field whenever the JTextField's text changes.
*/
public abstract class StringTextField
extends JTextField
{
abstract public void setValue(String value);
abstract public String getValue();
public StringTextField() {
super();
setText(getValue());
getDocument().addDocumentListener(new DocumentListener() {
public void insertUpdate(DocumentEvent e) {
setValue(getText());
}
public void removeUpdate(DocumentEvent e) {
setValue(getText());
}
public void changedUpdate(DocumentEvent e) {
setValue(getText());
}
});
}
}
plugins/rearranger/src/com/wrq/rearranger/configuration/TableMap.java
-103
View File
@@ -1,103 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.configuration;
/**
* In a chain of data manipulators some behaviour is common. TableMap
* provides most of this behaviour and can be subclassed by filters
* that only need to override a handful of specific methods. TableMap
* implements TableModel by routing all requests to its model, and
* TableModelListener by routing all events to its listeners. Inserting
* a TableMap which has not been subclassed into a chain of table filters
* should have no effect.
*
* @version 1.4 12/17/97
* @author Philip Milne
*/
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.TableModel;
public class TableMap
extends AbstractTableModel
implements TableModelListener
{
// ------------------------------ FIELDS ------------------------------
protected TableModel model;
// --------------------- GETTER / SETTER METHODS ---------------------
public void setModel(TableModel model) {
this.model = model;
model.addTableModelListener(this);
}
// ------------------------ INTERFACE METHODS ------------------------
// --------------------- Interface TableModel ---------------------
public int getColumnCount() {
return (model == null) ? 0 : model.getColumnCount();
}
public int getRowCount() {
return (model == null) ? 0 : model.getRowCount();
}
public boolean isCellEditable(int row, int column) {
return model.isCellEditable(row, column);
}
public Class getColumnClass(int aColumn) {
return model.getColumnClass(aColumn);
}
// By default, implement TableModel by forwarding all messages
// to the model.
public Object getValueAt(int aRow, int aColumn) {
return model.getValueAt(aRow, aColumn);
}
public void setValueAt(Object aValue, int aRow, int aColumn) {
model.setValueAt(aValue, aRow, aColumn);
}
public String getColumnName(int aColumn) {
return model.getColumnName(aColumn);
}
// --------------------- Interface TableModelListener ---------------------
//
// Implementation of the TableModelListener interface,
//
// By default forward all events to all the listeners.
public void tableChanged(TableModelEvent e) {
fireTableChanged(e);
}
}
plugins/rearranger/src/com/wrq/rearranger/configuration/TableSorter.java
-342
View File
@@ -1,342 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.configuration;
/**
* A sorter for TableModels. The sorter has a model (conforming to TableModel)
* and itself implements TableModel. TableSorter does not store or copy
* the data in the TableModel, instead it maintains an array of
* integers which it keeps the same size as the number of rows in its
* model. When the model changes it notifies the sorter that something
* has changed eg. "rowsAdded" so that its internal array of integers
* can be reallocated. As requests are made of the sorter (like
* getValueAt(row, col) it redirects them to its model via the mapping
* array. That way the TableSorter appears to hold another copy of the table
* with the rows in a different order. The sorting algorthm used is stable
* which means that it does not move around rows when its comparison
* function returns 0 to denote that they are equivalent.
*
* @version 1.5 12/17/97
* @author Philip Milne
*/
import com.intellij.ui.ClickListener;
import javax.swing.*;
import javax.swing.event.TableModelEvent;
import javax.swing.table.TableColumnModel;
import javax.swing.table.TableModel;
import java.awt.event.InputEvent;
import java.awt.event.MouseEvent;
import java.util.Date;
import java.util.List;
import java.util.Vector;
public class TableSorter extends TableMap {
// ------------------------------ FIELDS ------------------------------
int[] indexes;
List<Integer> sortingColumns = new Vector<Integer>();
boolean ascending = true;
int compares;
// --------------------------- CONSTRUCTORS ---------------------------
public TableSorter() {
indexes = new int[0]; // for consistency
}
public TableSorter(TableModel model) {
setModel(model);
}
public void setModel(TableModel model) {
super.setModel(model);
reallocateIndexes();
}
public void reallocateIndexes() {
int rowCount = model.getRowCount();
// Set up a new array of indexes with the right number of elements
// for the new data model.
indexes = new int[rowCount];
// Initialise with the identity mapping.
for (int row = 0; row < rowCount; row++) {
indexes[row] = row;
}
}
// ------------------------ INTERFACE METHODS ------------------------
// --------------------- Interface TableModel ---------------------
// The mapping only affects the contents of the data rows.
// Pass all requests to these rows through the mapping array: "indexes".
public Object getValueAt(int aRow, int aColumn) {
checkModel();
return model.getValueAt(indexes[aRow], aColumn);
}
public void setValueAt(Object aValue, int aRow, int aColumn) {
checkModel();
model.setValueAt(aValue, indexes[aRow], aColumn);
}
// --------------------- Interface TableModelListener ---------------------
public void tableChanged(TableModelEvent e) {
reallocateIndexes();
super.tableChanged(e);
}
// -------------------------- OTHER METHODS --------------------------
// There is nowhere else to put this.
// Add a mouse listener to the Table to trigger a table sort
// when a column heading is clicked in the JTable.
public void addMouseListenerToHeaderInTable(JTable table) {
final TableSorter sorter = this;
final JTable tableView = table;
tableView.setColumnSelectionAllowed(false);
new ClickListener() {
@Override
public boolean onClick(MouseEvent e, int clickCount) {
TableColumnModel columnModel = tableView.getColumnModel();
int viewColumn = columnModel.getColumnIndexAtX(e.getX());
int column = tableView.convertColumnIndexToModel(viewColumn);
if (clickCount == 1 && column != -1) {
int shiftPressed = e.getModifiers() & InputEvent.SHIFT_MASK;
boolean ascending = defaultSortOrderAscending(column) ^ (shiftPressed != 0);
sorter.sortByColumn(column, ascending);
return true;
}
return false;
}
}.installOn(tableView.getTableHeader());
}
public boolean defaultSortOrderAscending(int column) {
return true;
}
public void sortByColumn(int column, boolean ascending) {
this.ascending = ascending;
sortingColumns.clear();
sortingColumns.add(column);
sort(this);
super.tableChanged(new TableModelEvent(this));
}
public void sort(TableSorter sender) {
checkModel();
compares = 0;
// n2sort();
// qsort(0, indexes.length-1);
shuttlesort(indexes.clone(), indexes, 0, indexes.length);
}
public void checkModel() {
if (indexes.length != model.getRowCount()) {
throw new RuntimeException("Sorter not informed of a change in model.");
}
}
// This is a home-grown implementation which we have not had time
// to research - it may perform poorly in some circumstances. It
// requires twice the space of an in-place algorithm and makes
// NlogN assigments shuttling the values between the two
// arrays. The number of compares appears to vary between N-1 and
// NlogN depending on the initial order but the main reason for
// using it here is that, unlike qsort, it is stable.
public void shuttlesort(int[] from, int[] to, int low, int high) {
if (high - low < 2) {
return;
}
int middle = (low + high) / 2;
shuttlesort(to, from, low, middle);
shuttlesort(to, from, middle, high);
int p = low;
int q = middle;
/* This is an optional short-cut; at each recursive call,
check to see if the elements in this subset are already
ordered. If so, no further comparisons are needed; the
sub-array can just be copied. The array must be copied rather
than assigned otherwise sister calls in the recursion might
get out of sinc. When the number of elements is three they
are partitioned so that the first set, [low, mid), has one
element and and the second, [mid, high), has two. We skip the
optimisation when the number of elements is three or less as
the first compare in the normal merge will produce the same
sequence of steps. This optimisation seems to be worthwhile
for partially ordered lists but some analysis is needed to
find out how the performance drops to Nlog(N) as the initial
order diminishes - it may drop very quickly. */
if (high - low >= 4 && compare(from[middle - 1], from[middle]) <= 0) {
for (int i = low; i < high; i++) {
to[i] = from[i];
}
return;
}
// A normal merge.
for (int i = low; i < high; i++) {
if (q >= high || (p < middle && compare(from[p], from[q]) <= 0)) {
to[i] = from[p++];
}
else {
to[i] = from[q++];
}
}
}
public int compare(int row1, int row2) {
compares++;
for (Integer column : sortingColumns) {
int result = compareRowsByColumn(row1, row2, column);
if (result != 0) {
return ascending ? result : -result;
}
}
return 0;
}
public int compareRowsByColumn(int row1, int row2, int column) {
Class type = model.getColumnClass(column);
TableModel data = model;
// Check for nulls.
Object o1 = data.getValueAt(row1, column);
Object o2 = data.getValueAt(row2, column);
// If both values are null, return 0.
if (o1 == null && o2 == null) {
return 0;
}
else if (o1 == null) { // Define null less than everything.
return -1;
}
else if (o2 == null) {
return 1;
}
/*
* We copy all returned values from the getValue call in case
* an optimised model is reusing one object to return many
* values. The Number subclasses in the JDK are immutable and
* so will not be used in this way but other subclasses of
* Number might want to do this to save space and avoid
* unnecessary heap allocation.
*/
if (type.getSuperclass() == java.lang.Number.class) {
Number n1 = (Number)data.getValueAt(row1, column);
double d1 = n1.doubleValue();
Number n2 = (Number)data.getValueAt(row2, column);
double d2 = n2.doubleValue();
if (d1 < d2) {
return -1;
}
else if (d1 > d2) {
return 1;
}
else {
return 0;
}
}
else if (type == java.util.Date.class) {
Date d1 = (Date)data.getValueAt(row1, column);
long n1 = d1.getTime();
Date d2 = (Date)data.getValueAt(row2, column);
long n2 = d2.getTime();
if (n1 < n2) {
return -1;
}
else if (n1 > n2) {
return 1;
}
else {
return 0;
}
}
else if (type == String.class) {
String s1 = (String)data.getValueAt(row1, column);
String s2 = (String)data.getValueAt(row2, column);
int result = s1.compareTo(s2);
if (result < 0) {
return -1;
}
else if (result > 0) {
return 1;
}
else {
return 0;
}
}
else if (type == Boolean.class) {
Boolean bool1 = (Boolean)data.getValueAt(row1, column);
boolean b1 = bool1;
Boolean bool2 = (Boolean)data.getValueAt(row2, column);
boolean b2 = bool2;
if (b1 == b2) {
return 0;
}
else if (b1) { // Define false < true
return 1;
}
else {
return -1;
}
}
else {
Object v1 = data.getValueAt(row1, column);
String s1 = v1.toString();
Object v2 = data.getValueAt(row2, column);
String s2 = v2.toString();
int result = s1.compareTo(s2);
if (result < 0) {
return -1;
}
else if (result > 0) {
return 1;
}
else {
return 0;
}
}
}
}
plugins/rearranger/src/com/wrq/rearranger/defaultConfiguration.xml
-340
View File
@@ -1,340 +0,0 @@
<!--
~ Copyright (c) 2003, 2010, Dave Kriewall
~ All rights reserved.
~
~ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
~ following conditions are met:
~
~ 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
~ disclaimer.
~
~ 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
~ disclaimer in the documentation and/or other materials provided with the distribution.
~
~ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
~ INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
~ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
~ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
~ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
~ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
~ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-->
<component name="Rearranger">
<Rearranger KeepGettersSettersTogether="true" KeepGettersSettersWithProperty="false" KeepOverloadedMethodsTogether="true"
ConfirmBeforeRearranging="false" RearrangeInnerClasses="false" globalCommentPattern="" overloadedOrder="1"
ShowParameterTypes="true" ShowParameterNames="false" ShowFields="true" ShowTypeAfterMethod="true" ShowRules="true"
ShowMatchedRules="false" ShowComments="false" RemoveBlanksInsideCodeBlocks="true">
<Items>
<Comment condition="2" nPrecedingRulesToMatch="1" nSubsequentRulesToMatch="7" allPrecedingRules="true" allSubsequentRules="false"
fillString="" useProjectWidthForFill="true" fillWidth="0">\n// ------------------------------ FIELDS ------------------------------\n</Comment>
<Field priority="1">
<ProtectionLevel public="true" private="false" protected="false" package="false" invert="false"/>
<Static value="true" invert="false"/>
<Final value="true" invert="false"/>
<NameMatch match="false" invert="false" pattern=""/>
<SortOptions byModifiers="false" byType="false" isTypeCaseInsensitive="false" byName="false" isNameCaseInsensitive="false"/>
<InitializedToAnonymousClass value="false" invert="false"/>
<Transient value="false" invert="false"/>
<Volatile value="false" invert="false"/>
<TypeMatch match="false" invert="false" pattern=""/>
</Field>
<Field priority="1">
<ProtectionLevel public="true" private="false" protected="false" package="false" invert="false"/>
<Static value="true" invert="false"/>
<Final value="false" invert="false"/>
<NameMatch match="false" invert="false" pattern=""/>
<SortOptions byModifiers="false" byType="false" isTypeCaseInsensitive="false" byName="false" isNameCaseInsensitive="false"/>
<InitializedToAnonymousClass value="false" invert="false"/>
<Transient value="false" invert="false"/>
<Volatile value="false" invert="false"/>
<TypeMatch match="false" invert="false" pattern=""/>
</Field>
<Field priority="1">
<ProtectionLevel public="false" private="false" protected="false" package="false" invert="false"/>
<Static value="true" invert="false"/>
<Final value="false" invert="false"/>
<NameMatch match="false" invert="false" pattern=""/>
<SortOptions byModifiers="false" byType="false" isTypeCaseInsensitive="false" byName="false" isNameCaseInsensitive="false"/>
<InitializedToAnonymousClass value="false" invert="false"/>
<Transient value="false" invert="false"/>
<Volatile value="false" invert="false"/>
<TypeMatch match="false" invert="false" pattern=""/>
</Field>
<Field priority="1">
<ProtectionLevel public="true" private="false" protected="false" package="false" invert="false"/>
<Static value="false" invert="false"/>
<Final value="false" invert="false"/>
<NameMatch match="false" invert="false" pattern=""/>
<SortOptions byModifiers="false" byType="false" isTypeCaseInsensitive="false" byName="false" isNameCaseInsensitive="false"/>
<InitializedToAnonymousClass value="false" invert="false"/>
<Transient value="false" invert="false"/>
<Volatile value="false" invert="false"/>
<TypeMatch match="false" invert="false" pattern=""/>
</Field>
<Field priority="1">
<ProtectionLevel public="false" private="false" protected="false" package="true" invert="false"/>
<Static value="false" invert="false"/>
<Final value="false" invert="false"/>
<NameMatch match="false" invert="false" pattern=""/>
<SortOptions byModifiers="false" byType="false" isTypeCaseInsensitive="false" byName="false" isNameCaseInsensitive="false"/>
<InitializedToAnonymousClass value="false" invert="false"/>
<Transient value="false" invert="false"/>
<Volatile value="false" invert="false"/>
<TypeMatch match="false" invert="false" pattern=""/>
</Field>
<Field priority="1">
<ProtectionLevel public="false" private="false" protected="true" package="false" invert="false"/>
<Static value="false" invert="false"/>
<Final value="false" invert="false"/>
<NameMatch match="false" invert="false" pattern=""/>
<SortOptions byModifiers="false" byType="false" isTypeCaseInsensitive="false" byName="false" isNameCaseInsensitive="false"/>
<InitializedToAnonymousClass value="false" invert="false"/>
<Transient value="false" invert="false"/>
<Volatile value="false" invert="false"/>
<TypeMatch match="false" invert="false" pattern=""/>
</Field>
<Field priority="1">
<ProtectionLevel public="false" private="false" protected="false" package="false" invert="false"/>
<Static value="false" invert="false"/>
<Final value="false" invert="false"/>
<NameMatch match="false" invert="false" pattern=""/>
<SortOptions byModifiers="false" byType="false" isTypeCaseInsensitive="false" byName="false" isNameCaseInsensitive="false"/>
<InitializedToAnonymousClass value="false" invert="false"/>
<Transient value="false" invert="false"/>
<Volatile value="false" invert="false"/>
<TypeMatch match="false" invert="false" pattern=""/>
</Field>
<Comment condition="2" nPrecedingRulesToMatch="1" nSubsequentRulesToMatch="1" allPrecedingRules="true" allSubsequentRules="true"
fillString="" useProjectWidthForFill="true" fillWidth="0">\n// -------------------------- STATIC METHODS --------------------------\n</Comment>
<Method priority="1">
<ProtectionLevel public="false" private="false" protected="false" package="false" invert="false"/>
<Static value="true" invert="false"/>
<Final value="false" invert="false"/>
<NameMatch match="false" invert="false" pattern=""/>
<SortOptions byModifiers="false" byType="false" isTypeCaseInsensitive="false" byName="false" isNameCaseInsensitive="false"/>
<Abstract value="false" invert="false"/>
<Native value="false" invert="false"/>
<Synchronized value="false" invert="false"/>
<Overridden value="false" invert="false"/>
<Overriding value="false" invert="false"/>
<Implemented value="false" invert="false"/>
<Implementing value="false" invert="false"/>
<Initializer value="false" invert="false"/>
<ReturnTypeMatch match="false" invert="false" pattern=""/>
<MIN_PARAMS match="false" opType="0" value="0"/>
<MAX_PARAMS match="false" opType="1" value="0"/>
<Misc constructorMethod="false" getterSetter="false" canonicalMethod="false" otherMethod="false" invertMethod="false"
noExtractedMethods="false"/>
<GetterSetterDefinition getterBody="0" getterName="0" setterBody="0" setterName="0"/>
</Method>
<Comment condition="2" nPrecedingRulesToMatch="1" nSubsequentRulesToMatch="1" allPrecedingRules="true" allSubsequentRules="true"
fillString="" useProjectWidthForFill="true" fillWidth="0">\n// --------------------------- CONSTRUCTORS ---------------------------\n</Comment>
<Method priority="1">
<ProtectionLevel public="false" private="false" protected="false" package="false" invert="false"/>
<Static value="false" invert="false"/>
<Final value="false" invert="false"/>
<NameMatch match="false" invert="false" pattern=""/>
<SortOptions byModifiers="false" byType="false" isTypeCaseInsensitive="false" byName="false" isNameCaseInsensitive="false"/>
<Abstract value="false" invert="false"/>
<Native value="false" invert="false"/>
<Synchronized value="false" invert="false"/>
<Overridden value="false" invert="false"/>
<Overriding value="false" invert="false"/>
<Implemented value="false" invert="false"/>
<Implementing value="false" invert="false"/>
<Initializer value="false" invert="false"/>
<ReturnTypeMatch match="false" invert="false" pattern=""/>
<MIN_PARAMS match="false" opType="0" value="0"/>
<MAX_PARAMS match="false" opType="1" value="0"/>
<Misc constructorMethod="true" getterSetter="false" canonicalMethod="false" otherMethod="false" invertMethod="false"
noExtractedMethods="false"/>
<GetterSetterDefinition getterBody="0" getterName="0" setterBody="0" setterName="0"/>
</Method>
<Method priority="1">
<ProtectionLevel public="false" private="false" protected="false" package="false" invert="false"/>
<Static value="false" invert="false"/>
<Final value="false" invert="false"/>
<NameMatch match="false" invert="false" pattern=""/>
<SortOptions byModifiers="false" byType="false" isTypeCaseInsensitive="false" byName="false" isNameCaseInsensitive="false"/>
<Abstract value="false" invert="false"/>
<Native value="false" invert="false"/>
<Synchronized value="false" invert="false"/>
<Overridden value="false" invert="false"/>
<Overriding value="false" invert="false"/>
<Implemented value="false" invert="false"/>
<Implementing value="false" invert="false"/>
<Initializer value="true" invert="false"/>
<ReturnTypeMatch match="false" invert="false" pattern=""/>
<MIN_PARAMS match="false" opType="0" value="0"/>
<MAX_PARAMS match="false" opType="1" value="0"/>
<Misc constructorMethod="false" getterSetter="false" canonicalMethod="false" otherMethod="false" invertMethod="false"
noExtractedMethods="false"/>
<GetterSetterDefinition getterBody="0" getterName="0" setterBody="0" setterName="0"/>
</Method>
<Comment condition="2" nPrecedingRulesToMatch="1" nSubsequentRulesToMatch="1" allPrecedingRules="true" allSubsequentRules="true"
fillString="" useProjectWidthForFill="true" fillWidth="0">\n// --------------------- GETTER / SETTER METHODS ---------------------\n</Comment>
<Method priority="1">
<ProtectionLevel public="false" private="false" protected="false" package="false" invert="false"/>
<Static value="false" invert="false"/>
<Final value="false" invert="false"/>
<NameMatch match="false" invert="false" pattern=""/>
<SortOptions byModifiers="false" byType="false" isTypeCaseInsensitive="false" byName="true" isNameCaseInsensitive="false"/>
<Abstract value="false" invert="false"/>
<Native value="false" invert="false"/>
<Synchronized value="false" invert="false"/>
<Overridden value="false" invert="false"/>
<Overriding value="false" invert="false"/>
<Implemented value="false" invert="false"/>
<Implementing value="false" invert="false"/>
<Initializer value="false" invert="false"/>
<ReturnTypeMatch match="false" invert="false" pattern=""/>
<MIN_PARAMS match="false" opType="0" value="0"/>
<MAX_PARAMS match="false" opType="1" value="0"/>
<Misc constructorMethod="false" getterSetter="true" canonicalMethod="false" otherMethod="false" invertMethod="false"
noExtractedMethods="false"/>
<GetterSetterDefinition getterBody="0" getterName="0" setterBody="0" setterName="0"/>
</Method>
<Comment condition="2" nPrecedingRulesToMatch="1" nSubsequentRulesToMatch="1" allPrecedingRules="true" allSubsequentRules="true"
fillString="" useProjectWidthForFill="true" fillWidth="0">\n// ------------------------ CANONICAL METHODS ------------------------\n</Comment>
<Method priority="1">
<ProtectionLevel public="false" private="false" protected="false" package="false" invert="false"/>
<Static value="false" invert="false"/>
<Final value="false" invert="false"/>
<NameMatch match="false" invert="false" pattern=""/>
<SortOptions byModifiers="false" byType="false" isTypeCaseInsensitive="false" byName="true" isNameCaseInsensitive="false"/>
<Abstract value="false" invert="false"/>
<Native value="false" invert="false"/>
<Synchronized value="false" invert="false"/>
<Overridden value="false" invert="false"/>
<Overriding value="false" invert="false"/>
<Implemented value="false" invert="false"/>
<Implementing value="false" invert="false"/>
<Initializer value="false" invert="false"/>
<ReturnTypeMatch match="false" invert="false" pattern=""/>
<MIN_PARAMS match="false" opType="0" value="0"/>
<MAX_PARAMS match="false" opType="1" value="0"/>
<Misc constructorMethod="false" getterSetter="false" canonicalMethod="true" otherMethod="false" invertMethod="false"
noExtractedMethods="false"/>
<GetterSetterDefinition getterBody="0" getterName="0" setterBody="0" setterName="0"/>
</Method>
<Comment condition="2" nPrecedingRulesToMatch="1" nSubsequentRulesToMatch="1" allPrecedingRules="true" allSubsequentRules="true"
fillString="" useProjectWidthForFill="true" fillWidth="0">\n// ------------------------ INTERFACE METHODS ------------------------\n</Comment>
<Interface alphabetizeInterfaces="true" noExtractedMethods="true" methodOrder="1" priority="1" fillString=""
useProjectWidthForFill="true" fillWidth="0">
<NameMatch match="false" invert="false" pattern=""/>
<PrecedingComment>
<Comment condition="0" nPrecedingRulesToMatch="1" nSubsequentRulesToMatch="1" allPrecedingRules="true" allSubsequentRules="true"
fillString="" useProjectWidthForFill="true" fillWidth="0">\n// --------------------- Interface %IF% ---------------------\n</Comment>
</PrecedingComment>
<TrailingComment>
<Comment condition="0" nPrecedingRulesToMatch="1" nSubsequentRulesToMatch="1" allPrecedingRules="true" allSubsequentRules="true"
fillString="" useProjectWidthForFill="true" fillWidth="0"/>
</TrailingComment>
</Interface>
<Comment condition="2" nPrecedingRulesToMatch="1" nSubsequentRulesToMatch="1" allPrecedingRules="true" allSubsequentRules="true"
fillString="" useProjectWidthForFill="true" fillWidth="0">\n// -------------------------- OTHER METHODS --------------------------\n</Comment>
<Method priority="1">
<ProtectionLevel public="false" private="false" protected="false" package="false" invert="false"/>
<Static value="false" invert="false"/>
<Final value="false" invert="false"/>
<NameMatch match="false" invert="false" pattern=""/>
<SortOptions byModifiers="false" byType="false" isTypeCaseInsensitive="false" byName="true" isNameCaseInsensitive="false"/>
<Abstract value="false" invert="false"/>
<Native value="false" invert="false"/>
<Synchronized value="false" invert="false"/>
<Overridden value="false" invert="false"/>
<Overriding value="false" invert="false"/>
<Implemented value="false" invert="false"/>
<Implementing value="false" invert="false"/>
<Initializer value="false" invert="false"/>
<ReturnTypeMatch match="false" invert="false" pattern=""/>
<MIN_PARAMS match="false" opType="0" value="0"/>
<MAX_PARAMS match="false" opType="1" value="0"/>
<Misc constructorMethod="false" getterSetter="false" canonicalMethod="false" otherMethod="false" invertMethod="false"
noExtractedMethods="false"/>
<GetterSetterDefinition getterBody="0" getterName="0" setterBody="0" setterName="0"/>
</Method>
<Comment condition="2" nPrecedingRulesToMatch="1" nSubsequentRulesToMatch="1" allPrecedingRules="true" allSubsequentRules="true"
fillString="" useProjectWidthForFill="true" fillWidth="0">\n//\ -------------------------- ENUMERATIONS --------------------------\n</Comment>
<InnerClass priority="1">
<ProtectionLevel public="false" private="false" protected="false" package="false" invert="false"/>
<Static value="false" invert="false"/>
<Final value="false" invert="false"/>
<NameMatch match="false" invert="false" pattern=""/>
<SortOptions byModifiers="false" byType="false" isTypeCaseInsensitive="false" byName="false" isNameCaseInsensitive="false"/>
<Abstract value="false" invert="false"/>
<Enum value="true" invert="false"/>
</InnerClass>
<Comment condition="2" nPrecedingRulesToMatch="1" nSubsequentRulesToMatch="1" allPrecedingRules="true" allSubsequentRules="true"
fillString="" useProjectWidthForFill="true" fillWidth="0">\n// -------------------------- INNER CLASSES --------------------------\n</Comment>
<InnerClass priority="1">
<ProtectionLevel public="false" private="false" protected="false" package="false" invert="false"/>
<Static value="false" invert="false"/>
<Final value="false" invert="false"/>
<NameMatch match="false" invert="false" pattern=""/>
<SortOptions byModifiers="false" byType="false" isTypeCaseInsensitive="false" byName="false" isNameCaseInsensitive="false"/>
<Abstract value="false" invert="false"/>
<Enum value="false" invert="false"/>
</InnerClass>
<Comment condition="2" nPrecedingRulesToMatch="1" nSubsequentRulesToMatch="1" allPrecedingRules="true" allSubsequentRules="true"
fillString="" useProjectWidthForFill="true" fillWidth="0">\n//\ ---------------------------\ main()\ method\
---------------------------\n
</Comment>
<Method priority="2">
<ProtectionLevel public="false" private="false" protected="false" package="false" invert="false"/>
<Static value="false" invert="false"/>
<Final value="false" invert="false"/>
<NameMatch match="true" invert="false" pattern="main"/>
<SortOptions byModifiers="false" byType="false" isTypeCaseInsensitive="false" byName="false" isNameCaseInsensitive="false"/>
<Abstract value="false" invert="false"/>
<Native value="false" invert="false"/>
<Synchronized value="false" invert="false"/>
<Overridden value="false" invert="false"/>
<Overriding value="false" invert="false"/>
<Implemented value="false" invert="false"/>
<Implementing value="false" invert="false"/>
<Initializer value="false" invert="false"/>
<ReturnTypeMatch match="false" invert="false" pattern=""/>
<MIN_PARAMS match="false" opType="0" value="0"/>
<MAX_PARAMS match="false" opType="1" value="0"/>
<Misc constructorMethod="false" getterSetter="false" canonicalMethod="false" otherMethod="false" invertMethod="false"
noExtractedMethods="false"/>
<GetterSetterDefinition getterBody="0" getterName="0" setterBody="0" setterName="0"/>
</Method>
</Items>
<Classes>
<Class priority="1">
<ProtectionLevel public="true" private="false" protected="false" package="false" invert="false"/>
<Static value="false" invert="false"/>
<Final value="false" invert="false"/>
<NameMatch match="false" invert="false" pattern=""/>
<SortOptions byModifiers="false" byType="false" isTypeCaseInsensitive="false" byName="false" isNameCaseInsensitive="false"/>
<Abstract value="false" invert="false"/>
<Enum value="false" invert="false"/>
</Class>
</Classes>
<DefaultGetterSetterDefinition>
<GetterSetterDefinition getterBody="0" getterName="0" setterBody="0" setterName="0"/>
</DefaultGetterSetterDefinition>
<RelatedMethods moveExtractedMethods="true" belowFirstCaller="true" depthFirstOrdering="true" ordering="0" nonPrivateTreatment="2"
commentType="0" fillString="" useProjectWidthForFill="true" fillWidth="0">
<PrecedingComment>
<Comment condition="0" nPrecedingRulesToMatch="1" nSubsequentRulesToMatch="1" allPrecedingRules="true" allSubsequentRules="true"
fillString="" useProjectWidthForFill="true" fillWidth="0"/>
</PrecedingComment>
<TrailingComment>
<Comment condition="0" nPrecedingRulesToMatch="1" nSubsequentRulesToMatch="1" allPrecedingRules="true" allSubsequentRules="true"
fillString="" useProjectWidthForFill="true" fillWidth="0"/>
</TrailingComment>
</RelatedMethods>
<AfterClassLBrace Force="true" nBlankLines="0"/>
<AfterClassRBrace Force="true" nBlankLines="1"/>
<BeforeClassRBrace Force="true" nBlankLines="0"/>
<BeforeMethodLBrace Force="false" nBlankLines="1"/>
<AfterMethodLBrace Force="true" nBlankLines="0"/>
<AfterMethodRBrace Force="true" nBlankLines="1"/>
<BeforeMethodRBrace Force="true" nBlankLines="0"/>
<NewlinesAtEOF Force="false" nBlankLines="1"/>
</Rearranger>
</component>
plugins/rearranger/src/com/wrq/rearranger/entry/ClassContentsEntry.java
-66
View File
@@ -1,66 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.entry;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiField;
import com.wrq.rearranger.popup.FilePopupEntry;
import com.wrq.rearranger.popup.RearrangerTreeNode;
import com.wrq.rearranger.settings.RearrangerSettings;
import org.jetbrains.annotations.Nullable;
import javax.swing.tree.DefaultMutableTreeNode;
/**
* Describes the fields, methods, and inner class declarations of a class. This information is used to reorder
* these declarations within an outer class.
*/
public abstract class ClassContentsEntry extends RangeEntry implements FilePopupEntry {
public ClassContentsEntry(@Nullable final PsiElement start,
@Nullable final PsiElement end,
final int modifiers,
final String modifierString,
final @Nullable String name,
final String type)
{
super(start, end, modifiers, modifierString, name, type);
}
public ClassContentsEntry(@Nullable final PsiElement start,
@Nullable final PsiElement end,
final boolean fixedHeader,
final boolean fixedTrailer)
{
super(start, end, fixedHeader, fixedTrailer);
}
public DefaultMutableTreeNode addToPopupTree(DefaultMutableTreeNode parent, RearrangerSettings settings) {
DefaultMutableTreeNode node = null;
if ((myEnd instanceof PsiField && settings.isShowFields()) ||
(this instanceof ClassEntry))
{
node = new RearrangerTreeNode(this, myName);
parent.add(node);
}
return node;
}
}
plugins/rearranger/src/com/wrq/rearranger/entry/ClassEntry.java
-587
View File
@@ -1,587 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.entry;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.project.Project;
import com.intellij.psi.*;
import com.intellij.psi.search.PsiSearchHelper;
import com.intellij.psi.search.SearchScope;
import com.intellij.psi.search.searches.OverridingMethodsSearch;
import com.intellij.util.Query;
import com.wrq.rearranger.ModifierConstants;
import com.wrq.rearranger.popup.FilePopupEntry;
import com.wrq.rearranger.rearrangement.Emitter;
import com.wrq.rearranger.rearrangement.GenericRearranger;
import com.wrq.rearranger.ruleinstance.RuleInstance;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.util.ModifierUtils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import javax.swing.*;
import javax.swing.tree.DefaultMutableTreeNode;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
/**
* Describes an entire class's range and type.
* This information is used when reordering outer classes.
*/
public class ClassEntry extends ClassContentsEntry implements FilePopupEntry {
private static final Logger LOG = Logger.getInstance("#" + ClassEntry.class.getName());
protected final List<ClassContentsEntry> myContents;
private List<RuleInstance> myResultRuleInstances;
private final RearrangerSettings mySettings;
private final int myNestingLevel;
public ClassEntry(@Nullable PsiElement start,
@Nullable PsiElement end,
int modifiers,
String modifierString,
@Nullable String name,
int nestingLevel,
RearrangerSettings settings) {
super(start, end, modifiers, modifierString, name, "");
myContents = new ArrayList<ClassContentsEntry>();
myResultRuleInstances = null;
mySettings = settings;
myNestingLevel = nestingLevel;
}
public String getTypeIconName() {
String result = "nodes/class";
if (myEnd.getParent() instanceof PsiClass) {
PsiClass psiClass = (PsiClass)myEnd.getParent();
if (psiClass.isEnum()) {
result = "nodes/enum";
}
else if (psiClass.isInterface()) {
result = "nodes/interface";
}
}
return result;
}
public String[] getAdditionalIconNames() {
if (myEnd instanceof PsiJavaToken && myEnd.getText().equals("{")) {
PsiClass psiClass = (PsiClass)myEnd.getParent();
final PsiModifierList modifierList = psiClass.getModifierList();
if (modifierList == null) {
return null;
}
if (modifierList.hasModifierProperty(PsiModifier.PUBLIC)) {
return new String[]{"nodes/c_public"};
}
if (modifierList.hasModifierProperty(PsiModifier.PROTECTED)) {
return new String[]{"nodes/c_protected"};
}
if (modifierList.hasModifierProperty(PsiModifier.PRIVATE)) {
return new String[]{"nodes/c_private"};
}
return new String[]{"nodes/c_plocal"};
}
return null;
}
public JLabel getPopupEntryText(RearrangerSettings settings) {
return new JLabel(myName);
}
protected void parseRemainingClassContents(@NotNull final Project project,
int startingIndex,
@NotNull final PsiElement psiClass
) {
final PsiSearchHelper psh = PsiSearchHelper.SERVICE.getInstance(project);
int lastIndex = startingIndex;
/**
* if option indicates, don't parse inner class contents; leave them unchanged.
*/
if (mySettings.isRearrangeInnerClasses() || myNestingLevel <= 1) {
for (int i = startingIndex; i < psiClass.getChildren().length; i++) {
PsiElement child = psiClass.getChildren()[i];
if (child instanceof PsiJavaToken && child.getText().equals("{")) {
lastIndex = i + 1; // first item of a class starts immediately after the class left brace.
}
LOG.debug(psiClass.toString() + " child " + i + ":" + child.toString());
if (child instanceof PsiField ||
child instanceof PsiMethod ||
child instanceof PsiClass ||
child instanceof PsiClassInitializer)
{
MemberAttributes attributes = new MemberAttributes();
PsiElement startElement = psiClass.getChildren()[lastIndex];
ClassContentsEntry classContentsEntry = null;
if (child instanceof PsiField) {
i = parseField(child, attributes, i, (PsiClass)psiClass);
// a field declaration with multiple fields like "int x, y;" must advance child to "y;"
// to prevent splitting.
child = psiClass.getChildren()[i];
classContentsEntry = new FieldEntry(
startElement,
child,
attributes.modifiers,
attributes.modifierString,
attributes.name,
attributes.type
);
}
if (child instanceof PsiMethod) {
parseMethod(child, attributes, psh);
classContentsEntry = new MethodEntry(
startElement,
child,
attributes.modifiers,
attributes.modifierString,
attributes.name,
attributes.type,
attributes.nParameters,
attributes.interfaceName
);
}
if (child instanceof PsiClass) {
parseClassAttributes((PsiClass)child, attributes);
//
// if child is an enum, set the last entry past the LBrace to the final enumeration or the
// semicolon thereafter, if any.
//
PsiClass clazz = (PsiClass)child;
PsiElement clazzEnd;
int startElementIndex = 0;
if (clazz.isEnum()) {
// we want to skip all the enumeration fields, including terminating semicolon if present.
// class parsing begins after these.
startElementIndex = findLastEnumTerminator(clazz);
clazzEnd = clazz.getChildren()[startElementIndex];
startElementIndex++;
}
else {
// normal class: parse everything after the left brace.
clazzEnd = clazz.getLBrace();
startElementIndex = Arrays.asList(clazz.getChildren()).indexOf(clazzEnd) + 1;
}
ClassEntry entry = new ClassEntry(
startElement,
clazzEnd,
attributes.modifiers,
attributes.modifierString,
attributes.name,
myNestingLevel + 1,
mySettings
);
classContentsEntry = entry;
entry.parseRemainingClassContents(
project,
startElementIndex,
child);
}
if (child instanceof PsiClassInitializer) {
parseClassInitializer(child, attributes);
classContentsEntry = new ClassInitializerEntry(startElement,
child,
attributes.modifiers,
attributes.modifierString,
attributes.name);
}
myContents.add(classContentsEntry);
classContentsEntry.checkForComment();
lastIndex = i + 1; // next class includes everything since the end of the prior class.
}
}
}
if (lastIndex < psiClass.getChildren().length) {
if (lastIndex < 0) {
lastIndex = 0;
}
// create a dummy trailer entry to cover anything after the last class.
final MiscellaneousTextEntry miscellaneousTextEntry = new MiscellaneousTextEntry(
psiClass.getChildren()[lastIndex],
psiClass.getChildren()[psiClass.getChildren().length - 1],
false, true
);
myContents.add(miscellaneousTextEntry);
miscellaneousTextEntry.checkForComment();
}
}
/**
* Search for the end of the enumeration's fields. It may be terminated with a semicolon, in which case we want
* to point to the next item. If no semicolon is found, we want to point to the enum's right brace.
*
* @param clazz
* @return starting element index for the portion of the enumeration class following its enum declarations.
*/
private static int findLastEnumTerminator(PsiClass clazz) {
int startElementIndex = 0;
// go until we hit RBrace (non-inclusive), or semicolon (inclusive)
boolean foundLBrace = false;
for (int j = 0; j < clazz.getChildren().length; j++) {
PsiElement psiElement = clazz.getChildren()[j];
if (!foundLBrace) {
if (psiElement == clazz.getLBrace()) {
foundLBrace = true;
}
}
else {
startElementIndex = j;
if (psiElement == clazz.getRBrace()) {
break;
}
if (psiElement instanceof PsiJavaToken &&
((PsiJavaToken)psiElement).getTokenType() == JavaTokenType.SEMICOLON)
{
break;
}
}
}
return startElementIndex;
}
private static int parseField(PsiElement child, MemberAttributes attributes, int i, final PsiClass psiClass) {
attributes.field = (PsiField)child;
LOG.debug("enter parseField: child=" +
(child == null ? "null" : child.toString()));
attributes.name = attributes.field.getName();
final PsiClass containingClass = attributes.field.getContainingClass();
final PsiTypeElement typeElement = attributes.field.getTypeElement();
if (typeElement == null && containingClass != null) {
attributes.type = containingClass.getName(); // if enum, use class as type
}
else if (typeElement != null) {
attributes.type = typeElement.getText();
}
final PsiModifierList modifierList = attributes.field.getModifierList();
if (modifierList != null) {
attributes.modifierString = modifierList.getText();
}
attributes.modifiers = ModifierUtils.getModifierMask(attributes.modifierString);
if (containingClass != null && containingClass.isInterface()) {
// all fields in an interface are constants, hence "public static final"
attributes.modifiers |= Modifier.PUBLIC | Modifier.STATIC | Modifier.FINAL;
}
final PsiExpression initializer = attributes.field.getInitializer();
if (initializer instanceof PsiNewExpression) {
final PsiElement lc = initializer.getLastChild();
if (lc instanceof PsiAnonymousClass) {
attributes.modifiers |= ModifierConstants.INIT_TO_ANON_CLASS;
}
}
LOG.debug(
"parseField: name=" +
attributes.name +
", modifiers=" +
Integer.toHexString(attributes.modifiers)
);
/**
* handle multiple declarations here. While this field declaration does not end
* in a semicolon, skip whitespace and intervening comma; move child ahead to
* next field. This prevents declarations like "int b, a;" from being split.
*/
PsiElement myChild = child;
boolean done = false;
while (!done) {
PsiElement lastElement = myChild.getLastChild();
LOG.debug("parseField: getLastChild=" +
(lastElement == null ? "null" : lastElement.toString()));
if (lastElement == null) break;
if (lastElement instanceof PsiErrorElement) break;
if (lastElement instanceof PsiJavaToken &&
((PsiJavaToken)lastElement).getTokenType() == JavaTokenType.SEMICOLON)
{
break;
}
if (lastElement instanceof PsiComment) {
break;
}
// skip to next field
LOG.debug(
"parseField:skipping to next field, i=" +
i +
", psiClass=" + psiClass.getName()
);
LOG.debug(
"parseField: psiClass children array length=" +
psiClass.getChildren().length
);
while (++i < psiClass.getChildren().length) {
myChild = psiClass.getChildren()[i];
LOG.debug("parseField: myChild=" + myChild.toString());
if (myChild instanceof PsiField) {
done = true;
break;
}
}
}
return i;
}
private static void parseMethod(PsiElement child, MemberAttributes attributes, final PsiSearchHelper psh) {
attributes.method = (PsiMethod)child;
attributes.name = attributes.method.getName();
final PsiTypeElement returnTypeElement = attributes.method.getReturnTypeElement();
if (returnTypeElement == null) {
attributes.type = "null";
}
else {
attributes.type = returnTypeElement.getText();
}
attributes.modifierString = attributes.method.getModifierList().getText();
attributes.modifiers = ModifierUtils.getModifierMask(attributes.modifierString);
attributes.nParameters = attributes.method.getParameterList().getParameters().length;
final PsiClass containingClass = attributes.method.getContainingClass();
if (containingClass != null && containingClass.isInterface()) {
// methods in an interface are always considered public
attributes.modifiers |= Modifier.PUBLIC;
}
// set any additional "modifier" flags.
// final Query<MethodSignatureBackedByPsiMethod> sm2 = SuperMethodsSearch.search(attributes.method,
// attributes.method.getContainingClass(), false, false);
// for (MethodSignatureBackedByPsiMethod msb : sm2) {
// System.out.println(msb.getMethod().getName());
// } // seems to be no different than method.findSuperMethods()
attributes.modifiers |= isCanonicalOrInterface(attributes.method, attributes);
final SearchScope ss = psh.getUseScope(child);
final Query<PsiMethod> query = OverridingMethodsSearch.search(attributes.method, ss, true);
final PsiMethod method = query.findFirst();
if (method != null) {
final Collection<PsiMethod> overridersCollection = query.findAll();
final PsiMethod[] overriders = overridersCollection.toArray(new PsiMethod[overridersCollection.size()]);
LOG.debug(
"method " +
attributes.method.toString() +
" is overridden; has " +
overriders.length + " overriding methods:"
);
dumpMethodNames(overriders);
if (attributes.method.getBody() == null) {
attributes.modifiers |= ModifierConstants.IMPLEMENTED;
}
else {
attributes.modifiers |= ModifierConstants.OVERRIDDEN;
}
}
// Determine if this method overrides another.
final PsiMethod[] superMethods = attributes.method.findSuperMethods(false);
LOG.debug("method " + attributes.method.toString() + " has " + superMethods.length + " supermethods");
dumpMethodNames(superMethods);
if (superMethods.length > 0) {
// Determine if supermethod is abstract or interface; if so, assign IMPLEMENTING attribute.
PsiMethod superMethod = superMethods[0];
boolean abztract = superMethod.getModifierList().hasModifierProperty(PsiModifier.ABSTRACT);
PsiClass superclass = superMethod.getContainingClass();
if (abztract || (
superclass != null && superclass.isInterface()))
{
attributes.modifiers |= ModifierConstants.IMPLEMENTING;
}
else {
attributes.modifiers |= ModifierConstants.OVERRIDING;
}
}
if (attributes.method.isConstructor()) {
attributes.modifiers |= ModifierConstants.CONSTRUCTOR;
}
// Getter/setter cannot be determined here because definition of what a getter/setter
// is can vary from rule to rule. Do it at the time of rule matching.
else if ((attributes.modifiers & ModifierConstants.CANONICAL) == 0) {
attributes.modifiers |= ModifierConstants.OTHER_METHOD;
}
LOG.debug(
"method " +
attributes.name +
" attributes: " +
ModifierConstants.toString(attributes.modifiers)
);
}
private static int isCanonicalOrInterface(PsiMethod method, MemberAttributes attributes) {
PsiElement methodParent = method.getParent();
LOG.debug("checking to see if " + method.getName() + " of " + methodParent + " is canonical");
PsiMethod[] superMethods = method.findSuperMethods();
LOG.debug("result of findSuperMethods for " + method.getName() + ": size=" + superMethods.length);
// check to see if this method is canonical (inherited from Object).
for (PsiMethod m : superMethods) {
PsiElement parent = m.getParent();
LOG.debug(
"supermethod " +
m.getName() +
" belongs to " +
parent
);
if (parent instanceof PsiClass) {
final PsiClass psiClass = ((PsiClass)parent);
if (psiClass.isInterface()) {
LOG.debug("method " + method.toString() + " implements interface");
attributes.interfaceName = psiClass.getName();
}
PsiElement superclass = psiClass.getSuperClass();
if (superclass == null) {
// m's class must be java.lang.Object; it's the only class with a null
// superclass.
LOG.debug("method " + method.toString() + " is canonical");
return ModifierConstants.CANONICAL;
}
else {
int result = isCanonicalOrInterface(m, attributes);
// int result = 0;
// if (!superclass.toString().equalsIgnoreCase("psiclass:object"))
// {
// result = isCanonicalOrInterface(m, attributes);
// }
if (result > 0) {
LOG.debug("Returning result from canonical check as " + result);
return result;
}
}
}
}
return 0;
}
private static void dumpMethodNames(PsiMethod[] methods) {
for (int j = 0; j < methods.length; j++) {
LOG.debug(
j +
":" +
methods[j].toString() +
" of class " +
methods[j].getParent().toString()
);
}
}
private static void parseClassAttributes(@NotNull PsiClass child, @NotNull MemberAttributes attributes) {
attributes.childClass = child;
attributes.name = attributes.childClass.getName();
if (attributes.name == null) {
attributes.name = "";
}
final PsiModifierList modifierList = child.getModifierList();
if (modifierList != null) {
attributes.modifierString = modifierList.getText();
}
attributes.modifiers = ModifierUtils.getModifierMask(attributes.modifierString);
attributes.type = attributes.childClass.isEnum() ? "enum" : "class";
if (attributes.childClass.isEnum()) {
attributes.modifiers |= ModifierConstants.ENUM;
}
}
private static void parseClassInitializer(PsiElement child, MemberAttributes attributes) {
attributes.classInitializer = (PsiClassInitializer)child;
attributes.name = "";
final PsiModifierList modifierList = attributes.classInitializer.getModifierList();
if (modifierList != null) {
attributes.modifierString = modifierList.getText();
}
attributes.modifiers = ModifierUtils.getModifierMask(attributes.modifierString) |
ModifierConstants.INITIALIZER;
}
public void emit(Emitter emitter) {
// First emit the text up to and including the left brace.
super.emit(emitter);
// now emit all children.
emitter.emitRuleInstances(getResultRuleInstances());
}
public DefaultMutableTreeNode addToPopupTree(DefaultMutableTreeNode parent, RearrangerSettings settings) {
DefaultMutableTreeNode result = super.addToPopupTree(parent, settings);
// now add class contents, if any
if (getResultRuleInstances() != null) {
for (RuleInstance instance : getResultRuleInstances()) {
instance.addRuleInstanceToPopupTree(result, settings);
}
}
return result;
}
/** Rearranges the contents of this PsiClass according to supplied rules. */
public void rearrangeContents() {
buildMethodCallGraph();
LOG.debug("identifying setters and extracted (related) methods");
for (ClassContentsEntry contentsEntry : getContents()) {
if (contentsEntry instanceof RelatableEntry) {
((RelatableEntry)contentsEntry).determineSettersAndMethodCalls(mySettings, getContents());
}
}
LOG.debug("relating extracted methods");
for (ClassContentsEntry contentsEntry : getContents()) {
if (contentsEntry instanceof RelatableEntry) {
((RelatableEntry)contentsEntry).determineExtractedMethod(mySettings.getExtractedMethodsSettings());
}
}
// Remove any cycles in the related method graph.
MethodEntry.eliminateCycles(getContents());
// Check for overloaded extracted methods; if configured to be kept together, attach subsequent
// methods to the first and remove them from consideration for other alignment.
MethodEntry.handleOverloadedMethods(getContents(), mySettings);
final GenericRearranger classContentsRearranger =
new GenericRearranger(mySettings.getItemOrderAttributeList(),
myContents,
myNestingLevel,
mySettings)
{
public void rearrangeRelatedItems(List<ClassContentsEntry> entries,
List<RuleInstance> ruleInstanceList)
{
for (RuleInstance ruleInstance : ruleInstanceList) {
ruleInstance.rearrangeRuleItems(entries, mySettings);
}
}
};
myResultRuleInstances = classContentsRearranger.rearrangeEntries();
}
private void buildMethodCallGraph() {
if (mySettings.getExtractedMethodsSettings().isMoveExtractedMethods() ||
mySettings.isKeepGettersSettersTogether())
{
LOG.debug("building method call & getter-setter graph");
for (ClassContentsEntry contentsEntry : getContents()) {
if (contentsEntry instanceof RelatableEntry) {
((RelatableEntry)contentsEntry).determineGetterSetterAndExtractedMethodStatus(mySettings);
}
}
}
}
// End Methods of Interface IFilePopupEntry
public final List<ClassContentsEntry> getContents() {
return myContents;
}
public List<RuleInstance> getResultRuleInstances() {
return myResultRuleInstances;
}
}
plugins/rearranger/src/com/wrq/rearranger/entry/ClassInitializerEntry.java
-68
View File
@@ -1,68 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.entry;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.psi.PsiElement;
import com.wrq.rearranger.popup.RearrangerTreeNode;
import com.wrq.rearranger.settings.RearrangerSettings;
import javax.swing.*;
import javax.swing.tree.DefaultMutableTreeNode;
import java.lang.reflect.Modifier;
/** Represents a class initializer. */
public class ClassInitializerEntry
extends ClassContentsEntry
{
private static final Logger LOG = Logger.getInstance("#" + ClassInitializerEntry.class.getName());
public ClassInitializerEntry(final PsiElement start,
final PsiElement end,
final int modifiers,
final String modifierString,
final String name)
{
super(start, end, modifiers, modifierString, name, "");
}
public String getTypeIconName() {
final String name = Modifier.isStatic(getModifiers()) ? "nodes/StaticClassInitializer" : "nodes/ClassInitializer";
return name;
}
public String[] getAdditionalIconNames() {
return null;
}
public JLabel getPopupEntryText(RearrangerSettings settings) {
return new JLabel(Modifier.isStatic(getModifiers()) ? "<static class initializer>" : "<class initializer>");
}
public DefaultMutableTreeNode addToPopupTree(DefaultMutableTreeNode parent, RearrangerSettings settings) {
LOG.debug("add class initializer to popup tree");
DefaultMutableTreeNode node = new RearrangerTreeNode(this, myName);
parent.add(node);
return node;
}
}
plugins/rearranger/src/com/wrq/rearranger/entry/FieldEntry.java
-116
View File
@@ -1,116 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.entry;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiField;
import com.intellij.psi.PsiModifier;
import com.intellij.psi.PsiModifierList;
import com.wrq.rearranger.rearrangement.Emitter;
import com.wrq.rearranger.settings.RearrangerSettings;
import javax.swing.*;
import javax.swing.tree.DefaultMutableTreeNode;
/** Represents a member field of a class. */
public class FieldEntry
extends ClassContentsEntry
{
/**
* If Keep Getters/Setters With Property is true, and if this field is a property, then a reference to the
* property's getter (primary) method is stored here. That method is removed from the list of entries considered
* for rule matching. This field is responsible for emitting that method.
*/
MethodEntry getterMethod;
public FieldEntry(final PsiElement start,
final PsiElement end,
final int modifiers,
final String modifierString,
final String name,
final String type)
{
super(start, end, modifiers, modifierString, name, type);
getterMethod = null;
}
public String getTypeIconName() {
if (myEnd instanceof PsiField) {
PsiField f = (PsiField)myEnd;
return ((PsiModifierList)f.getModifierList()).hasModifierProperty(PsiModifier.STATIC) ? "nodes/staticField" : "nodes/field";
}
return null;
}
public String[] getAdditionalIconNames() {
if (myEnd instanceof PsiField) {
PsiField f = (PsiField)myEnd;
if (f.getModifierList().hasModifierProperty(PsiModifier.PUBLIC)) return new String[]{"nodes/c_public"};
if (f.getModifierList().hasModifierProperty(PsiModifier.PROTECTED)) return new String[]{"nodes/c_protected"};
if (f.getModifierList().hasModifierProperty(PsiModifier.PRIVATE)) return new String[]{"nodes/c_private"};
return new String[]{"nodes/c_plocal"};
}
return null;
}
public JLabel getPopupEntryText(RearrangerSettings settings) {
StringBuffer name = new StringBuffer(80);
PsiField f = (PsiField)myEnd;
name.append(f.getName());
name.append(": ");
name.append(f.getTypeElement().getText());
if (f.getInitializer() != null && f.getInitializer().getText().indexOf('\n') < 0) {
name.append(" = ");
name.append(f.getInitializer().getText());
}
return new JLabel(name.toString());
}
public DefaultMutableTreeNode addToPopupTree(DefaultMutableTreeNode parent, RearrangerSettings settings) {
DefaultMutableTreeNode node = super.addToPopupTree(parent, settings);
if (node != null && getterMethod != null) {
getterMethod.addToPopupTree(node, settings);
for (MethodEntry me : getterMethod.myCorrespondingGetterSetters) {
me.addToPopupTree(node, settings);
}
}
return node;
}
public void emit(Emitter emitter) {
super.emit(emitter);
/**
* emit setters/getters if they are kept with the property.
*/
if (getterMethod != null) {
getterMethod.emit(emitter);
}
}
public MethodEntry getGetterMethod() {
return getterMethod;
}
public void setGetterMethod(MethodEntry getterMethod) {
this.getterMethod = getterMethod;
}
}
plugins/rearranger/src/com/wrq/rearranger/entry/MemberAttributes.java
-41
View File
@@ -1,41 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.entry;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiClassInitializer;
import com.intellij.psi.PsiField;
import com.intellij.psi.PsiMethod;
/** Temporary structure to accumulate attributes during parsing, before final RangeEntry is created. */
public class MemberAttributes {
String name = "";
String type = "";
String interfaceName = null;
PsiField field = null;
PsiMethod method = null;
PsiClass childClass = null;
PsiClassInitializer classInitializer = null;
int modifiers = 0;
String modifierString = "";
int nParameters = 0;
}
plugins/rearranger/src/com/wrq/rearranger/entry/MethodEntry.java
-1282
View File
File diff suppressed because it is too large Load Diff
plugins/rearranger/src/com/wrq/rearranger/entry/MiscellaneousTextEntry.java
-69
View File
@@ -1,69 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.entry;
import com.intellij.psi.PsiElement;
import com.wrq.rearranger.settings.RearrangerSettings;
import org.jetbrains.annotations.Nullable;
import javax.swing.*;
/** Corresponds to comments and whitespace that surround Java syntactic items like classes and methods. */
public class MiscellaneousTextEntry extends ClassContentsEntry {
public MiscellaneousTextEntry(final PsiElement start,
final PsiElement end,
final boolean fixedHeader,
final boolean fixedTrailer)
{
super(start, end, fixedHeader, fixedTrailer);
}
@Nullable
public String getTypeIconName() {
// do not show headers and trailers in the file structure popup.
return null;
}
public String[] getAdditionalIconNames() {
return null;
}
@Nullable
public JLabel getPopupEntryText(RearrangerSettings settings) {
return null;
}
public String toString() {
String result;
if (isFixedHeader()) {
result = "Header";
}
else {
result = "Trailer";
}
if (myAlternateValue != null) {
result += "; comments removed";
}
return result;
}
}
plugins/rearranger/src/com/wrq/rearranger/entry/PopupTreeRangeEntry.java
-43
View File
@@ -1,43 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.entry;
import com.wrq.rearranger.settings.RearrangerSettings;
import javax.swing.tree.DefaultMutableTreeNode;
/**
* User: davek
* Date: Feb 18, 2004
* Time: 9:17:56 AM
*/
public interface PopupTreeRangeEntry {
/**
* Gives individual entries control over their appearance, depending on settings.
*
* @param parent DefaultMutableTreeNode to which this entry will be appended as a child.
* @param settings current Rearranger settings
* @return new DefaultMutableTreeNode
*/
DefaultMutableTreeNode addToPopupTree(DefaultMutableTreeNode parent, RearrangerSettings settings);
}
plugins/rearranger/src/com/wrq/rearranger/entry/PsiFileEntry.java
-91
View File
@@ -1,91 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.entry;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiComment;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiWhiteSpace;
import com.wrq.rearranger.settings.RearrangerSettings;
import org.jetbrains.annotations.NotNull;
import java.util.List;
/**
* Dummy "outer class" which actually corresponds to the PsiFile. Since classes contain
* header text (text from the beginning of the class until the first recognized member), one or more
* members, and trailing text, we can create a dummy "class" which will parse the file. Header text
* will include the package and import statements, and outer classes will be its members.
*/
public class PsiFileEntry extends ClassEntry {
public PsiFileEntry(@NotNull RearrangerSettings settings) {
super(null, null, 0, "", null, 0, settings);
}
/**
* Strips off leading elements which do not belong to the first class, and place them in
* a MiscellaneousText entry.
*
*
* @param project
* @param psiFile
* @return
*/
public List<ClassContentsEntry> parseFile(Project project, PsiElement psiFile) {
int startingIndex = 0;
// TODO den re-write to the 'firstChild & nextSibling'
for (int i = 0; i < psiFile.getChildren().length; i++) {
PsiElement child = psiFile.getChildren()[i];
if (child instanceof PsiClass) {
do {
startingIndex = i;
i--;
if (i >= 0) {
child = psiFile.getChildren()[i];
}
else {
break;
}
}
while (child instanceof PsiWhiteSpace ||
child instanceof PsiComment ||
child.getText().length() == 0);
break;
}
}
MiscellaneousTextEntry miscellaneousTextEntry = null;
if (startingIndex > 0) {
miscellaneousTextEntry = new MiscellaneousTextEntry(
psiFile.getChildren()[0],
psiFile.getChildren()[startingIndex - 1],
true, false
);
}
parseRemainingClassContents(project, startingIndex, psiFile);
if (miscellaneousTextEntry != null) {
myContents.add(0, miscellaneousTextEntry);
}
return myContents;
}
}
plugins/rearranger/src/com/wrq/rearranger/entry/RangeEntry.java
-300
View File
@@ -1,300 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.entry;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.editor.Document;
import com.intellij.openapi.util.TextRange;
import com.intellij.psi.PsiElement;
import com.wrq.rearranger.popup.RearrangerTreeNode;
import com.wrq.rearranger.rearrangement.Emitter;
import com.wrq.rearranger.ruleinstance.RuleInstance;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.util.CommentUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import javax.swing.tree.DefaultMutableTreeNode;
import java.util.regex.Matcher;
/**
* Corresponds to Java syntactic items ("entries") like classes, fields, and methods. A range entry
* contains start and end Psi elements for each item (which could be identical), as well as modifier
* flags and special flags to mark any miscellaneous text or comments that precede or follow the item.
*/
abstract public class RangeEntry implements PopupTreeRangeEntry {
// ------------------------------ FIELDS ------------------------------
private static final Logger LOG = Logger.getInstance("#" + RangeEntry.class.getName());
String myAlternateValue;
final String myName;
protected final PsiElement myStart;
protected final PsiElement myEnd;
private final int myModifiers;
private final String myModifierString;
private final boolean myFixedHeader;
private final boolean myFixedTrailer;
private final String myType;
private RuleInstance myMatchedRule;
private boolean mySeparatorCommentPrecedes;
// --------------------------- CONSTRUCTORS ---------------------------
public RangeEntry(@Nullable final PsiElement start,
@Nullable final PsiElement end,
final boolean fixedHeader,
final boolean fixedTrailer)
{
this(start, end, 0, "", "", "", fixedHeader, fixedTrailer);
}
RangeEntry(@Nullable final PsiElement start,
@Nullable final PsiElement end,
final int modifiers,
final String modifierString,
@Nullable final String name,
final String type)
{
this(start, end, modifiers, modifierString, name, type, false, false);
}
private RangeEntry(@Nullable final PsiElement start,
@Nullable final PsiElement end,
final int modifiers,
final String modifierString,
@Nullable final String name,
final String type,
final boolean fixedHeader,
final boolean fixedTrailer)
{
myStart = start;
myEnd = end;
myModifiers = modifiers;
myModifierString = modifierString;
myFixedHeader = fixedHeader;
myFixedTrailer = fixedTrailer;
myName = name;
myType = type;
myAlternateValue = null;
}
// --------------------- GETTER / SETTER METHODS ---------------------
public PsiElement getEnd() {
return myEnd;
}
public RuleInstance getMatchedRule() {
return myMatchedRule;
}
public void setMatchedRule(RuleInstance matchedRule) {
this.myMatchedRule = matchedRule;
}
public int getModifiers() {
return myModifiers;
}
public String getModifierString() {
return myModifierString;
}
public String getName() {
return myName;
}
public String getType() {
return myType;
}
public PsiElement getStart() {
return myStart;
}
public boolean isFixedHeader() {
return myFixedHeader;
}
public boolean isFixedTrailer() {
return myFixedTrailer;
}
// ------------------------ CANONICAL METHODS ------------------------
public String toString() {
String result = (myName == null ? "<unnamed>" : myName);
if (myStart != null && myEnd != null) {
result += "; range from " +
myStart.toString() +
" [" +
myStart.getTextRange().getStartOffset() +
"] to " +
myEnd.toString() +
" [" +
myEnd.getTextRange().getEndOffset() +
"]; modifiers=0x" +
Integer.toHexString(myModifiers);
}
else {
result += "; no start/end specified";
}
if (myFixedHeader) {
result = "Header: " + result;
}
if (myFixedTrailer) {
result = "Trailer: " + result;
}
if (myAlternateValue != null) {
result += "; comments removed";
}
return result;
}
// ------------------------ INTERFACE METHODS ------------------------
// --------------------- Interface IPopupTreeRangeEntry ---------------------
public DefaultMutableTreeNode addToPopupTree(DefaultMutableTreeNode parent, RearrangerSettings settings) {
DefaultMutableTreeNode myNode = new RearrangerTreeNode(this, myName);
parent.add(myNode);
return myNode;
}
// -------------------------- OTHER METHODS --------------------------
public void checkForComment() {
if (CommentUtil.getCommentMatchers().isEmpty()) {
return;
}
createAlternateValueString();
// For each separator comment specified by the user, check to see if this comment matches.
for (Matcher matcher : CommentUtil.getCommentMatchers()) {
matcher.reset(myAlternateValue);
boolean foundMatch = matcher.find();
if (foundMatch) {
LOG.debug("found comment pattern '" +
matcher.pattern().pattern().replaceAll("\n", "#") +
"' in '" +
myAlternateValue.replaceAll("\n", "#") +
"'");
StringBuffer sb = new StringBuffer(myAlternateValue.length());
do {
boolean leadingNewlines = myStart.getTextRange().getStartOffset() > 0;
matcher.appendReplacement(sb,
leadingNewlines ? "\n" : "");
foundMatch = matcher.find();
}
while (foundMatch);
matcher.appendTail(sb);
myAlternateValue = sb.toString();
LOG.debug("RangeEntry alternateValue=" + myAlternateValue.replaceAll("\n", "#"));
}
}
}
protected void createAlternateValueString() {
if (myAlternateValue != null) {
return;
}
final StringBuilder sb = new StringBuilder(myEnd.getTextRange().getEndOffset() - myStart.getTextRange().getStartOffset());
PsiElement e = myStart;
while (e != null && e != myEnd) {
if (e == myEnd.getParent()) {
e = e.getFirstChild();
}
else {
sb.append(e.getText());
e = e.getNextSibling();
}
}
if (e == myEnd) {
sb.append(myEnd.getText());
}
myAlternateValue = sb.toString();
}
public void emit(Emitter emitter) {
emitAllElements(emitter.getTextBuffer(), emitter.getDocument());
}
protected void emitAllElements(StringBuilder buffer, Document document) {
if (myAlternateValue != null) {
String result = myAlternateValue;
if (mySeparatorCommentPrecedes) {
// remove all leading blank lines. The only blank lines we want are the ones explicitly appended
// to the preceding separator comment.
LOG.debug("emitAllElements: separator comment precedes " +
myName + "; original value=" +
myAlternateValue.replaceAll("\n", "#"));
result = myAlternateValue.replaceFirst("\n[ \t\n]*\n", "\n");
LOG.debug("emitAllElements: resulting value=" +
myAlternateValue.replaceAll("\n", "#"));
}
buffer.append(result);
}
else {
PsiElement curr = myStart;
while (curr != null && curr != myEnd) {
if (curr == myEnd.getParent()) {
curr = curr.getFirstChild();
}
else {
emitElement(curr, buffer, document);
curr = curr.getNextSibling();
}
}
if (curr == myEnd && myEnd != null) {
emitElement(myEnd, buffer, document);
}
}
}
private static void emitElement(@NotNull final PsiElement curr, @NotNull final StringBuilder sb, @NotNull final Document document) {
final TextRange range = curr.getTextRange();
try {
sb.append(document.getCharsSequence(), range.getStartOffset(), range.getEndOffset());
}
catch (ArrayIndexOutOfBoundsException oob) {
LOG.error("internal error attempting to append text to document");
LOG.error("document.getCharsSequence.length=" + document.getCharsSequence().length());
LOG.error("document.getCharsSequence.toString().length=" + document.getCharsSequence().toString().length());
LOG.error("document...toCharArray.length=" + document.getCharsSequence().toString().toCharArray().length);
LOG.error("current PSI element=" + curr.toString());
LOG.error("current PSI element text=" + curr.getText());
LOG.error("current PSI element text range, start offset=" + range.getStartOffset());
LOG.error("current PSI element text range, end offset=" + range.getEndOffset());
LOG.error("current PSI element text range, length=" + range.getLength());
LOG.error(oob);
throw oob;
}
}
public void setSeparatorCommentPrecedes(boolean precedes) {
this.mySeparatorCommentPrecedes = precedes;
LOG.debug("emitAllElements: set separator comment precedes " + myName);
}
}
plugins/rearranger/src/com/wrq/rearranger/entry/RelatableEntry.java
-61
View File
@@ -1,61 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.entry;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.settings.RelatedMethodsSettings;
import java.util.List;
/**
* Defines methods implemented by entries which may be related to others, i.e. getters and setters,
* method entries which call other methods, and overloaded method entries.
*/
public interface RelatableEntry {
/**
* Determine if the entry is a getter/setter or is excluded from extracted method consideration by an
* overriding rule.
*/
void determineGetterSetterAndExtractedMethodStatus(RearrangerSettings settings);
/**
* Determine corresponding setters for getters and identify related methods.
*
* @param settings current settings, containing extracted/related method options.
* @param contents contents of class, containing potentially related methods.
*/
void determineSettersAndMethodCalls(RearrangerSettings settings,
List<ClassContentsEntry> contents);
/**
* Decide if a method is an extracted method. It is an extracted method if:
* - it is called by at least one other method, and
* - it is private, or passes the "never / 1 / >1" caller test.
*/
void determineExtractedMethod(RelatedMethodsSettings settings);
/** @return true if the method is related to another. In this case, the method is exempt from rule matching. */
boolean isRelatedMethod();
/** @return true if the method is a setter and will be emitted below a corresponding getter. */
boolean isEmittableSetter();
}
plugins/rearranger/src/com/wrq/rearranger/popup/FilePopupEntry.java
-45
View File
@@ -1,45 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.popup;
import com.wrq.rearranger.settings.RearrangerSettings;
import org.jetbrains.annotations.Nullable;
import javax.swing.*;
/** Interface implemented by objects which can appear as entries in the file structure popup. */
public interface FilePopupEntry {
/** @return the name of the icon representing the popup entry's type of Java object (method, class, etc.) */
@Nullable
String getTypeIconName();
/**
* @return the names of the icon representing the protection level of the popup entry, and any other
* icons (overrides/overriding/implements/implementing).
*/
@Nullable
String[] getAdditionalIconNames();
/** @return a JLabel containing the text of the popup tree entry. */
@Nullable
JLabel getPopupEntryText(RearrangerSettings settings);
}
plugins/rearranger/src/com/wrq/rearranger/popup/FileStructurePopup.java
-352
View File
@@ -1,352 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.popup;
import com.intellij.psi.PsiFile;
import com.wrq.rearranger.ruleinstance.RuleInstance;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.util.Constraints;
import com.wrq.rearranger.util.IconUtil;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.ArrayList;
import java.util.List;
/** Contains code to pop up a file structure dialog, showing proposed rearrangement. */
public class FileStructurePopup
implements IHasScrollPane
{
final RearrangerSettings settings;
final PopupTreeComponent treeComponent;
public FileStructurePopup(RearrangerSettings settings,
List<RuleInstance> resultRuleInstances,
final FilePopupEntry psiFileEntry)
{
this.settings = settings;
treeComponent = new PopupTreeComponent(settings, resultRuleInstances, psiFileEntry);
}
public FileStructurePopup(RearrangerSettings settings,
List<RuleInstance> resultRuleInstances,
final PsiFile psiFile)
{
this.settings = settings;
FilePopupEntry psiFileEntry = new FilePopupEntry() {
public String getTypeIconName() {
return "ppFile";
}
public String[] getAdditionalIconNames() {
return null;
}
public JLabel getPopupEntryText(RearrangerSettings settings) {
return new JLabel(psiFile.getName());
}
};
treeComponent = new PopupTreeComponent(settings, resultRuleInstances, psiFileEntry);
}
/**
* Display a pane showing the rearrangement.
*
* @return true if rearrangement should take place
*/
public boolean displayRearrangement() {
JPanel containerPanel = getContainerPanel();
JOptionPane pane = new JOptionPane(
containerPanel,
JOptionPane.PLAIN_MESSAGE,
JOptionPane.OK_CANCEL_OPTION
);
JDialog dialog = pane.createDialog(null, "Rearrangement Results");
dialog.setResizable(true);
dialog.setVisible(true);
Object selectedValue = pane.getValue();
return ((Integer)selectedValue) == JOptionPane.OK_OPTION;
}
// Level 2 methods
private JPanel getContainerPanel() {
final JPanel containerPanel = new JPanel(new GridBagLayout());
final GridBagConstraints scrollPaneConstraints = new GridBagConstraints();
Constraints constraints = new Constraints(GridBagConstraints.NORTHWEST);
final JScrollPane treeView = getScrollPane();
final JComponent showTypesBox =
new IconBox(containerPanel, scrollPaneConstraints, this) {
boolean getSetting() {
return settings.isShowParameterTypes();
}
void setSetting(boolean value) {
settings.setShowParameterTypes(value);
}
Icon getIcon() {
return IconUtil.getIcon("ShowParamTypes");
}
String getToolTipText() {
return "Show parameter types";
}
int getShortcut() {
return KeyEvent.VK_T;
}
}.getIconBox();
final JComponent showNamesBox =
new IconBox(containerPanel, scrollPaneConstraints, this) {
boolean getSetting() {
return settings.isShowParameterNames();
}
void setSetting(boolean value) {
settings.setShowParameterNames(value);
}
Icon getIcon() {
return IconUtil.getIcon("ShowParamNames");
}
String getToolTipText() {
return "Show parameter names";
}
int getShortcut() {
return KeyEvent.VK_N;
}
}.getIconBox();
final JComponent showFieldsBox =
new IconBox(containerPanel, scrollPaneConstraints, this) {
boolean getSetting() {
return settings.isShowFields();
}
void setSetting(boolean value) {
settings.setShowFields(value);
}
Icon getIcon() {
return IconUtil.getIcon("ShowFields");
}
String getToolTipText() {
return "Show fields";
}
int getShortcut() {
return KeyEvent.VK_F;
}
}.getIconBox();
final JComponent showTypeAfterMethodBox =
new IconBox(containerPanel, scrollPaneConstraints, this) {
boolean getSetting() {
return settings.isShowTypeAfterMethod();
}
void setSetting(boolean value) {
settings.setShowTypeAfterMethod(value);
}
Icon getIcon() {
return IconUtil.getIcon("ShowTypeAfterMethod");
}
String getToolTipText() {
return "Show type after method";
}
int getShortcut() {
return KeyEvent.VK_A;
}
}.getIconBox();
final JComponent showRulesBox =
new IconBox(containerPanel, scrollPaneConstraints, this) {
boolean getSetting() {
return settings.isShowRules();
}
void setSetting(boolean value) {
settings.setShowRules(value);
}
Icon getIcon() {
return IconUtil.getIcon("ShowRules");
}
String getToolTipText() {
return "Show rules";
}
int getShortcut() {
return KeyEvent.VK_R;
}
}.getIconBox();
final JComponent showMatchedRulesBox =
new IconBox(containerPanel, scrollPaneConstraints, this) {
boolean getSetting() {
return settings.isShowMatchedRules();
}
void setSetting(boolean value) {
settings.setShowMatchedRules(value);
}
Icon getIcon() {
return IconUtil.getIcon("ShowMatchedRules");
}
String getToolTipText() {
return "Show matched rules only";
}
int getShortcut() {
return KeyEvent.VK_M;
}
}.getIconBox();
final JComponent showCommentsBox =
new IconBox(containerPanel, scrollPaneConstraints, this) {
boolean getSetting() {
return settings.isShowComments();
}
void setSetting(boolean value) {
settings.setShowComments(value);
}
Icon getIcon() {
return IconUtil.getIcon("ShowComments");
}
String getToolTipText() {
return "Show generated separator comments";
}
int getShortcut() {
return KeyEvent.VK_C;
}
}.getIconBox();
((JCheckBox)showRulesBox.getComponent(0)).addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
showMatchedRulesBox.setEnabled(((JCheckBox)showRulesBox.getComponent(0)).isSelected());
}
}
);
showMatchedRulesBox.setEnabled(((JCheckBox)showRulesBox.getComponent(0)).isSelected());
scrollPaneConstraints.insets = new Insets(3, 3, 3, 3);
scrollPaneConstraints.fill = GridBagConstraints.BOTH;
scrollPaneConstraints.gridwidth = GridBagConstraints.REMAINDER;
scrollPaneConstraints.gridheight = GridBagConstraints.REMAINDER;
scrollPaneConstraints.weightx = 1;
scrollPaneConstraints.weighty = 1;
scrollPaneConstraints.gridx = 0;
scrollPaneConstraints.gridy = 1;
constraints.insets = new Insets(5, 5, 5, 5);
containerPanel.add(showTypesBox, constraints.firstCol());
containerPanel.add(showNamesBox, constraints.nextCol());
containerPanel.add(showFieldsBox, constraints.nextCol());
containerPanel.add(showTypeAfterMethodBox, constraints.nextCol());
containerPanel.add(showCommentsBox, constraints.nextCol());
containerPanel.add(showRulesBox, constraints.nextCol());
containerPanel.add(showMatchedRulesBox, constraints.lastCol());
containerPanel.add(treeView, scrollPaneConstraints);
return containerPanel;
}
/**
* build a JTree containing classes, fields and methods, in accordance with settings.
*
* @return
*/
public JScrollPane getScrollPane() {
// Create the nodes.
JTree tree = treeComponent.createTree();
/** expand all nodes. */
for (int i = 0; i < tree.getRowCount(); i++) {
tree.expandRow(i);
}
JScrollPane treeView = new JScrollPane(tree);
treeView.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
treeView.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
Dimension d = treeView.getPreferredSize();
if (d.width < 400) d.width = 400;
if (d.height < 300) d.height = 300;
treeView.setPreferredSize(d);
return treeView;
}
public static void main(String[] args) {
final RearrangerSettings settings = new RearrangerSettings();
FilePopupEntry pf = new FilePopupEntry() {
public String getTypeIconName() {
return "nodes/ppFile";
}
public String[] getAdditionalIconNames() {
return null;
}
public JLabel getPopupEntryText(RearrangerSettings settings) {
return new JLabel("FileName.java");
}
};
FileStructurePopup fsp = new FileStructurePopup(settings, new ArrayList<RuleInstance>(), pf);
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
}
catch (Exception e) {
}
final JFrame frame = new JFrame("SwingApplication");
final GridBagConstraints constraints = new GridBagConstraints();
constraints.anchor = GridBagConstraints.NORTHWEST;
constraints.fill = GridBagConstraints.BOTH;
constraints.weightx = 1.0d;
constraints.weighty = 1.0d;
constraints.gridwidth = GridBagConstraints.REMAINDER;
constraints.gridx = 0;
constraints.gridy = 0;
final JPanel object = fsp.getContainerPanel();
frame.getContentPane().setLayout(new GridBagLayout());
frame.getContentPane().add(object, constraints);
//Finish setting up the frame, and show it.
frame.addWindowListener(
new WindowAdapter() {
public void windowClosing(final WindowEvent e) {
System.exit(0);
}
}
);
frame.pack();
frame.setVisible(true);
}
}
plugins/rearranger/src/com/wrq/rearranger/popup/IHasScrollPane.java
-32
View File
@@ -1,32 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.popup;
import javax.swing.*;
/**
* Interface implemented by popups (LiveRearrangerPopup, FileStructurePopup) to (re)create the scrollpane when
* the underlying tree changes.
*/
public interface IHasScrollPane {
public JScrollPane getScrollPane();
}
plugins/rearranger/src/com/wrq/rearranger/popup/ILiveRearranger.java
-34
View File
@@ -1,34 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.popup;
import com.wrq.rearranger.ruleinstance.RuleInstance;
import java.util.List;
public interface ILiveRearranger {
void setRearrangementOccurred(boolean rearrangementOccurred);
void setResultRuleInstances(List<RuleInstance> resultRuleInstances);
void liveRearranger();
}
plugins/rearranger/src/com/wrq/rearranger/popup/IconBox.java
-229
View File
@@ -1,229 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.popup;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.util.Constraints;
import com.wrq.rearranger.util.IconUtil;
import javax.swing.*;
import javax.swing.border.Border;
import java.awt.*;
import java.awt.event.*;
/**
* Contains enough information to construct a checkbox with the given icon and tooltip
* text, related to a setting.
*/
abstract class IconBox {
static final Color mouseoverColor = new Color(181, 190, 214);
static final Color selectedColor = new Color(132, 146, 189);
static final Color outlineColor = new Color(8, 36, 107);
final JPanel containerPanel;
final GridBagConstraints constraints;
final IHasScrollPane scrollPaneComponent;
protected IconBox(JPanel containerPanel,
GridBagConstraints constraints,
IHasScrollPane scrollPaneComponent)
{
this.containerPanel = containerPanel;
this.constraints = constraints;
this.scrollPaneComponent = scrollPaneComponent;
}
abstract boolean getSetting();
abstract void setSetting(boolean value);
abstract Icon getIcon();
abstract String getToolTipText();
abstract int getShortcut();
class MouseBox
extends JCheckBox
{
boolean mouseOver;
public MouseBox(Icon icon) {
super(icon);
}
}
class MyAction
extends AbstractAction
{
final MouseBox box;
public MyAction(String name, MouseBox box) {
super(name);
this.box = box;
}
public void actionPerformed(ActionEvent e) {
//To change body of implemented methods use File | Settings | File Templates.
box.getActionMap().get("pressed").actionPerformed(e);
box.getActionMap().get("released").actionPerformed(e);
}
}
public JPanel getIconBox() {
final JPanel result = new JPanel(new GridBagLayout());
final Icon icon = getIcon();
final MouseBox box = new MouseBox(icon);
box.setToolTipText(getToolTipText());
box.setSelected(getSetting());
box.setBackground(box.isSelected() ? selectedColor : null);
setOutline(result, box.isSelected());
final MyAction myAction = new MyAction("toggleButton", box);
box.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
setAction(box, (JPanel)box.getParent());
}
}
);
box.setFocusable(false);
box.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(
KeyStroke.getKeyStroke(
getShortcut(),
InputEvent.ALT_DOWN_MASK
),
"toggleButton"
);
box.getActionMap().put("toggleButton", myAction);
box.addMouseListener(
new MouseAdapter() {
public void mouseEntered(MouseEvent e) {
box.mouseOver = true;
if (!box.isSelected()) {
box.setBackground(mouseoverColor);
setOutline(result, true);
}
}
public void mouseExited(MouseEvent e) {
box.mouseOver = false;
if (!box.isSelected()) {
box.setBackground(null);
setOutline(result, false);
}
}
}
);
result.add(box);
return result;
}
private void setAction(final MouseBox box, final JPanel result) {
setSetting(box.isSelected());
box.setBackground(box.isSelected() ? selectedColor : box.mouseOver ? mouseoverColor : null);
setOutline(result, box.mouseOver);
int lastIndex = containerPanel.getComponentCount() - 1;
containerPanel.remove(lastIndex);
final JScrollPane scrollPane = scrollPaneComponent.getScrollPane();
containerPanel.add(scrollPane, constraints, lastIndex);
scrollPane.invalidate();
containerPanel.validate();
}
/**
* draws a nearly-black outline border around the button (or removes such border).
*
* @param panel JPanel which contains the button.
* @param outline if true, draw the outline.
*/
private void setOutline(JPanel panel, boolean outline) {
Color borderColor = outline ? outlineColor : ((java.awt.Color)panel.getBackground());
Border b = BorderFactory.createLineBorder(borderColor);
panel.setBorder(b);
}
public static void main(String[] args) {
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
}
catch (Exception e) {
}
final JFrame frame = new JFrame("IconBox test");
final Constraints constraints = new Constraints(GridBagConstraints.NORTHWEST);
constraints.fill = GridBagConstraints.BOTH;
constraints.weightedLastRow();
frame.getContentPane().setLayout(new GridBagLayout());
JPanel panel = new JPanel(new GridBagLayout());
frame.getContentPane().add(panel, constraints.weightedLastCol());
constraints.fill = GridBagConstraints.NONE;
constraints.gridheight = 1;
constraints.weighty = 0;
IHasScrollPane scroll = new IHasScrollPane() {
public JScrollPane getScrollPane() {
return new JScrollPane(new JLabel("scroll pane contents"));
}
};
final RearrangerSettings settings = new RearrangerSettings();
IconBox box = new IconBox(panel, constraints, scroll) {
boolean getSetting() {
return settings.isShowComments();
}
void setSetting(boolean value) {
settings.setShowComments(value);
}
Icon getIcon() {
return IconUtil.getIcon("ShowComments");
}
String getToolTipText() {
return "Show comments (Alt+C)";
}
int getShortcut() {
return KeyEvent.VK_C;
}
};
panel.add(box.getIconBox(), constraints);
constraints.weightedLastRow();
constraints.fill = GridBagConstraints.BOTH;
JScrollPane firstPane = new JScrollPane(new JLabel("first scrollpane"));
panel.add(firstPane, constraints);
//Finish setting up the frame, and show it.
frame.addWindowListener(
new WindowAdapter() {
public void windowClosing(final WindowEvent e) {
System.exit(0);
}
}
);
frame.pack();
frame.setVisible(true);
}
}
plugins/rearranger/src/com/wrq/rearranger/popup/LiveRearrangerDialog.java
-321
View File
@@ -1,321 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.popup;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.editor.Document;
import com.intellij.psi.PsiFile;
import com.wrq.rearranger.LiveRearrangerActionHandler;
import com.wrq.rearranger.rearrangement.Emitter;
import com.wrq.rearranger.ruleinstance.RuleInstance;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.util.Constraints;
import com.wrq.rearranger.util.IconUtil;
import javax.swing.*;
import java.awt.*;
import java.awt.dnd.DnDConstants;
import java.awt.event.KeyEvent;
import java.util.List;
/**
* Contains logic to display a rearrangement dialog, allow user to perform drag&drop rearrangement, and
* rearrange the code accordingly.
*/
public class LiveRearrangerDialog
implements IHasScrollPane,
ILiveRearranger
{
private static final Logger LOG = Logger.getInstance("#" + LiveRearrangerDialog.class.getName());
final RearrangerSettings settings;
PopupTreeComponent treeComponent;
List<RuleInstance> myResultRuleInstances;
final Window outerPanel;
final Document document;
final PsiFile psiFile;
FilePopupEntry myPsiFileEntry;
TreeDragSource tds;
TreeDropTarget tdt;
boolean rearrangementOccurred = false;
private JPanel containerPanel;
int cursorOffset;
private PopupTree popupTree;
private void createFilePopupEntry(final PsiFile psiFile) {
myPsiFileEntry = new FilePopupEntry() {
public String getTypeIconName() {
return "nodes/ppFile";
}
public String[] getAdditionalIconNames() {
return null;
}
public JLabel getPopupEntryText(RearrangerSettings settings) {
return new JLabel(psiFile.getName());
}
};
}
public LiveRearrangerDialog(RearrangerSettings settings, PsiFile psiFile, Document document,
final Window outerPanel, int cursorOffset)
{
this.settings = settings;
this.document = document;
this.psiFile = psiFile;
createFilePopupEntry(psiFile);
this.outerPanel = outerPanel;
this.cursorOffset = cursorOffset;
}
public void setRearrangementOccurred(boolean rearrangementOccurred) {
this.rearrangementOccurred = rearrangementOccurred;
}
public void setResultRuleInstances(List<RuleInstance> resultRuleInstances) {
this.myResultRuleInstances = resultRuleInstances;
treeComponent = new PopupTreeComponent(settings, resultRuleInstances, myPsiFileEntry);
}
/** Display a live rearrangement window. */
public void liveRearranger() {
containerPanel = getContainerPanel();
JOptionPane pane = new JOptionPane(
containerPanel,
JOptionPane.PLAIN_MESSAGE,
JOptionPane.OK_CANCEL_OPTION
);
JDialog dialog = pane.createDialog(null, "Live Rearranger");
dialog.setResizable(true);
dialog.setVisible(true);
Object selectedValue = pane.getValue();
rearrangementOccurred =
treeComponent.isRearrangementOccurred() &&
(popupTree.isExitedWithEnterKey() ||
(selectedValue != null &&
(((Integer)selectedValue) == JOptionPane.OK_OPTION)));
finish();
LOG.debug("exit liveRearranger");
}
public void finish() {
LOG.debug("entered finish() on thread " + Thread.currentThread().getName());
if (!rearrangementOccurred) {
LOG.debug("no rearrangement occurred, not rearranging document");
return;
}
LOG.debug("rearranging document");
if (document != null) {
final Emitter e = new Emitter(psiFile, myResultRuleInstances, document);
e.emitRearrangedDocument();
}
LiveRearrangerActionHandler.setInProgress(false);
LOG.debug("exit finish() on thread " + Thread.currentThread().getName());
}
private JPanel getContainerPanel() {
final JPanel containerPanel = new JPanel(new GridBagLayout());
final GridBagConstraints scrollPaneConstraints = new GridBagConstraints();
scrollPaneConstraints.insets = new Insets(3, 3, 3, 3);
scrollPaneConstraints.fill = GridBagConstraints.BOTH;
scrollPaneConstraints.gridwidth = GridBagConstraints.REMAINDER;
scrollPaneConstraints.gridheight = GridBagConstraints.REMAINDER;
scrollPaneConstraints.weightx = 1;
scrollPaneConstraints.weighty = 1;
scrollPaneConstraints.gridx = 0;
scrollPaneConstraints.gridy = 1;
final JScrollPane treeView = getScrollPane();
final JComponent showTypesBox =
new IconBox(containerPanel, scrollPaneConstraints, this) {
boolean getSetting() {
return settings.isShowParameterTypes();
}
void setSetting(boolean value) {
settings.setShowParameterTypes(value);
}
Icon getIcon() {
return IconUtil.getIcon("ShowParamTypes");
}
String getToolTipText() {
return "Show parameter types";
}
int getShortcut() {
return KeyEvent.VK_T;
}
}.getIconBox();
final JComponent showNamesBox =
new IconBox(containerPanel, scrollPaneConstraints, this) {
boolean getSetting() {
return settings.isShowParameterNames();
}
void setSetting(boolean value) {
settings.setShowParameterNames(value);
}
Icon getIcon() {
return IconUtil.getIcon("ShowParamNames");
}
String getToolTipText() {
return "Show parameter names";
}
int getShortcut() {
return KeyEvent.VK_N;
}
}.getIconBox();
final JComponent showFieldsBox =
new IconBox(containerPanel, scrollPaneConstraints, this) {
boolean getSetting() {
return settings.isShowFields();
}
void setSetting(boolean value) {
settings.setShowFields(value);
}
Icon getIcon() {
return IconUtil.getIcon("ShowFields");
}
String getToolTipText() {
return "Show fields";
}
int getShortcut() {
return KeyEvent.VK_F;
}
}.getIconBox();
final JComponent showTypeAfterMethodBox =
new IconBox(containerPanel, scrollPaneConstraints, this) {
boolean getSetting() {
return settings.isShowTypeAfterMethod();
}
void setSetting(boolean value) {
settings.setShowTypeAfterMethod(value);
}
Icon getIcon() {
return IconUtil.getIcon("ShowTypeAfterMethod");
}
String getToolTipText() {
return "Show type after method";
}
int getShortcut() {
return KeyEvent.VK_A;
}
}.getIconBox();
Constraints constraints = new Constraints(GridBagConstraints.NORTHWEST);
constraints.insets = new Insets(5, 5, 5, 5);
containerPanel.add(showTypesBox, constraints.firstCol());
containerPanel.add(showNamesBox, constraints.nextCol());
containerPanel.add(showFieldsBox, constraints.nextCol());
containerPanel.add(showTypeAfterMethodBox, constraints.lastCol());
containerPanel.add(treeView, scrollPaneConstraints);
return containerPanel;
}
/**
* build a JTree containing classes, fields and methods, in accordance with settings.
*
* @return
*/
public JScrollPane getScrollPane() {
// Create the nodes.
popupTree = treeComponent.createLiveRearrangerTree();
// /** only expand node where cursor is located. Inspect all rows; deepest node that covers
// * cursor location is the best to expand. (Parent node like a class contains a method where
// * the cursor is; we want to expand the method, not just the class.
// */
// int expandRow = -1;
// for (int i = 0; i < tree.getRowCount(); i++)
// {
// DefaultMutableTreeNode node = (DefaultMutableTreeNode) tree.getPathForRow(i).getLastPathComponent();
// if (node.getUserObject() instanceof RangeEntry)
// {
// RangeEntry re = (RangeEntry) node.getUserObject();
// if (re.getStart().getTextRange().getStartOffset() <= cursorOffset &&
// re.getEnd().getTextRange().getEndOffset() >= cursorOffset)
// {
// logger.debug(
// "node " +
// i +
// " contained cursor (offset=" +
// cursorOffset +
// "): " + re
// );
// expandRow = i;
// }
// }
// else
// {
// logger.debug("expand node candidate not RangeEntry; node=" + node);
// }
// }
// if (expandRow >= 0)
// {
// logger.debug("expand row " + expandRow);
// tree.expandRow(expandRow);
// }
/** simply expand all nodes. */
for (int i = 0; i < popupTree.getRowCount(); i++) {
popupTree.expandRow(i);
}
JScrollPane treeView = new JScrollPane(popupTree);
treeView.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
treeView.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
treeView.getVerticalScrollBar().setFocusable(false);
treeView.getHorizontalScrollBar().setFocusable(false);
Dimension d = treeView.getPreferredSize();
if (d.width < 400) d.width = 400;
if (d.height < 300) d.height = 300;
treeView.setPreferredSize(d);
tdt = new TreeDropTarget(popupTree, this);
tds = new TreeDragSource(popupTree, DnDConstants.ACTION_MOVE, tdt);
return treeView;
}
// class RearrangerTest
// extends LightCodeInsightTestCase
// {
// private RearrangerSettings rs;
//
// protected final void setUp() throws Exception
// {
// super.setUp();
// }
//
//
//
}
plugins/rearranger/src/com/wrq/rearranger/popup/LiveRearrangerPopup.java
-638
View File
@@ -1,638 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.popup;
import com.intellij.openapi.application.Application;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.command.CommandProcessor;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.editor.Document;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiFile;
import com.wrq.rearranger.LiveRearrangerActionHandler;
import com.wrq.rearranger.entry.RangeEntry;
import com.wrq.rearranger.rearrangement.Emitter;
import com.wrq.rearranger.ruleinstance.RuleInstance;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.util.IconUtil;
import javax.swing.*;
import javax.swing.border.Border;
import javax.swing.border.TitledBorder;
import javax.swing.tree.DefaultMutableTreeNode;
import java.awt.*;
import java.awt.dnd.DnDConstants;
import java.awt.event.*;
import java.lang.reflect.InvocationTargetException;
import java.util.List;
/**
* Contains logic to display a rearrangement popup, allow user to perform drag&drop rearrangement, and (when
* a keystroke is seen or a mouse click outside the popup occurs) rearrange the code accordingly.
*/
public class LiveRearrangerPopup
implements IHasScrollPane, ILiveRearranger
{
private static final Logger LOG = Logger.getInstance("#" + LiveRearrangerPopup.class.getName());
final RearrangerSettings settings;
PopupTreeComponent treeComponent;
List<RuleInstance> myResultRuleInstances;
final Window outerPanel;
final Document document;
final PsiFile psiFile;
FilePopupEntry myPsiFileEntry;
private WindowFocusListener windowFocusListener;
private WindowAdapter windowAdapter;
private MouseAdapter mouseAdapter;
private KeyEventDispatcher keyEventDispatcher;
private Popup popup;
// private JWindow popup;
TreeDragSource tds;
TreeDropTarget tdt;
boolean rearrangementOccurred = false;
private FocusAdapter focusAdapter;
private JPanel containerPanel;
private final Project project;
private Cursor oldCursor;
private MouseAdapter ma2;
int cursorOffset;
private Component outerPanelFocusOwner;
boolean sawKeyPressed = false;
public LiveRearrangerPopup(RearrangerSettings settings,
final FilePopupEntry psiFileEntry,
Window outerPanel,
Document document,
Project project)
{
LOG.debug("entered LiveRearrangerPopup constructor");
this.settings = settings;
this.outerPanel = outerPanel;
this.myPsiFileEntry = psiFileEntry;
this.document = document;
this.psiFile = null;
this.project = project;
}
private void createFilePopupEntry(final PsiFile psiFile) {
myPsiFileEntry = new FilePopupEntry() {
public String getTypeIconName() {
return "nodes/ppFile";
}
public String[] getAdditionalIconNames() {
return null;
}
public JLabel getPopupEntryText(RearrangerSettings settings) {
return new JLabel(psiFile.getName());
}
};
}
public LiveRearrangerPopup(RearrangerSettings settings, PsiFile psiFile, Document document, Project project,
final Window outerPanel, int cursorOffset)
{
this.settings = settings;
this.document = document;
this.psiFile = psiFile;
createFilePopupEntry(psiFile);
this.project = project;
this.outerPanel = outerPanel;
this.cursorOffset = cursorOffset;
try {
SwingUtilities.invokeAndWait(
new Runnable() {
public void run() {
// popup = new JWindow();
JPanel tempPanel = new JPanel(new GridBagLayout());
JLabel label = new JLabel("Live Rearranger parsing file...");
Border b = BorderFactory.createRaisedBevelBorder();
tempPanel.setBorder(b);
GridBagConstraints constraints = new GridBagConstraints();
constraints.insets = new Insets(5, 5, 5, 5);
tempPanel.add(label, constraints);
Dimension d = outerPanel.getSize();
Dimension c = tempPanel.getPreferredSize();
int x = (d.width - c.width) / 2;
int y = (d.height - c.height) / 2;
if (x < 0) x = 0;
if (y < 0) y = 0;
popup = PopupFactory.getSharedInstance().getPopup(outerPanel, tempPanel, x, y);
// popup.getContentPane().add(tempPanel);
// popup.setLocation(x, y);
LOG.debug("initial outerPanel size=" + d + ", tempPanel preferred size=" + c);
LOG.debug("Constructing initial Popup at x,y=" + x + "," + y);
// popup.pack();
// popup.setVisible(true);
// popup.requestFocusInWindow();
popup.show();
Cursor cu = Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR);
oldCursor = outerPanel.getCursor();
LOG.debug("setCursor (WAIT)" + cu + " on " + outerPanel);
outerPanel.setCursor(cu);
}
}
);
}
catch (InterruptedException ie) {
throw new RuntimeException(ie);
}
catch (InvocationTargetException ite) {
throw new RuntimeException(ite);
}
}
public void setRearrangementOccurred(boolean rearrangementOccurred) {
this.rearrangementOccurred = rearrangementOccurred;
}
public void setResultRuleInstances(List<RuleInstance> resultRuleInstances) {
this.myResultRuleInstances = resultRuleInstances;
treeComponent = new PopupTreeComponent(settings, resultRuleInstances, myPsiFileEntry);
}
/** Display a live rearrangement window. */
public void liveRearranger() {
try {
SwingUtilities.invokeAndWait(
new Runnable() {
public void run() {
containerPanel = getContainerPanel();
LOG.debug("containerPanel.isFocusable=" + containerPanel.isFocusable());
Border b = BorderFactory.createRaisedBevelBorder();
containerPanel.setBorder(b);
Dimension d = outerPanel.getSize();
Dimension c = containerPanel.getPreferredSize();
int x = (d.width - c.width) / 2;
int y = (d.height - c.height) / 2;
if (x < 0) x = 0;
if (y < 0) y = 0;
popup.hide(); // destroy initial (interim) popup
popup = PopupFactory.getSharedInstance().getPopup(outerPanel, containerPanel, x, y);
// popup = new JFrame();
// final Container contentPane = popup.getContentPane();
// contentPane.remove(0);
// contentPane.add(containerPanel);
// contentPane.validate();
// popup.setLocation(x, y);
LOG.debug("setCursor (original)" + oldCursor + " on " + outerPanel);
outerPanel.setCursor(oldCursor);
// logger.debug("set default cursor on " + popup);
// popup.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
// popup.repaint();
LOG.debug("outerPanel size=" + d + ", containerPanel preferred size=" + c);
LOG.debug("Constructing Popup at x,y=" + x + "," + y);
LiveRearrangerActionHandler.setInProgress(true);
// popup.addWindowFocusListener(windowFocusListener);
// popup.addWindowListener(windowAdapter);
// popup.addMouseListener(mouseAdapter);
// popup.addFocusListener(focusAdapter);
// contentPane.addFocusListener(focusAdapter);
outerPanel.addWindowFocusListener(
windowFocusListener = getWindowFocusListener("outerPanel")
);
outerPanel.addWindowListener(windowAdapter = getWindowAdapter("outerPanel"));
outerPanel.addMouseListener(mouseAdapter = getMouseAdapter("outerPanel"));
ma2 = getMouseAdapter("focus owner");
outerPanelFocusOwner = outerPanel.getFocusOwner();
if (outerPanelFocusOwner != null) {
outerPanelFocusOwner.addMouseListener(ma2);
}
outerPanel.addFocusListener(focusAdapter = getFocusAdapter("outerPanel"));
containerPanel.addFocusListener(getFocusAdapter("containerPanel"));
keyEventDispatcher = new KeyEventDispatcher() {
public boolean dispatchKeyEvent(KeyEvent e) {
LOG.debug(
"key event dispatcher: outerPanel isFocused=" +
outerPanel.isFocused() +
", rearrangementOccurred=" +
rearrangementOccurred +
" keyEvent=" +
e
);
if (e.getID() == KeyEvent.KEY_RELEASED &&
(rearrangementOccurred || sawKeyPressed))
{
LOG.debug("key event dispatcher: disposing popup, saw keyEvent " + e);
finish();
}
if (e.getID() == KeyEvent.KEY_PRESSED) {
sawKeyPressed = true;
}
return true;
}
};
KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(
keyEventDispatcher
);
// wasLightWeight = ToolTipManager.sharedInstance().isLightWeightPopupEnabled();
// ToolTipManager.sharedInstance().setLightWeightPopupEnabled(false);
popup.show();
// popup.setVisible(true);
}
}
);
}
catch (InterruptedException ie) {
throw new RuntimeException(ie);
}
catch (InvocationTargetException ite) {
throw new RuntimeException(ite);
}
LOG.debug("exit liveRearranger");
}
private MouseAdapter getMouseAdapter(final String component) {
return new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
LOG.debug(
component +
": mouse clicked at " +
e.getX() +
"," +
e.getY() +
"; window size/position is " +
outerPanel.getBounds()
);
LOG.debug("close popup and finish");
finish();
super.mouseClicked(e);
}
};
}
private FocusAdapter getFocusAdapter(final String component) {
return new FocusAdapter() {
public void focusGained(FocusEvent e) {
LOG.debug(component + ": focus gained");
}
public void focusLost(FocusEvent e) {
LOG.debug(component + ": focus lost, close popup & finish");
finish();
}
};
}
private WindowAdapter getWindowAdapter(final String component) {
return new WindowAdapter() {
public void windowLostFocus(WindowEvent e) {
LOG.debug(component + ": lost focus");
LOG.debug("close popup and finish");
finish();
}
public void windowClosing(WindowEvent e) {
LOG.debug(component + ": window closing");
}
};
}
private WindowFocusListener getWindowFocusListener(final String component) {
return new WindowFocusListener() {
public void windowGainedFocus(WindowEvent e) {
LOG.debug(component + ": gained window focus");
}
public void windowLostFocus(WindowEvent e) {
LOG.debug(component + ": lost window focus");
LOG.debug("close popup and finish");
finish();
}
};
}
public void finish() {
LOG.debug("entered finish() on thread " + Thread.currentThread().getName());
// popup.setVisible(false);
// popup.dispose();
// popup.removeWindowFocusListener(windowFocusListener);
// popup.removeWindowListener(windowAdapter);
// popup.removeMouseListener(mouseAdapter);
// popup.removeFocusListener(focusAdapter);
// popup.getContentPane().removeFocusListener(focusAdapter);
outerPanel.removeWindowFocusListener(windowFocusListener);
if (outerPanelFocusOwner != null) {
outerPanelFocusOwner.removeMouseListener(ma2);
}
outerPanel.removeWindowListener(windowAdapter);
outerPanel.removeMouseListener(mouseAdapter);
outerPanel.removeFocusListener(focusAdapter);
// containerPanel.removeFocusListener(containerPanel.getFocusListeners()[0]);
popup.hide();
// popup.dispose();
KeyboardFocusManager.getCurrentKeyboardFocusManager().removeKeyEventDispatcher(keyEventDispatcher);
// ToolTipManager.sharedInstance().setLightWeightPopupEnabled(wasLightWeight);
if (!rearrangementOccurred) {
LOG.debug("no rearrangement occurred, not rearranging document");
LiveRearrangerActionHandler.setInProgress(false);
return;
}
LOG.debug("rearranging document");
final Runnable task = new Runnable() {
public void run() {
if (document != null) {
final Emitter e = new Emitter(psiFile, myResultRuleInstances, document);
e.emitRearrangedDocument();
}
}
};
final Application application = ApplicationManager.getApplication();
application.runWriteAction(
new Runnable() {
public void run() {
CommandProcessor.getInstance().executeCommand(project, task, "Rearrange", null);
}
}
);
LiveRearrangerActionHandler.setInProgress(false);
LOG.debug("exit finish() on thread " + Thread.currentThread().getName());
}
private JPanel getContainerPanel() {
final JPanel containerPanel = new JPanel(new GridBagLayout());
Border etched = BorderFactory.createTitledBorder(
BorderFactory.createEtchedBorder(), "Live Rearranger", TitledBorder.CENTER,
TitledBorder.TOP
);
containerPanel.setBorder(etched);
final GridBagConstraints scrollPaneConstraints = new GridBagConstraints();
scrollPaneConstraints.insets = new Insets(3, 3, 3, 3);
scrollPaneConstraints.fill = GridBagConstraints.BOTH;
scrollPaneConstraints.gridwidth = GridBagConstraints.REMAINDER;
scrollPaneConstraints.gridheight = GridBagConstraints.REMAINDER;
scrollPaneConstraints.weightx = 1;
scrollPaneConstraints.weighty = 1;
scrollPaneConstraints.gridx = 0;
scrollPaneConstraints.gridy = 1;
final JScrollPane treeView = getScrollPane();
final JComponent showTypesBox =
new IconBox(containerPanel, scrollPaneConstraints, this) {
boolean getSetting() {
return settings.isShowParameterTypes();
}
void setSetting(boolean value) {
settings.setShowParameterTypes(value);
}
Icon getIcon() {
return IconUtil.getIcon("ShowParamTypes");
}
String getToolTipText() {
return "Show parameter types";
}
int getShortcut() {
return KeyEvent.VK_T;
}
}.getIconBox();
final JComponent showNamesBox =
new IconBox(containerPanel, scrollPaneConstraints, this) {
boolean getSetting() {
return settings.isShowParameterNames();
}
void setSetting(boolean value) {
settings.setShowParameterNames(value);
}
Icon getIcon() {
return IconUtil.getIcon("ShowParamNames");
}
String getToolTipText() {
return "Show parameter names";
}
int getShortcut() {
return KeyEvent.VK_N;
}
}.getIconBox();
final JComponent showFieldsBox =
new IconBox(containerPanel, scrollPaneConstraints, this) {
boolean getSetting() {
return settings.isShowFields();
}
void setSetting(boolean value) {
settings.setShowFields(value);
}
Icon getIcon() {
return IconUtil.getIcon("ShowFields");
}
String getToolTipText() {
return "Show fields";
}
int getShortcut() {
return KeyEvent.VK_F;
}
}.getIconBox();
final JComponent showTypeAfterMethodBox =
new IconBox(containerPanel, scrollPaneConstraints, this) {
boolean getSetting() {
return settings.isShowTypeAfterMethod();
}
void setSetting(boolean value) {
settings.setShowTypeAfterMethod(value);
}
Icon getIcon() {
return IconUtil.getIcon("ShowTypeAfterMethod");
}
String getToolTipText() {
return "Show type after method";
}
int getShortcut() {
return KeyEvent.VK_A;
}
}.getIconBox();
GridBagConstraints constraints = new GridBagConstraints();
constraints.anchor = GridBagConstraints.NORTHWEST;
constraints.fill = GridBagConstraints.NONE;
constraints.gridwidth = 1;
constraints.gridheight = 1;
constraints.gridx = 0;
constraints.gridy = 0;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.insets = new Insets(5, 5, 5, 5);
containerPanel.add(showTypesBox, constraints);
constraints.gridx++;
containerPanel.add(showNamesBox, constraints);
constraints.gridx++;
containerPanel.add(showFieldsBox, constraints);
constraints.gridx++;
constraints.gridwidth = GridBagConstraints.REMAINDER;
containerPanel.add(showTypeAfterMethodBox, constraints);
containerPanel.add(treeView, scrollPaneConstraints);
return containerPanel;
}
/**
* build a JTree containing classes, fields and methods, in accordance with settings.
*
* @return
*/
public JScrollPane getScrollPane() {
// Create the nodes.
PopupTree tree = treeComponent.createLiveRearrangerTree();
/** only expand node where cursor is located. Inspect all rows; deepest node that covers
* cursor location is the best to expand. (Parent node like a class contains a method where
* the cursor is; we want to expand the method, not just the class.
*/
int expandRow = -1;
for (int i = 0; i < tree.getRowCount(); i++) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode)tree.getPathForRow(i).getLastPathComponent();
if (node.getUserObject() instanceof RangeEntry) {
RangeEntry re = (RangeEntry)node.getUserObject();
if (re.getStart().getTextRange().getStartOffset() <= cursorOffset &&
re.getEnd().getTextRange().getEndOffset() >= cursorOffset)
{
LOG.debug(
"node " +
i +
" contained cursor (offset=" +
cursorOffset +
"): " + re
);
expandRow = i;
}
}
else {
LOG.debug("expand node candidate not RangeEntry; node=" + node);
}
}
if (expandRow >= 0) {
LOG.debug("expand row " + expandRow);
tree.expandRow(expandRow);
}
JScrollPane treeView = new JScrollPane(tree);
treeView.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
treeView.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
Dimension d = treeView.getPreferredSize();
if (d.width < 400) d.width = 400;
if (d.height < 300) d.height = 300;
treeView.setPreferredSize(d);
tdt = new TreeDropTarget(tree, this);
tds = new TreeDragSource(tree, DnDConstants.ACTION_MOVE, tdt);
return treeView;
}
// class RearrangerTest
// extends LightCodeInsightTestCase
// {
// private RearrangerSettings rs;
//
// protected final void setUp() throws Exception
// {
// super.setUp();
// }
//
//
//
public static void main(String[] args) {
// RearrangerTest t = new RearrangerTest();
// t.testIt();
// void testIt()
// {
final RearrangerSettings settings = new RearrangerSettings();
FilePopupEntry pf = new FilePopupEntry() {
public String getTypeIconName() {
return "nodes/ppFile";
}
public String[] getAdditionalIconNames() {
return null;
}
public JLabel getPopupEntryText(RearrangerSettings settings) {
return new JLabel("FileName.java");
}
};
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
}
catch (Exception e) {
}
// logger.setAdditivity(false);
// logger.addAppender(new ConsoleAppender(new PatternLayout("[%7r] %6p - %30.30c - %m \n")));
// logger.setLevel(Level.DEBUG);
// logger.debug("Testing LiveRearrangerPopup");
final JFrame frame = new JFrame("SwingApplication");
// Window window = new Window(frame);
JPanel panel = new JPanel();
panel.setSize(800, 600);
frame.setSize(800, 600);
frame.getRootPane().add(panel);
// window.setSize(800, 600);
// window.getRootPane().add(panel);
final GridBagConstraints constraints = new GridBagConstraints();
constraints.anchor = GridBagConstraints.NORTHWEST;
constraints.fill = GridBagConstraints.BOTH;
constraints.weightx = 1.0d;
constraints.weighty = 1.0d;
constraints.gridwidth = GridBagConstraints.REMAINDER;
constraints.gridx = 0;
constraints.gridy = 0;
LiveRearrangerPopup lrp = new LiveRearrangerPopup(
// getProject(),
settings, pf, frame, null,
null
);
// final JPanel object = lrp.getContainerPanel();
// frame.getContentPane().setLayout(new GridBagLayout());
// frame.getContentPane().add(object, constraints);
//Finish setting up the frame, and show it.
frame.addWindowListener(
new WindowAdapter() {
public void windowClosing(final WindowEvent e) {
System.exit(0);
}
}
);
// frame.pack();
frame.setVisible(true);
lrp.liveRearranger();
}
}
//
//}
plugins/rearranger/src/com/wrq/rearranger/popup/PopupTree.java
-283
View File
@@ -1,283 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.popup;
import com.intellij.openapi.diagnostic.Logger;
import com.wrq.rearranger.entry.RangeEntry;
import com.wrq.rearranger.ruleinstance.RuleInstance;
import javax.swing.*;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;
import java.awt.*;
import java.awt.dnd.Autoscroll;
import java.util.LinkedList;
/** Handles vertical autoscrolling of the tree inside the live rearranger popup/dialog. */
public class PopupTree
extends JTree
implements Autoscroll
{
private static final Logger LOG = Logger.getInstance("#" + PopupTree.class.getName());
private static final int margin = 12;
private TreeDropTarget treeDropTarget;
private boolean exitedWithEnterKey;
private final PopupTreeComponent owner;
public PopupTree(TreeNode root, PopupTreeComponent owner) {
super(root);
this.owner = owner;
}
public void setTreeDropTarget(TreeDropTarget dropTarget) {
treeDropTarget = dropTarget;
}
public boolean isExitedWithEnterKey() {
return exitedWithEnterKey;
}
public void setExitedWithEnterKey(boolean exitedWithEnterKey) {
this.exitedWithEnterKey = exitedWithEnterKey;
}
// scroll because mouse cursor is in the scroll zone.
public void autoscroll(Point p) {
// determine row. Set y value to that of current row left edge; this allows scrolling to occur
int realrow = getRowForLocation(p.x, p.y);
if (treeDropTarget != null) {
treeDropTarget.clearInsertionPoint();
// Set y value to that of current row left edge; this allows scrolling to occur even when cursor is
// to the right or left of the smallest rectangle enclosing the row.
int row = treeDropTarget.getSrcRow();
Rectangle r = getRowBounds(row);
if (realrow < 0) {
LOG.debug("autscroll: realrow < 0 for [" + p.x + "," + p.y + "], trying x=" + r.x);
p.x = r.x;
realrow = getRowForLocation(p.x, p.y);
}
}
if (realrow < 0) {
LOG.debug("autoscroll point=[" + p.x + "," + p.y + "] realrow=" + realrow);
return;
}
Rectangle outer = getBounds();
// now determine if the row is at the top or bottom of the screen.
// Make the previous or next row visible accordingly.
int newRow =
p.y + outer.y <= margin
? realrow < 1 ? 0 : realrow - 1
: realrow < getRowCount() - 1
? realrow + 1
: realrow;
// logger.setLevel(Level.DEBUG); -- following code doesn't work for horizontal scrolling; something interferes
// int newCol = p.x;
// if (this.getParent() instanceof JViewport)
// {
// JViewport parent = (JViewport) getParent();
// logger.debug(
// "autoscroll horizontal TEST: p.x=" +
// p.x +
// ", bounds.x=" +
// outer.x +
// ", viewport x=" +
// parent.getBounds().x +
// ", width=" + parent.getBounds().width);
// if (p.x + outer.x <= margin)
// {
// newCol = p.x - margin;
// logger.debug(
// "autoscroll horizontal LEFT: new x=" + newCol
// );
// logger.debug("this=" + this.toString());
// logger.debug("this.parent=" + this.getParent().toString());
// Rectangle r = parent.getViewRect();
// r.x -= margin;
// parent.scrollRectToVisible(r);
// }
// else
// {
// if (p.x + outer.x + margin >= parent.getBounds().x + parent.getBounds().width)
// {
// newCol = p.x + margin;
// logger.debug(
// "autoscroll horizontal RIGHT: new x=" + newCol
// );
//// logger.debug("this=" + this.toString());
//// logger.debug("this.parent=" + parent.toString());
// Rectangle r = parent.getViewRect();
// r.x += margin;
// parent.scrollRectToVisible(r);
// }
// }
// }
LOG.debug("autoscroll point=[" + p.x + "," + p.y + "] realrow=" + realrow + ", newRow=" + newRow);
scrollRowToVisible(newRow);
if (treeDropTarget != null) {
treeDropTarget.computeInsertionPoint();
treeDropTarget.drawInsertionPoint();
}
}
/**
* Calculate insets for the JTree, not the viewport the tree is in.
* this makes it a bit messy.
*
* @return
*/
public Insets getAutoscrollInsets() {
Rectangle outer = getBounds();
Rectangle inner = getParent().getBounds();
return new Insets(
inner.y - outer.y + margin,
inner.x - outer.x + margin,
outer.height - inner.height - inner.y + outer.y + margin,
outer.width - inner.width - inner.x + outer.x + margin
);
}
// Use this method to see the boundaries of the autoscroll active region.
// public void paintComponent(Graphics g)
// {
// super.paintComponent(g);
// Rectangle outer = getBounds();
// Rectangle inner = getParent().getBounds();
// g.setColor(Color.RED);
// g.drawRect(-outer.x + margin, -outer.y + margin,
// inner.width - 2*margin, inner.height - 2*margin);
// }
/**
* Move the tree's selection to the destination row indicated. The selection may contain multiple
* discontiguous rows, but all rows must have the same parent node.
*
* @param dstIndex child index of common parent before which selection is to be inserted. If null, insert at end of parent.
*/
public void moveSelection(int dstIndex, boolean before) {
/**
* First, remove all mutable tree nodes from the tree's model and the rule instance. Place them in a list.
* If any are removed before the destination row, decrement the dstIndex so that the insertion still
* happens in the correct place.
*/
TreePath[] paths = getSelectionPaths();
LinkedList<DefaultMutableTreeNode> nodeList = new LinkedList<DefaultMutableTreeNode>();
LinkedList<RangeEntry> ruleList = new LinkedList<RangeEntry>();
if (paths == null || paths.length == 0) {
return; // nothing selected
}
owner.setRearrangementOccurred(true);
final DefaultMutableTreeNode peerNode = (DefaultMutableTreeNode)paths[0].getLastPathComponent();
RangeEntry entry = (RangeEntry)peerNode.getUserObject();
DefaultMutableTreeNode peerParent = (DefaultMutableTreeNode)peerNode.getParent();
DefaultMutableTreeNode dstNode = (DefaultMutableTreeNode)peerParent.getChildAt(dstIndex);
if (!before && dstIndex < peerParent.getChildCount()) {
dstIndex++;
}
RuleInstance ruleInstance = entry.getMatchedRule();
DefaultTreeModel model = (DefaultTreeModel)getModel();
for (TreePath path : paths) {
DefaultMutableTreeNode srcNode = (DefaultMutableTreeNode)path.getLastPathComponent();
DefaultMutableTreeNode srcParent = (DefaultMutableTreeNode)srcNode.getParent();
int srcRow = srcParent.getIndex(srcNode);
if (srcRow < dstIndex) {
dstIndex--;
}
nodeList.add(srcNode);
model.removeNodeFromParent(srcNode);
RangeEntry match = (RangeEntry)srcNode.getUserObject();
ruleInstance.getMatches().remove(match);
ruleList.add(match);
}
/**
* now insert all the nodes in the list at the appropriate spots in the model and rule instance.
*/
clearSelection();
TreePath visiblePath = null;
/**
* calculate the offset between the destination row in the model and its location in the ruleInstance's
* list of matching items. This is non-zero when fields exist but are not shown in the tree.
*/
int dstOffset = (ruleInstance.getMatches().indexOf(dstNode.getUserObject())) - peerParent.getIndex(dstNode);
while (!nodeList.isEmpty()) {
DefaultMutableTreeNode srcNode = nodeList.removeFirst();
model.insertNodeInto(srcNode, peerParent, dstIndex);
final TreePath treePath = new TreePath(srcNode.getPath());
addSelectionPath(treePath);
if (before) {
if (visiblePath == null) visiblePath = treePath;
}
else {
visiblePath = treePath;
}
final RangeEntry match = ruleList.removeFirst();
ruleInstance.getMatches().add(dstIndex + dstOffset, match);
dstIndex++;
}
if (visiblePath != null) {
scrollPathToVisible(visiblePath);
}
}
/**
* returns true if src and dst have common parent. Since src has been created from serialized data,
* the actual parents are different objects. So compare by name up to the root. Ignore any plain
* DefaultMutableTreeNodes in the path (these correspond to rules) -- just compare names of
* RearrangerTreeNodes.
*
* @param src RearrangerTreeNode reconstituted from serialized data
* @param dst RearrangerTreeNode next to which src is to be dropped
* @return -1 if src and dst do not have common parent; >= 0 to indicate position of src in children list
*/
int haveCommonAncestors(DefaultMutableTreeNode src, DefaultMutableTreeNode dst) {
if (src == null || dst == null) {
return -1;
}
DefaultMutableTreeNode p = (DefaultMutableTreeNode)src.getParent();
int result = p.getIndex(src);
src = (DefaultMutableTreeNode)src.getParent();
dst = (DefaultMutableTreeNode)dst.getParent();
while (src != null && dst != null) {
if (src instanceof RearrangerTreeNode) {
if (dst instanceof RearrangerTreeNode) {
RearrangerTreeNode s = (RearrangerTreeNode)src;
RearrangerTreeNode d = (RearrangerTreeNode)dst;
if (!s.name.equals(d.name)) {
return -1;
}
}
else {
return -1;
}
}
else if (dst instanceof RearrangerTreeNode) {
return -1;
}
src = (DefaultMutableTreeNode)src.getParent();
dst = (DefaultMutableTreeNode)dst.getParent();
}
return src == null && dst == null ? result : -1;
}
}
plugins/rearranger/src/com/wrq/rearranger/popup/PopupTreeComponent.java
-361
View File
@@ -1,361 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.popup;
import com.intellij.openapi.diagnostic.Logger;
import com.wrq.rearranger.Rearranger;
import com.wrq.rearranger.ruleinstance.RuleInstance;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.util.Constraints;
import com.wrq.rearranger.util.IconUtil;
import javax.swing.*;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.net.URL;
import java.util.List;
/** Builds a JTree that can be used in a file structure popup or live rearranger popup. */
public class PopupTreeComponent {
private static final Logger LOG = Logger.getInstance("#" + PopupTreeComponent.class.getName());
private final FilePopupEntry myPsiFileEntry;
private final List<RuleInstance> myResultRuleInstances;
private final RearrangerSettings settings;
private boolean rearrangementOccurred;
public PopupTreeComponent(RearrangerSettings settings,
List<RuleInstance> resultRuleInstances,
final FilePopupEntry psiFileEntry)
{
this.settings = settings;
this.myResultRuleInstances = resultRuleInstances;
this.myPsiFileEntry = psiFileEntry;
}
public boolean isRearrangementOccurred() {
return rearrangementOccurred;
}
public void setRearrangementOccurred(boolean rearrangementOccurred) {
this.rearrangementOccurred = rearrangementOccurred;
}
public JTree createTree() {
DefaultMutableTreeNode top = createAllNodes();
final JTree tree = new JTree(top);
tree.putClientProperty("JTree.lineStyle", "Angled");
tree.setRootVisible(true);
tree.setShowsRootHandles(true);
tree.setRowHeight(0);
tree.setCellRenderer(new JavaObjectRenderer());
tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
tree.setEditable(false);
return tree;
}
public PopupTree createLiveRearrangerTree() {
DefaultMutableTreeNode top = createAllNodes();
// discard top nodes if only one child
// while (top.getChildCount() == 1) { // TODO - enable
// // remove that child, make its child(ren) top's child(ren).
// DefaultMutableTreeNode child = (DefaultMutableTreeNode) top.getChildAt(0);
// child.removeFromParent();
// for (int i = 0; i < child.getChildCount(); i++) {
// DefaultMutableTreeNode grandchild = (DefaultMutableTreeNode) child.getChildAt(i);
// top.add(grandchild);
// }
// }
final PopupTree tree = new PopupTree(top, this);
tree.putClientProperty("JTree.lineStyle", "Angled");
tree.setRootVisible(true);
tree.setShowsRootHandles(true);
tree.setRowHeight(0);
tree.setCellRenderer(new JavaObjectRenderer());
tree.getSelectionModel().setSelectionMode(TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION);
tree.setEditable(false);
tree.getSelectionModel().addTreeSelectionListener(
new TreeSelectionListener() {
public void valueChanged(TreeSelectionEvent e) {
LOG.debug("selection changed as follows (" + e.getPaths().length + " path(s)):");
TreePath lastPathAdded = null;
int i = 0;
for (TreePath path : e.getPaths()) {
if (e.isAddedPath(path)) {
lastPathAdded = path;
}
LOG.debug(
"path " +
i +
(e.isAddedPath(path) ? " added:" : " removed:") +
path
);
i++;
}
if (lastPathAdded == null) {
// nothing added, so all selected paths still have same parent.
return;
}
/**
* ensure that all selection rows have the same parent. If not, take the last added
* path, and remove any rows with a different parent. (So simply start with the last
* added path and remove any rows with a different parent.)
*/
DefaultMutableTreeNode lastNodeAdded = null;
lastNodeAdded = (DefaultMutableTreeNode)lastPathAdded.getLastPathComponent();
boolean haveSameParent = true;
for (TreePath path : tree.getSelectionPaths()) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode)path.getLastPathComponent();
if (lastNodeAdded == null) {
lastNodeAdded = node;
}
if (node != lastNodeAdded) {
if (tree.haveCommonAncestors(lastNodeAdded, node) < 0) {
// parents not identical, so remove node from selection.
haveSameParent = false;
break;
}
}
}
if (!haveSameParent) {
// to avoid reentry into this listener, temporarily remove it
tree.getSelectionModel().removeTreeSelectionListener(this);
tree.clearSelection();
tree.addSelectionPath(lastPathAdded);
tree.getSelectionModel().addTreeSelectionListener(this);
}
}
}
);
AbstractAction moveUpAction = new AbstractAction() {
public void actionPerformed(ActionEvent e) {
LOG.debug("moveUpAction, " + tree.getSelectionPaths().length + " paths in selection");
if (tree.getSelectionPaths().length == 0) {
return;
}
/**
* find first selection row.
*/
int selectionRow = Integer.MAX_VALUE;
for (TreePath path : tree.getSelectionPaths()) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode)path.getLastPathComponent();
int nodeIndex = node.getParent().getIndex(node);
if (selectionRow > nodeIndex) {
selectionRow = nodeIndex;
}
}
if (selectionRow > 0) {
selectionRow--;
}
tree.moveSelection(selectionRow, true);
}
};
AbstractAction moveDownAction = new AbstractAction() {
public void actionPerformed(ActionEvent e) {
LOG.debug("moveDownAction, " + tree.getSelectionPaths().length + " paths in selection");
if (tree.getSelectionPaths().length == 0) {
return;
}
/**
* find last selection row.
*/
int selectionRow = -1;
for (TreePath path : tree.getSelectionPaths()) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode)path.getLastPathComponent();
final DefaultMutableTreeNode parent = ((DefaultMutableTreeNode)node.getParent());
int nodeIndex = parent.getIndex(node);
if (selectionRow < nodeIndex) {
selectionRow = nodeIndex;
}
}
selectionRow++;
tree.moveSelection(selectionRow, false);
}
};
AbstractAction enterKeyAction = new AbstractAction() {
public void actionPerformed(ActionEvent e) {
LOG.debug("exit with enter key");
tree.setExitedWithEnterKey(true);
for (Container p = tree.getParent(); p != null; p = p.getParent()) {
if (p instanceof JDialog) {
p.setVisible(false);
}
}
}
};
tree.getInputMap().put(
KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0),
"enterKeyAction"
);
tree.getActionMap().put("enterKeyAction", enterKeyAction);
tree.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(
KeyStroke.getKeyStroke(
KeyEvent.VK_UP,
InputEvent.SHIFT_DOWN_MASK | InputEvent.CTRL_DOWN_MASK
),
"moveUpAction"
);
tree.getActionMap().put("moveUpAction", moveUpAction);
tree.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(
KeyStroke.getKeyStroke(
KeyEvent.VK_DOWN,
InputEvent.SHIFT_DOWN_MASK | InputEvent.CTRL_DOWN_MASK
),
"moveDownAction"
);
tree.getActionMap().put("moveDownAction", moveDownAction);
tree.setSelectionPath(tree.getPathForRow(0));
return tree;
}
public DefaultMutableTreeNode createAllNodes() {
DefaultMutableTreeNode top = new RearrangerTreeNode(myPsiFileEntry, "root");
createNodes(top);
return top;
}
private void createNodes(DefaultMutableTreeNode top) {
for (RuleInstance ruleInstance : myResultRuleInstances) {
ruleInstance.addRuleInstanceToPopupTree(top, settings);
}
}
class JavaObjectRenderer
extends DefaultTreeCellRenderer
{
Icon findIcon(String iconName) {
if (iconName == null) {
return null;
}
URL iconURL = this.getClass().getClassLoader().getResource(iconName + ".png");
if (iconURL == null) {
return IconUtil.getIcon(iconName);
}
else {
return new ImageIcon(iconURL, Rearranger.COMPONENT_NAME);
}
}
public Component getTreeCellRendererComponent(final JTree tree,
final Object value,
final boolean sel,
final boolean expanded,
final boolean leaf,
final int row,
final boolean hasFocus)
{
Object userObject = null;
if (value instanceof DefaultMutableTreeNode) {
userObject = ((DefaultMutableTreeNode)value).getUserObject();
}
// obtain a component that will render the appropriate item.
if (userObject instanceof FilePopupEntry) {
FilePopupEntry entry = (FilePopupEntry)userObject;
final String iconTypeName = entry.getTypeIconName();
final String[] iconNames = entry.getAdditionalIconNames();
final JLabel textLabel = entry.getPopupEntryText(settings);
JPanel panel = new JPanel(new GridBagLayout()) {
public void paint(Graphics g) {
// System.out.println("paint " + textLabel.getText() + ", sel=" + sel +
// ", hasFocus=" + hasFocus +
// ", selected=" + selected +
// ", bg=" + getBackground().toString().replaceFirst(".*\\[", "[") +
// ", bg sel=" + getBackgroundSelectionColor().toString().replaceFirst(".*\\[", "[") +
// ", border=" + getBorderSelectionColor().toString().replaceFirst(".*\\[", "[")
// );
if (sel && !hasFocus) {
Color bgColor = getBackground();
setBackground(Color.WHITE);
super.paint(g);
setBackground(bgColor);
Color bsColor = getBorderSelectionColor();
if (bsColor != null) {
g.setColor(bsColor);
if (getComponentOrientation().isLeftToRight()) {
g.drawRect(
0, 0, getWidth() - 1,
getHeight() - 1
);
}
else {
g.drawRect(
0, 0, getWidth() - 1,
getHeight() - 1
);
}
}
}
else {
super.paint(g);
}
}
};
Constraints constraints = new Constraints(GridBagConstraints.NORTHWEST);
constraints.weightedLastRow();
Icon typeIcon = findIcon(iconTypeName == null ? "fileTypes/unknown" : iconTypeName);
panel.setBackground(Color.WHITE);
if (sel) {
// Color fg = textLabel.getForeground();
// Color bg = textLabel.getBackground();
// textLabel.setForeground(bg);
// textLabel.setBackground(new Color(181, 190, 214));
// Color fg = panel.getForeground();
// Color bg = panel.getBackground();
// panel.setForeground(bg);
panel.setBackground(new Color(181, 190, 214));
}
else {
textLabel.setBackground(Color.WHITE);
}
if (typeIcon != null) {
JLabel typeLabel = new JLabel(typeIcon);
panel.add(typeLabel, constraints.nextCol());
}
if (iconNames != null) {
for (String iconName : iconNames) {
Icon addlIcon = findIcon(iconName);
JLabel plLabel = new JLabel(addlIcon);
panel.add(plLabel, constraints.nextCol());
}
}
constraints.insets = new Insets(0, 3, 0, 0);
panel.add(textLabel, constraints.lastCol());
panel.repaint();
return panel;
}
LOG.debug("getTreeCellRendererComponent: userObject not IFilePopupEntry;" + userObject);
return super.getTreeCellRendererComponent(tree, value, sel, expanded, leaf, row, hasFocus);
}
}
}
plugins/rearranger/src/com/wrq/rearranger/popup/RearrangerTreeNode.java
-35
View File
@@ -1,35 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.popup;
import javax.swing.tree.DefaultMutableTreeNode;
public class RearrangerTreeNode
extends DefaultMutableTreeNode
{
String name;
public RearrangerTreeNode(Object userObject, String name) {
super(userObject);
this.name = name;
}
}
plugins/rearranger/src/com/wrq/rearranger/popup/TransferableTreeNode.java
-57
View File
@@ -1,57 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.popup;
import javax.swing.tree.TreePath;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.IOException;
public class TransferableTreeNode
implements Transferable
{
public static DataFlavor treePathFlavor = new DataFlavor(TreePath.class, "Tree Path Flavor");
DataFlavor[] flavors = {treePathFlavor};
TreePath[] paths;
public TransferableTreeNode(TreePath[] paths) {
this.paths = paths;
}
public DataFlavor[] getTransferDataFlavors() {
return flavors;
}
public boolean isDataFlavorSupported(DataFlavor flavor) {
return (flavor.getRepresentationClass() == TreePath.class);
}
public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
if (isDataFlavorSupported(flavor)) {
return paths;
}
else {
throw new UnsupportedFlavorException(flavor);
}
}
}
plugins/rearranger/src/com/wrq/rearranger/popup/TreeDragSource.java
-93
View File
@@ -1,93 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.popup;
import com.intellij.openapi.diagnostic.Logger;
import javax.swing.*;
import java.awt.*;
import java.awt.dnd.*;
/** Contains logic to start a drag from the popup file structure tree. */
public class TreeDragSource
implements DragSourceListener,
DragGestureListener
{
private static final Logger LOG = Logger.getInstance("#" + TreeDragSource.class.getName());
DragSource source;
DragGestureRecognizer recognizer;
TransferableTreeNode transferable;
JTree sourceTree;
TreeDropTarget tdt;
public TreeDragSource(JTree sourceTree, int actions, TreeDropTarget tdt) {
LOG.debug("construct TreeDragSource, actions=" + actions);
this.sourceTree = sourceTree;
this.tdt = tdt;
source = DragSource.getDefaultDragSource();
recognizer = source.createDefaultDragGestureRecognizer(
sourceTree, actions, this);
}
public void dragEnter(DragSourceDragEvent dsde) {
LOG.debug("src dragEnter, calling dragOver");
dragOver(dsde);
}
public void dragOver(DragSourceDragEvent dsde) {
// logger.debug("src dragOver; drop action=" + dsde.getDropAction() +
// ", target actions=" + dsde.getTargetActions());
// dsde.getDragSourceContext().setCursor(dsde.getDropAction() > 0
// ? DragSource.DefaultMoveDrop
// : DragSource.DefaultMoveNoDrop);
}
public void dropActionChanged(DragSourceDragEvent dsde) {
LOG.debug("src dropActionChanged: action=" + dsde.getDropAction());
}
public void dragDropEnd(DragSourceDropEvent dsde) {
LOG.debug("src dragDropEnd, success=" + dsde.getDropSuccess());
}
public void dragExit(DragSourceEvent dse) {
// logger.debug("src dragExit");
}
public void dragGestureRecognized(DragGestureEvent dge) {
LOG.debug("src dragGestureRecognized, action=" + dge.getDragAction() +
", n paths in selection=" + sourceTree.getSelectionPaths().length);
final Point point = dge.getDragOrigin();
// TreePath path = sourceTree.getSelectionPath();
// if (path == null ||
// path.getPathCount() <= 1)
// {
// // can't move the root node or an empty selection
// System.out.println("can't drag root node or empty selection");
// return;
// }
// Make a version of the node that we can use for DnD.
tdt.setSrcRow(sourceTree.getClosestRowForLocation(point.x, point.y));
transferable = new TransferableTreeNode(sourceTree.getSelectionPaths());
dge.startDrag(null, transferable, this);
}
}
plugins/rearranger/src/com/wrq/rearranger/popup/TreeDropTarget.java
-273
View File
@@ -1,273 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.popup;
import com.intellij.openapi.diagnostic.Logger;
import javax.swing.*;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.TreePath;
import java.awt.*;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.awt.dnd.*;
import java.io.IOException;
/** Handles drop actions associated with manual rearrangement. */
public class TreeDropTarget
implements DropTargetListener
{
private static final Logger LOG = Logger.getInstance("#" + TreeDropTarget.class.getName());
private static final Color xorBackgroundColor = new Color(255 - 8, 255 - 36, 255 - 107);
DropTarget target;
PopupTree targetTree;
ILiveRearranger lrp;
/** Cached information about the location of the last insertion row to be drawn. */
private transient Rectangle lastRowRect;
/** cached value of last row to be drawn. */
private int lastRow;
/**
* Cached information about whether insertion was possible at the last
* insertion point.
*/
private transient boolean canInsert;
/** true if rectangle has been drawn. */
private boolean rectangleDrawn;
/** row being dragged. */
private int srcRow;
public TreeDropTarget(PopupTree tree,
ILiveRearranger lrp)
{
this.lrp = lrp;
this.targetTree = tree;
target = new DropTarget(targetTree, DnDConstants.ACTION_MOVE, this);
this.lastRowRect = new Rectangle();
this.canInsert = false;
rectangleDrawn = false;
srcRow = -1;
tree.setTreeDropTarget(this);
}
public void dragEnter(DropTargetDragEvent dtde) {
// logger.debug("tgt dragEnter calling dragOver logic");
dragOver(dtde);
}
public int getSrcRow() {
return srcRow;
}
public void setSrcRow(int srcRow) {
this.srcRow = srcRow;
}
public void dragOver(DropTargetDragEvent dtde) {
// logger.debug("target dragOver: src drop actions=" + dtde.getSourceActions() +
// ", src drop action=" + dtde.getDropAction());
clearInsertionPoint();
Point pt = dtde.getLocation();
lastRow = targetTree.getClosestRowForLocation(pt.x, pt.y);
computeInsertionPoint(lastRow);
TreePath path = targetTree.getClosestPathForLocation(pt.x, pt.y);
final DefaultMutableTreeNode tgtNode;
tgtNode = (DefaultMutableTreeNode)path.getLastPathComponent();
// logger.debug("tgt dragOver, closest node=" + tgtNode);
// compare selected node(s) to see if it has same parent as tgtNode.
final DefaultMutableTreeNode srcNode;
final TreePath srcPath = targetTree.getSelectionPath();
if (srcPath != null) {
srcNode = (DefaultMutableTreeNode)srcPath.getLastPathComponent();
// logger.debug("tgt dragOver, selected node=" + srcNode);
if (srcNode.getParent() == tgtNode.getParent() &&
srcNode != tgtNode)
{
// logger.debug("tgt dragOver: accept drag");
canInsert = true;
drawInsertionPoint();
dtde.acceptDrag(DnDConstants.ACTION_MOVE);
return;
}
}
// logger.debug("tgt dragOver: reject drag");
canInsert = false;
dtde.rejectDrag();
}
public void dropActionChanged(DropTargetDragEvent dtde) {
// logger.debug("tgt:dropActionChanged, action=" + dtde.getDropAction());
}
public void drop(DropTargetDropEvent dtde) {
clearInsertionPoint();
canInsert = false;
// figure out where the drop occurred.
Point pt = dtde.getLocation();
TreePath path = targetTree.getClosestPathForLocation(pt.x, pt.y);
Transferable t = dtde.getTransferable();
DataFlavor[] flavors = t.getTransferDataFlavors();
for (DataFlavor flavor : flavors) {
if (t.isDataFlavorSupported(flavor)) {
DefaultMutableTreeNode dstNode = (DefaultMutableTreeNode)path.getLastPathComponent();
Transferable tx = dtde.getTransferable();
TreePath[] tr = null;
try {
Object o = tx.getTransferData(TransferableTreeNode.treePathFlavor);
tr = (TreePath[])o;
}
catch (UnsupportedFlavorException e) {
e.printStackTrace();
dtde.rejectDrop();
return;
}
catch (IOException e) {
e.printStackTrace();
dtde.rejectDrop();
return;
}
if (tr == null) {
dtde.rejectDrop();
return;
}
final DefaultMutableTreeNode srcNode = (DefaultMutableTreeNode)tr[0].getLastPathComponent();
int srcIndex = targetTree.haveCommonAncestors(srcNode, dstNode);
if (srcIndex < 0) {
LOG.debug(
"reject drop onto " +
dstNode +
"; parent of " +
srcNode + " is different"
);
dtde.rejectDrop();
return;
}
else {
DefaultMutableTreeNode parent = (DefaultMutableTreeNode)dstNode.getParent();
DefaultMutableTreeNode srcInCurrentTree = (DefaultMutableTreeNode)parent.getChildAt(srcIndex);
int dstRow = parent.getIndex(dstNode);
boolean before = true;
if (srcIndex < dstRow) {
LOG.debug(
"drop: move " +
srcIndex +
":" +
srcInCurrentTree +
" after " + dstRow + ":" + dstNode
);
before = false;
}
else if (srcIndex == dstRow) {
LOG.debug("reject drop: item onto itself");
dtde.rejectDrop();
return;
}
else {
LOG.debug(
"drop: move " +
srcIndex +
":" +
srcInCurrentTree +
" before " + dstRow + ":" + dstNode
);
}
targetTree.moveSelection(dstRow, before);
lrp.setRearrangementOccurred(true);
dtde.acceptDrop(dtde.getDropAction());
dtde.dropComplete(true);
return;
}
}
}
dtde.rejectDrop();
}
public void dragExit(DropTargetEvent dte) {
LOG.debug("tgt dragExit");
clearInsertionPoint();
canInsert = false;
}
public void clearInsertionPoint() {
if (rectangleDrawn) {
// Erase the old insertion point by drawing over it.
drawInsertionPoint();
}
}
/**
* Draw or erase the current insertion point indicator. This draws in XOR
* mode, so drawing the indicator once will display it and drawing it again
* in the same location will erase it.
*/
public void drawInsertionPoint() {
if (canInsert) {
Graphics g = this.targetTree.getGraphics();
g.setXORMode(xorBackgroundColor);
g.drawRect(
this.lastRowRect.x, this.lastRowRect.y,
this.lastRowRect.width, this.lastRowRect.height
);
rectangleDrawn = !rectangleDrawn;
}
}
public void computeInsertionPoint() {
computeInsertionPoint(lastRow);
}
/**
* Given a particular point over the associated tree component, determine
* the corresponding insertion point in the tree for dropped data. The tree
* path that the insertion will be relative to can be found using the
* <code>JTree</code> method <code>getClosestPathForLocation</code>. The
* insertion itself will either be before, after, or in the node at the end
* of the path. This method also calculates the rectangle which can be used
* to draw the appropriate indicator for the insertion point.
*
* @param row the row number of the tree corresponding to the drop target.
*/
public void computeInsertionPoint(int row) {
JTree tree = targetTree;
Rectangle rowBounds = tree.getRowBounds(row);
if (row < srcRow) {
// Insertion point is immediately before the node.
this.lastRowRect.setBounds(rowBounds.x, rowBounds.y, rowBounds.width, 0);
}
else if (row > srcRow) {
// Insertion point is immediately after the node.
this.lastRowRect.setBounds(
rowBounds.x, rowBounds.y + rowBounds.height - 1,
rowBounds.width, 0
);
}
else {
// Insertion point is on the node - dropped data will be appended to the
// nodes child list. Draw nothing in this case.
this.lastRowRect.setBounds(rowBounds.x, rowBounds.y, 0, 0);
}
}
}
plugins/rearranger/src/com/wrq/rearranger/rearrangement/Emitter.java
-76
View File
@@ -1,76 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.rearrangement;
import com.intellij.openapi.editor.Document;
import com.intellij.psi.PsiFile;
import com.wrq.rearranger.ruleinstance.RuleInstance;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.ArrayList;
import java.util.List;
/** Emits a new document from the rearranged entries. */
public final class Emitter {
@NotNull private final StringBuilder myStringBuffer = new StringBuilder();
@NotNull private final List<RuleInstance> myResultRuleInstances = new ArrayList<RuleInstance>();
@NotNull private final PsiFile myFile;
@NotNull private final Document myDocument;
public Emitter(@NotNull final PsiFile file, @NotNull final List<RuleInstance> resultRuleInstances, @NotNull final Document document) {
myFile = file;
myResultRuleInstances.addAll(resultRuleInstances);
myDocument = document;
myStringBuffer.ensureCapacity(myFile.getText().length() + 100 /* room for inserted blank lines */);
}
@NotNull
public Document getDocument() {
return myDocument;
}
@NotNull
public StringBuilder getTextBuffer() {
return myStringBuffer;
}
public void emitRearrangedDocument() {
emitRuleInstances(myResultRuleInstances);
myDocument.replaceString(
myFile.getTextRange().getStartOffset(),
myFile.getTextRange().getEndOffset(),
myStringBuffer.toString()
);
}
public void emitRuleInstances(@Nullable List<RuleInstance> resultRuleInstances) {
if (resultRuleInstances == null) {
return;
}
for (RuleInstance ruleInstance : resultRuleInstances) {
ruleInstance.emit(this);
}
}
}
plugins/rearranger/src/com/wrq/rearranger/rearrangement/GenericRearranger.java
-197
View File
@@ -1,197 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.rearrangement;
import com.intellij.openapi.diagnostic.Logger;
import com.wrq.rearranger.entry.ClassContentsEntry;
import com.wrq.rearranger.entry.ClassEntry;
import com.wrq.rearranger.entry.RangeEntry;
import com.wrq.rearranger.entry.RelatableEntry;
import com.wrq.rearranger.ruleinstance.CommentRuleInstance;
import com.wrq.rearranger.ruleinstance.RuleInstance;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.settings.attributeGroups.*;
import org.jetbrains.annotations.NotNull;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
/** Template for generic rearrangement of items in a class or in a Java file. */
public abstract class GenericRearranger {
private static final Logger LOG = Logger.getInstance("#" + GenericRearranger.class.getName());
private final List<AttributeGroup> myRules;
private final List<ClassContentsEntry> myEntries;
private final List<RuleInstance> myResultRuleInstances;
private final int myNestingLevel;
private final RearrangerSettings mySettings;
@SuppressWarnings({"AssignmentToCollectionOrArrayFieldFromParameter"})
protected GenericRearranger(final List<AttributeGroup> rules,
final List<ClassContentsEntry> outerClasses,
final int nestingLevel,
final RearrangerSettings settings) {
myRules = rules;
myEntries = outerClasses;
this.myNestingLevel = nestingLevel;
this.mySettings = settings;
myResultRuleInstances = new ArrayList<RuleInstance>(rules.size() + 4);
}
/**
* Rearranges the RangeEntry objects contained in entries according to rules specified by the user.
* Inserts comments as directed.
*
* @return rearranged list of RangeEntry and CommentRuleInstance objects.
*/
public final List<RuleInstance> rearrangeEntries() {
final List<RuleInstance> prioritizedRuleInstances = new ArrayList<RuleInstance>();
buildRuleInstanceLists(prioritizedRuleInstances);
// Recursively reorder contents of every nested ClassEntry
for (ClassContentsEntry entry : myEntries) {
if (entry instanceof ClassEntry) {
((ClassEntry)entry).rearrangeContents();
}
}
matchPrioritizedRules(prioritizedRuleInstances);
// Move related methods together. Extracted methods and setters (emitted with getters)
// were not moved by the rearrangement code ("MatchPrioritizedRules()") just above.
rearrangeRelatedItems(myEntries, myResultRuleInstances);
// Now go back and determine which comments are going to be emitted, based on their criteria and the
// state of the immediately surrounding rules. Ignore inner classes if no rearrangement of inner
// classes is taking place.
if (myNestingLevel <= 1 || mySettings.isRearrangeInnerClasses()) {
determineEmittedComments();
}
return myResultRuleInstances;
}
/** For each comment rule instance, test its "emit" condition and set its emit flag appropriately. */
private void determineEmittedComments() {
for (int i = 0; i < myResultRuleInstances.size(); i++) {
if (myResultRuleInstances.get(i) instanceof CommentRuleInstance) {
final CommentRuleInstance ce = (CommentRuleInstance)myResultRuleInstances.get(i);
ce.determineEmit(myResultRuleInstances, i);
if (ce.isEmit()) {
// set the "separator comment preceding" flag on the next matching RangeEntry.
for (int j = i + 1; j < myResultRuleInstances.size(); j++) {
RuleInstance instance = myResultRuleInstances.get(j);
if (instance.hasMatches()) {
final List<RangeEntry> matches = instance.getMatches();
assert matches != null;
RangeEntry entry = (matches.get(0));
entry.setSeparatorCommentPrecedes(true);
break;
}
}
}
}
}
}
/**
* For each rule (in prioritized order), test all remaining entries to identify those that match.
* Exclude any extracted (i.e. related) methods and any setter methods that will be emitted with
* a corresponding getter. If an entry matches the rule, add it to the list of entries matching the
* rule and remove it from the list of remaining entries.
*
* @param prioritizedRules prioritized list of rules
*/
@SuppressWarnings({"StringContatenationInLoop"})
private void matchPrioritizedRules(@NotNull List<RuleInstance> prioritizedRules) {
for (RuleInstance ruleInstance : prioritizedRules) {
final Rule rule = ruleInstance.getRule();
final ListIterator entryIterator = myEntries.listIterator();
while (entryIterator.hasNext()) {
final RangeEntry entry = (RangeEntry)entryIterator.next();
if (entry instanceof RelatableEntry) {
// if this is an extracted (i.e. related) method, or
// if this is a setter that will be emitted under the corresponding getter,
// don't test it for match against the rule.
final RelatableEntry relatableEntry = ((RelatableEntry)entry);
if (relatableEntry.isRelatedMethod() || relatableEntry.isEmittableSetter()) {
continue;
}
}
if (rule.isMatch(entry)) {
LOG.debug("rule:" + rule.toString() + "; entry matched:" + entry.getEnd().toString());
ruleInstance.addEntry(entry);
entry.setMatchedRule(ruleInstance);
entryIterator.remove();
}
}
}
}
/**
* Build two rule instance lists, one in order of emission ("resultRuleInstances") and one
* in order of matching ("prioritizedRuleInstances").
*
* @param prioritizedRuleInstances
*/
private void buildRuleInstanceLists(final List<RuleInstance> prioritizedRuleInstances) {
// Add a HeaderTrailerRuleInstance to pick up any headers that might exist.
RuleInstance hri = new HeaderRule().createRuleInstance();
myResultRuleInstances.add(hri);
prioritizedRuleInstances.add(hri);
for (Rule rule : myRules) {
RuleInstance instance = rule.createRuleInstance();
myResultRuleInstances.add(instance);
// Now insert the rule instance into the prioritized list; highest priority first; stable insertion.
boolean inserted = false;
for (int i = prioritizedRuleInstances.size() - 1; i >= 0; i--) {
RuleInstance entry = (prioritizedRuleInstances.get(i));
if (rule.getPriority() <= entry.getRule().getPriority()) {
prioritizedRuleInstances.add(i + 1, instance);
inserted = true;
break;
}
}
if (!inserted) {
prioritizedRuleInstances.add(0, instance);
}
}
// Now add a default rule to pick up all unmatched items.
RuleInstance defaultRuleInstance = new DefaultRule().createRuleInstance();
myResultRuleInstances.add(defaultRuleInstance);
prioritizedRuleInstances.add(defaultRuleInstance);
// Finally, add a TrailerRuleInstance to pick up any leftover text.
RuleInstance tri = new TrailerRule().createRuleInstance();
myResultRuleInstances.add(tri);
prioritizedRuleInstances.add(tri);
}
/**
* Move any related items (e.g., extracted methods) remaining in 'entries' into the correct position in
* rearrangedEntries.
*
* @param entries
* @param rearrangedEntries
*/
public abstract void rearrangeRelatedItems(List<ClassContentsEntry> entries, List<RuleInstance> rearrangedEntries);
}
plugins/rearranger/src/com/wrq/rearranger/rearrangement/Mover.java
-63
View File
@@ -1,63 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.rearrangement;
import com.wrq.rearranger.entry.ClassContentsEntry;
import com.wrq.rearranger.ruleinstance.RuleInstance;
import com.wrq.rearranger.settings.RearrangerSettings;
import java.util.ArrayList;
import java.util.List;
/** Moves (rearranges) classes and class members according to rules specified by the user. */
public final class Mover {
private final List<ClassContentsEntry> myOuterClasses = new ArrayList<ClassContentsEntry>();
private final RearrangerSettings mySettings;
public Mover(final List<? extends ClassContentsEntry> outerClasses, final RearrangerSettings settings) {
myOuterClasses.addAll(outerClasses);
mySettings = settings;
}
public List<RuleInstance> rearrangeOuterClasses() {
final GenericRearranger outerClassRearranger = new GenericRearranger(
mySettings.getClassOrderAttributeList(),
myOuterClasses,
0,
mySettings)
{
/**
* There are no items related to outer classes -- outer classes are completely disjoint
* and independent. Hence this routine does nothing.
* @param entries
@param rearrangedEntries
*/
public void rearrangeRelatedItems(List<ClassContentsEntry> entries, List<RuleInstance> rearrangedEntries) {
}
};
return outerClassRearranger.rearrangeEntries();
}
}
plugins/rearranger/src/com/wrq/rearranger/rearrangement/Parser.java
-76
View File
@@ -1,76 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.rearrangement;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiFile;
import com.wrq.rearranger.entry.ClassContentsEntry;
import com.wrq.rearranger.entry.ClassEntry;
import com.wrq.rearranger.entry.PsiFileEntry;
import com.wrq.rearranger.entry.RangeEntry;
import com.wrq.rearranger.settings.RearrangerSettings;
import org.jetbrains.annotations.NotNull;
import java.util.List;
/** Creates a list of entries for classes and class members by parsing the Java file. */
public final class Parser {
private static final Logger LOG = Logger.getInstance("#" + Parser.class.getName());
private final Project myProject;
private final RearrangerSettings mySettings;
private final PsiFile myPsiFile;
public Parser(final @NotNull Project project, final @NotNull RearrangerSettings settings, final @NotNull PsiFile psiFile) {
myProject = project;
mySettings = settings;
myPsiFile = psiFile;
}
@NotNull
public List<ClassContentsEntry> parseOuterLevel() {
/**
* Parse the top level contents of the PsiFile here.
*/
PsiFileEntry fileEntry = new PsiFileEntry(mySettings);
return fileEntry.parseFile(myProject, myPsiFile);
}
@SuppressWarnings("UnusedDeclaration")
private static void dumpOuterClasses(final List<? extends ClassEntry> outerClasses) {
LOG.debug("Outer class entries:");
for (ClassEntry classEntry : outerClasses) {
LOG.debug(classEntry.toString());
if (classEntry.getContents() == null) {
// this is a header or trailer, and isn't really a class.
continue;
}
LOG.debug(" === class contents:");
for (RangeEntry rangeEntry : classEntry.getContents()) {
LOG.debug(rangeEntry.toString());
}
LOG.debug(" === end class contents:");
}
}
}
plugins/rearranger/src/com/wrq/rearranger/rearrangement/Spacer.java
-669
View File
@@ -1,669 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.rearrangement;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.editor.Document;
import com.intellij.psi.*;
import com.wrq.rearranger.settings.ForceBlankLineSetting;
import com.wrq.rearranger.settings.RearrangerSettings;
import javax.swing.*;
import java.util.HashMap;
import java.util.Map;
/** Responsible for adjusting the number of blank lines at strategic places in the source file. */
public class Spacer {
private static final Logger LOG = Logger.getInstance("#" + Spacer.class.getName());
private final PsiFile myFile;
private final Document myDocument;
private final RearrangerSettings mySettings;
private final char[] myNewlineChars;
private boolean myChangesMade;
private StringBuilder myBuffer;
private Map<PsiWhiteSpace, VirtualElement> virtualElements = new HashMap<PsiWhiteSpace, VirtualElement>();
public Spacer(PsiFile psiFile, Document document, RearrangerSettings settings) {
myFile = psiFile;
myDocument = document;
mySettings = settings;
myChangesMade = false;
int size = 0;
size += settings.getAfterClassLBrace().getnBlankLines() + 1;
size += settings.getBeforeMethodLBrace().getnBlankLines() + 1;
size += settings.getAfterMethodLBrace().getnBlankLines() + 1;
size += settings.getBeforeMethodRBrace().getnBlankLines() + 1;
size += settings.getAfterMethodRBrace().getnBlankLines() + 1;
size += settings.getBeforeClassRBrace().getnBlankLines() + 1;
size += settings.getAfterClassRBrace().getnBlankLines() + 1;
LOG.debug("constructor allocating " + size + " newline chars for max insertion");
myNewlineChars = new char[size];
while (size > 0) {
myNewlineChars[--size] = '\n';
}
LOG.debug(settings.getAfterClassLBrace().toString());
LOG.debug(settings.getBeforeMethodLBrace().toString());
LOG.debug(settings.getAfterMethodLBrace().toString());
LOG.debug(settings.getBeforeMethodRBrace().toString());
LOG.debug(settings.getAfterMethodRBrace().toString());
LOG.debug(settings.getBeforeClassRBrace().toString());
LOG.debug(settings.getAfterClassRBrace().toString());
final int ROOM_FOR_EXPANSION = 100;
int maxSize = document.getTextLength() + ROOM_FOR_EXPANSION;
myBuffer = new StringBuilder(maxSize);
}
private static class AbortRespacingException extends RuntimeException {
}
private static class BadPsiElementException extends Exception {
BadPsiElementException(String string) {
super(string);
}
}
private static void handleBadPsiElementException(String desc, PsiElement element)
throws AbortRespacingException
{
if (!ApplicationManager.getApplication().isUnitTestMode()) {
JOptionPane.showMessageDialog(null,
"Spacing could not be performed due to a syntax error:\n" +
desc + element.getText(), "Spacing Error", JOptionPane.ERROR_MESSAGE);
}
throw new AbortRespacingException();
}
public boolean respace() {
myBuffer.append(myDocument.getText());
JavaElementVisitor visitor = new JavaRecursiveElementVisitor() {
private int bias = 0;
public void visitReferenceExpression(PsiReferenceExpression referenceExpression) {
}
public void visitFile(PsiFile psiFile) {
super.visitFile(psiFile);
if (mySettings.getNewLinesAtEOF().isForce()) {
// remove all newlines at end of file, then append as many as are declared in configuration.
while (myBuffer.length() > 0 && myBuffer.charAt(myBuffer.length() - 1) == '\n') {
myBuffer.setLength(myBuffer.length() - 1);
}
for (int count = 0; count < mySettings.getNewLinesAtEOF().getnBlankLines(); count++) {
myBuffer.append('\n');
}
}
}
public void visitAnonymousClass(PsiAnonymousClass psiAnonymousClass) {
super.visitAnonymousClass(psiAnonymousClass);
}
public void visitClass(PsiClass psiClass) {
if (psiClass instanceof PsiTypeParameter) {
return;
}
boolean anonymous = psiClass.getName() == null;
int oldbias = bias;
try {
bias += adjustSpacing(
psiClass.getLBrace(),
psiClass.getRBrace(),
mySettings.getAfterClassLBrace(),
bias
);
}
catch (BadPsiElementException badPsiElement) {
handleBadPsiElementException("class " + psiClass.getName() + " missing left brace. Body follows:", psiClass);
}
log(mySettings.getAfterClassLBrace(), psiClass.getName(), oldbias, bias);
super.visitClass(psiClass);
oldbias = bias;
try {
bias += adjustSpacing(
psiClass.getRBrace(),
psiClass.getLBrace(),
mySettings.getBeforeClassRBrace(),
bias
);
}
catch (BadPsiElementException badPsiElement) {
handleBadPsiElementException("class " + psiClass.getName() + " missing right brace. Body follows:", psiClass);
}
log(mySettings.getBeforeClassRBrace(), psiClass.getName(), oldbias, bias);
if (anonymous) {
return;
}
/**
* if this is the last class in a file, don't adjust spacing after right brace.
* The setting for number of newline characters at end of file overrides it.
*/
boolean lastClass = false;
if (psiClass.getParent() instanceof PsiJavaFile) {
lastClass = isLastMeaningfulElement(psiClass.getParent(), psiClass);
}
if (!lastClass) {
oldbias = bias;
try {
bias += adjustSpacing(
psiClass.getRBrace(),
psiClass.getLBrace(),
mySettings.getAfterClassRBrace(),
bias
);
}
catch (BadPsiElementException badPsiElement) {
handleBadPsiElementException("class " + psiClass.getName() + " missing left brace. Body follows:", psiClass);
}
log(mySettings.getAfterClassRBrace(), psiClass.getName(), oldbias, bias);
}
else {
LOG.debug(
"class " +
psiClass.getName() +
" is last in file, no 'after right brace' adjustment"
);
}
}
public void visitMethod(PsiMethod psiMethod) {
int oldbias;
/**
* if method has no body, make no spacing adjustments - there are no braces. It must be an interface
* or abstract method declaration.
*/
if (psiMethod.getBody() == null) {
LOG.debug("skipping interface or abstract method " + psiMethod.getName());
super.visitMethod(psiMethod);
return;
}
/**
* if method has an empty body, do only the spacing before the opening brace and after the closing
* brace.
*/
boolean methodIsEmpty = true;
{
PsiElement element = psiMethod.getBody().getLBrace().getNextSibling();
while (element != null) {
if (!(element instanceof PsiWhiteSpace) &&
element != psiMethod.getBody().getRBrace())
{
methodIsEmpty = false;
break;
}
element = element.getNextSibling();
}
}
if (!methodIsEmpty) {
oldbias = bias;
try {
bias += adjustSpacing(
psiMethod.getBody().getLBrace(),
psiMethod.getBody().getRBrace(),
mySettings.getBeforeMethodLBrace(),
bias
);
bias += adjustSpacing(
psiMethod.getBody().getLBrace(),
psiMethod.getBody().getRBrace(),
mySettings.getAfterMethodLBrace(),
bias
);
}
catch (BadPsiElementException badPsiElement) {
handleBadPsiElementException("body of method " + psiMethod.getName() + " missing left brace. Body follows:", psiMethod);
}
log(mySettings.getAfterMethodLBrace(), psiMethod.getName(), oldbias, bias);
super.visitMethod(psiMethod);
oldbias = bias;
try {
bias += adjustSpacing(
psiMethod.getBody().getRBrace(),
psiMethod.getBody().getLBrace(),
mySettings.getBeforeMethodRBrace(),
bias
);
}
catch (BadPsiElementException badPsiElement) {
handleBadPsiElementException("body of method " + psiMethod.getName() + " missing right brace. Body follows:", psiMethod);
}
log(mySettings.getBeforeMethodRBrace(), psiMethod.getName(), oldbias, bias);
}
else {
LOG.debug("method " + psiMethod.getName() + " is empty, no internal spacing changes");
}
/**
* if this is the last method in a class, don't adjust spacing after right brace.
* The class setting for number of spaces before closing right brace overrides it.
* Normally this would make no difference, as the 2nd would cancel out the first;
* but in the case where the method ends with "}});" (anonymous inner class as
* parameter), an inserted blank line actually causes two newline characters to be
* inserted; but the class rule only removes one of those.
*/
boolean lastMethod = false;
PsiClass owner = psiMethod.getContainingClass();
if (owner == psiMethod.getParent()) {
lastMethod = isLastMeaningfulElement(owner, psiMethod);
}
if (!lastMethod) {
oldbias = bias;
try {
bias += adjustSpacing(
psiMethod.getBody().getRBrace(),
psiMethod.getBody().getLBrace(),
mySettings.getAfterMethodRBrace(),
bias
);
}
catch (BadPsiElementException badPsiElement) {
handleBadPsiElementException("body of method " + psiMethod.getName() + " missing right brace. Body follows:", psiMethod);
}
log(mySettings.getAfterMethodRBrace(), psiMethod.getName(), oldbias, bias);
}
else {
LOG.debug(
"method " +
psiMethod.getName() +
" is last in class, no 'after right brace' adjustment"
);
}
}
public void visitCodeBlock(PsiCodeBlock psiCodeBlock) {
int oldbias;
if (!(psiCodeBlock.getParent() instanceof PsiMethod) &&
mySettings.isRemoveBlanksInsideCodeBlocks())
{
oldbias = bias;
try {
bias += adjustSpacing(psiCodeBlock.getLBrace(),
psiCodeBlock.getRBrace(), false, 0, bias);
}
catch (BadPsiElementException badPsiElement) {
handleBadPsiElementException("code block missing left brace. Content follows:\n", psiCodeBlock);
}
log("code block left brace", oldbias, bias);
}
super.visitCodeBlock(psiCodeBlock);
if (!(psiCodeBlock.getParent() instanceof PsiMethod) &&
mySettings.isRemoveBlanksInsideCodeBlocks())
{
oldbias = bias;
try {
bias += adjustSpacing(psiCodeBlock.getRBrace(), psiCodeBlock.getLBrace(), true, 0, bias);
}
catch (BadPsiElementException badPsiElement) {
handleBadPsiElementException("code block missing right brace. Content follows:\n", psiCodeBlock);
}
log("code block right brace", oldbias, bias);
}
}
};
try {
myFile.accept(visitor);
}
catch (AbortRespacingException ar) {
return false;
}
if (myChangesMade) {
LOG.debug(
"changes made to document; old length=" +
myDocument.getTextLength() + ", new=" + myBuffer.length()
);
LOG.debug("old document is:\n" + myDocument.getText());
LOG.debug("new document is:\n" + myBuffer.toString());
myDocument.replaceString(0, myDocument.getTextLength(), myBuffer.toString());
}
return myChangesMade;
}
/**
* Determines if the psiElement (method or class) is last syntactic item in the owner class.
* If so, we don't want to change spacing after right brace of psiElement; this spacing is
* overridden by the parent class's spacing before right brace.
*
* @param owner class element to which psiElement belongs.
* @param psiElement method or inner class to be tested.
* @return true if the psiElement is the last syntactic item (i.e., not including comments and whitespace)
* of the owner.
*/
private static boolean isLastMeaningfulElement(PsiElement owner, PsiElement psiElement) {
boolean lastMethod;
// class is immediate parent
PsiElement[] elements = owner.getChildren();
boolean sawThisMethod = false;
boolean sawSomethingElseLater = false;
for (PsiElement element : elements) {
if (!sawThisMethod && element == psiElement) {
sawThisMethod = true;
}
else if (sawThisMethod &&
!(element instanceof PsiWhiteSpace) &&
!(element instanceof PsiJavaToken &&
element.getText().equals("}")))
// ((PsiJavaToken) elements[i]).getTokenType() == PsiJavaToken.RBRACE))
{
sawSomethingElseLater = true;
break;
}
}
lastMethod = sawThisMethod && !sawSomethingElseLater;
return lastMethod;
}
private static void log(ForceBlankLineSetting fbls, String name, int oldbias, int bias) {
if (oldbias != bias) {
LOG.debug(
fbls.getObjectName() +
" " +
name +
(fbls.isBefore() ? " before" : " after") +
(fbls.isOpenBrace() ? " left brace:" : " right brace:") +
(oldbias < bias ? " inserted " + (bias - oldbias)
: " removed " + (oldbias - bias)) + " newlines"
);
}
}
private static void log(String name, int oldbias, int bias) {
if (oldbias != bias) {
LOG.debug(
name +
(oldbias < bias ? " inserted " + (bias - oldbias)
: " removed " + (oldbias - bias)) + " newlines"
);
}
}
private int adjustSpacing(PsiElement brace, PsiElement matchingBrace, ForceBlankLineSetting fbls, int bias)
throws BadPsiElementException
{
if (fbls.isForce()) {
return adjustSpacing(brace, matchingBrace, fbls.isBefore(), fbls.getnBlankLines(), bias);
}
else {
return 0;
}
}
/**
* When whiteSpace is changed based on contents of a PsiWhiteSpace element, we need to keep track of that
* so that if a subsequent adjustment in spacing is based on that same element, we use the new whitespace value.
*/
private class VirtualElement {
private String textValue;
private final int textOffset;
VirtualElement(PsiWhiteSpace whiteSpace, int bias) {
textValue = whiteSpace.getText();
textOffset = whiteSpace.getTextOffset() + bias;
virtualElements.put(whiteSpace, this);
}
String getText() {
return textValue;
}
public void setTextValue(String textValue) {
this.textValue = textValue;
}
public int getTextOffset() {
return textOffset;
}
}
/**
* Determine the number of blank lines actually occurring before or after the brace. If this is not
* the desired number, alter the whitespace before or after the brace to contain the desired number
* of blank lines.
*
* @param brace
* @param before
* @param nBlankLines
* @param bias
* @return bias adjustment corresponding to number of newlines inserted or deleted
*/
private int adjustSpacing(PsiElement brace, PsiElement matchingBrace, boolean before, int nBlankLines, int bias)
throws BadPsiElementException
{
int result = 0;
if (brace == null) {
throw new BadPsiElementException(
"adjustSpacing: illegal syntax (mismatched braces); PsiElement for brace is null"
);
}
/*
* ensure that character at offset indicated by brace element is in fact a brace.
*/
int offset = brace.getTextRange().getStartOffset() + bias;
int direction = before ? -1 : +1;
int count = 0;
{
char braceChar = myBuffer.charAt(offset);
if (braceChar != '{' && braceChar != '}') {
int L = offset - 50;
int R = offset + 50;
if (L < 0) {
L = 0;
}
if (R > myBuffer.length()) {
R = myBuffer.length();
}
String context = myBuffer.toString().substring(L, R);
throw new RuntimeException(
"adjustSpacing: char at offset " +
offset +
" is not a brace, ='" +
braceChar + "'" + "; context is " + context
);
}
}
/*
* Locate the whitespace that precedes or follows this brace and which contains newline characters.
* Intervening text, such as comments and other syntactic items, could be skipped.
*/
PsiElement whiteSpace = brace;
do {
whiteSpace = getNextElement(whiteSpace, before);
if (whiteSpace == matchingBrace) {
/**
* Don't parse past the matching brace. This could occur if a class or method body is empty and
* the left and right braces are on the same line with no intervening whitespace.
*/
return result;
}
}
while (whiteSpace != null && (!(whiteSpace instanceof PsiWhiteSpace) || whiteSpace.getText().indexOf('\n') < 0));
VirtualElement virtualWhiteSpace = null;
if (whiteSpace != null) {
virtualWhiteSpace = (virtualElements.get(whiteSpace));
if (virtualWhiteSpace == null) {
virtualWhiteSpace = new VirtualElement((PsiWhiteSpace)whiteSpace, bias);
}
else {
LOG.debug("reusing virtualWhiteSpace, offset=" + virtualWhiteSpace.textOffset);
}
/*
* now count the number of newlines.
*/
String s = virtualWhiteSpace.getText();
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) == '\n') {
count++;
}
}
}
/**
* first count the number of existing blank lines.
*/
if (offset + direction >= myBuffer.length()) {
LOG.debug("at EOF, don't append any extra blank lines");
// we're at end of file. Don't append any extra blank lines.
nBlankLines = 0;
}
/**
* Count of one means there was a single newline character next to the brace.
* This can be counted as the one that belongs on the brace's line. So the real number
* of consecutive newline characters desired is nBlankLines + 1.
*/
int desiredNewlineChars = nBlankLines + 1;
if (desiredNewlineChars == 1 && count == 0 && before) {
// no blank lines to precede this text; in fact, there's prior text and no newline character at all.
// this is acceptable.
desiredNewlineChars = 0;
}
{
PsiElement element = brace.getParent();
if (element instanceof PsiCodeBlock &&
element.getParent() instanceof PsiMethod)
{
element = element.getParent();
}
LOG.debug(
"adjustSpacing: " +
(before ? "before " : "after ") +
element.toString() +
" " +
brace.getText() +
", desire " + desiredNewlineChars + " newlines, have " + count
);
}
if (desiredNewlineChars == count) {
return 0;
}
/*
* determine end index of whitespace to be replaced.
* keep trailing spaces/tabs.
*/
int endIndex;
// if (whiteSpace != null) // todo - try modifying the PSI tree
// {
// try
// {
// StringBuilder sbr = new StringBuilder(whiteSpace.getText());
// if (desiredNewlineChars > count) sbr.append(newlineChars, 0, desiredNewlineChars - count);
// else sbr.setLength(sbr.length() + desiredNewlineChars - count);
// PsiElement codeblk = factory.createCodeBlockFromText(sbr.toString(), element);
// whiteSpace.replace(codeblk.getFirstChild());
// }
// catch (IncorrectOperationException e)
// {
// e.printStackTrace(); //To change body of catch statement use File | Settings | File Templates.
// }
// }
if (virtualWhiteSpace != null) {
String s = virtualWhiteSpace.getText();
for (endIndex = s.length() - 1; endIndex >= 0; endIndex--) {
if (s.charAt(endIndex) != ' ' &&
s.charAt(endIndex) != '\t')
{
break;
}
} // now endIndex points to the last newline character in the whitespace.
offset = virtualWhiteSpace.getTextOffset();
endIndex += offset + 1;
}
else {
offset = endIndex = myBuffer.length();
}
try {
myChangesMade = true;
LOG.debug(
"sb.replace(" +
offset +
"," +
endIndex + ") with " + desiredNewlineChars + " newline characters"
);
myBuffer.replace(offset, endIndex, new String(myNewlineChars, 0, desiredNewlineChars));
result = desiredNewlineChars - (endIndex - offset);
// now update virtualWhiteSpace accordingly.
if (virtualWhiteSpace != null) {
offset -= virtualWhiteSpace.getTextOffset();
endIndex -= virtualWhiteSpace.getTextOffset();
StringBuffer vsb = new StringBuffer(virtualWhiteSpace.getText());
vsb.replace(offset, endIndex, new String(myNewlineChars, 0, desiredNewlineChars));
virtualWhiteSpace.setTextValue(vsb.toString());
}
}
catch (StringIndexOutOfBoundsException si) {
throw new RuntimeException(
"sb.length()=" +
myBuffer.length() +
", offset=" +
offset +
", before=" +
before +
", count=" +
count +
", desiredNewlineChars=" +
desiredNewlineChars +
", charAt offset=" + (offset < myBuffer.length() ? "" + myBuffer.charAt(offset) : "OOB"), si
);
}
return result;
}
/**
* Returns the leaf psiElement before or after the given element.
*
* @param element original element.
* @param before if true, return prior leaf element; else return next left element.
* @return adjacent leaf element.
*/
private PsiElement getNextElement(PsiElement element, boolean before) {
PsiElement result;
while (true) {
result = before ? element.getPrevSibling() : element.getNextSibling();
if (result == null) {
// first/last sibling; go to parent's previous/next item.
result = element.getParent();
if (result instanceof PsiFile) {
// don't go beyond this document!
result = null;
}
// if we started at the first/last leaf node, we run out of parents; there is no previous/next leaf element.
if (result == null) {
break;
}
else {
element = result;
}
}
else {
break;
}
}
while (result != null && result.getChildren().length != 0) {
// previous/next sibling is parent of others; find last/first leaf node.
result = result.getChildren()[before ? result.getChildren().length - 1 : 0];
}
return result;
}
}
plugins/rearranger/src/com/wrq/rearranger/ruleinstance/CommentRuleInstance.java
-183
View File
@@ -1,183 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.ruleinstance;
import com.wrq.rearranger.entry.ClassContentsEntry;
import com.wrq.rearranger.entry.RangeEntry;
import com.wrq.rearranger.popup.FilePopupEntry;
import com.wrq.rearranger.rearrangement.Emitter;
import com.wrq.rearranger.settings.CommentRule;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.settings.attributeGroups.Rule;
import org.jetbrains.annotations.Nullable;
import javax.swing.*;
import javax.swing.tree.DefaultMutableTreeNode;
import java.awt.*;
import java.util.Collections;
import java.util.List;
/** Used to store a generated comment, and to determine if it should be emitted. */
public abstract class CommentRuleInstance implements RuleInstance, FilePopupEntry {
protected final CommentRule myCommentRule;
protected boolean myEmit;
public CommentRuleInstance(final CommentRule commentRule) {
this.myCommentRule = commentRule;
myEmit = false;
}
public boolean isEmit() {
return myEmit;
}
public void setEmit(final boolean emit) {
this.myEmit = emit;
}
public Rule getRule() {
return myCommentRule;
}
/** Determine if this comment, in this instance, should be emitted. */
public abstract void determineEmit(List<RuleInstance> resultRuleInstances, int startIndex);
public boolean hasMatches() {
return false; // a generated comment never matches any object
}
public void emit(Emitter emitter) {
StringBuilder sb = emitter.getTextBuffer();
if (myEmit) {
// emit a comment. Precede with a newline unless this is the first line of the file.
if (sb.length() > 0) {
sb.append('\n');
sb.append(myCommentRule.getExpandedCommentText());
}
else {
sb.append(myCommentRule.getExpandedCommentText());
sb.append('\n');
}
}
}
public void addEntry(RangeEntry entry) // adds entry to list of matching entries, in correct order
{
// comment rules don't match anything in the existing file; they conditionally generate comments.
// So this method will never be called.
throw new RuntimeException("cannot add entry to comment rule instance");
}
public List<RangeEntry> getMatches() {
return Collections.emptyList();
}
public void rearrangeRuleItems(List<ClassContentsEntry> entries, RearrangerSettings settings) {
}
public void addRuleInstanceToPopupTree(DefaultMutableTreeNode node, RearrangerSettings settings) {
/**
* if we are supposed to show comment rules, create a node for the rule and put its contents below.
* Otherwise, just add comments.
*/
if (!settings.isShowComments()) return;
DefaultMutableTreeNode top = node;
if (settings.isShowRules()) {
// if "show matched rules only" is set, only display if comment will be emitted
if ((!settings.isShowMatchedRules()) || isEmit()) {
top = new DefaultMutableTreeNode(this);
node.add(top);
}
}
/**
* append the comment if generated and if showComments is set.
*/
if (isEmit()) {
myCommentRule.addToPopupTree(top, settings);
}
}
public String getTypeIconName() {
return null;
}
@Nullable
public String[] getAdditionalIconNames() {
return null;
}
public JLabel getPopupEntryText(RearrangerSettings settings) {
JLabel label = new JLabel(myCommentRule.toString());
Font font = label.getFont().deriveFont(Font.ITALIC);
label.setFont(font);
return label;
}
public String toString() {
return "instance of:" + myCommentRule.toString();
}
/**
* Beginning at the index of ruleStatistics (which is a comment entry), find nRules in the direction indicated,
* and test to see if all or any of them had entries that matched.
*
* @param nRules number of rules to consider for matching algorithm.
* @param direction 1 = subsequent, -1 = previous.
* @param startIndex comment entry index, sandwiched between rules.
* @param ANDing if true, all rules must be matched; if false, any rule that matches returns a result of true.
* @return true if the match condition is met.
*/
@SuppressWarnings({"MethodParameterNamingConvention"})
protected boolean match(final List<RuleInstance> resultRuleInstances,
final int nRules,
final int direction,
final int startIndex,
final boolean ANDing)
{
int index = startIndex + direction;
int nRulesSeen = 0;
while (index >= 0 &&
index < resultRuleInstances.size() &&
nRulesSeen < nRules)
{
if (!(resultRuleInstances.get(index) instanceof CommentRuleInstance)) {
// this is a rule entry, not a comment.
nRulesSeen++;
final RuleInstance ruleInstance = resultRuleInstances.get(index);
if (ruleInstance.hasMatches()) {
if (!ANDing) {
return true; // OR condition (any matching rule) met
}
}
else {
if (ANDing) {
return false; // AND condition not met
}
}
}
index += direction;
}
return ANDing;
}
}
plugins/rearranger/src/com/wrq/rearranger/ruleinstance/CommentRuleInstanceFactory.java
-47
View File
@@ -1,47 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.ruleinstance;
import com.wrq.rearranger.settings.CommentRule;
/** Creates appropriate subtype of CommentRuleInstance from a CommentRule. */
@SuppressWarnings({"UtilityClass"})
public class CommentRuleInstanceFactory {
private CommentRuleInstanceFactory() {
}
@SuppressWarnings({"MethodWithMultipleReturnPoints"})
public static CommentRuleInstance buildCommentRuleInstance(CommentRule rule) {
switch (rule.getEmitCondition()) {
case CommentRule.EMIT_ALWAYS:
return new EmitAlwaysCommentRuleInstance(rule);
case CommentRule.EMIT_IF_ITEMS_MATCH_SURROUNDING_RULES:
return new SurroundingCommentRuleInstance(rule);
case CommentRule.EMIT_IF_ITEMS_MATCH_SUBSEQUENT_RULE:
return new SubsequentCommentRuleInstance(rule);
case CommentRule.EMIT_IF_ITEMS_MATCH_PRECEDING_RULE:
return new PrecedingCommentRuleInstance(rule);
default:
throw new IllegalStateException("unknown emit condition type=" + rule.getEmitCondition());
}
}
}
plugins/rearranger/src/com/wrq/rearranger/ruleinstance/CommonRuleInstance.java
-161
View File
@@ -1,161 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.ruleinstance;
import com.intellij.openapi.diagnostic.Logger;
import com.wrq.rearranger.entry.ClassContentsEntry;
import com.wrq.rearranger.entry.PopupTreeRangeEntry;
import com.wrq.rearranger.entry.MethodEntry;
import com.wrq.rearranger.entry.RangeEntry;
import com.wrq.rearranger.popup.FilePopupEntry;
import com.wrq.rearranger.rearrangement.Emitter;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.settings.atomicAttributes.SortOptions;
import com.wrq.rearranger.settings.attributeGroups.CommonAttributes;
import com.wrq.rearranger.settings.attributeGroups.Rule;
import javax.swing.*;
import javax.swing.tree.DefaultMutableTreeNode;
import java.awt.*;
import java.util.ArrayList;
import java.util.List;
/** Handles basic Rule functions. */
public abstract class CommonRuleInstance
implements RuleInstance,
FilePopupEntry
{
private static final Logger LOG = Logger.getInstance("#" + CommonRuleInstance.class.getName());
protected final Rule myRule;
protected final List<RangeEntry> matchedItems;
public CommonRuleInstance(Rule rule) {
myRule = rule;
matchedItems = new ArrayList<RangeEntry>();
}
public Rule getRule() {
return myRule;
}
/**
* adds entry to list of matching entries, in correct order (order encountered, or alphabetically)
*
* @param entry
*/
public void addEntry(RangeEntry entry) {
if (myRule instanceof CommonAttributes) {
SortOptions sortOptions = ((CommonAttributes)myRule).getSortOptions();
insertionSort(entry, sortOptions);
}
else {
matchedItems.add(entry);
}
}
public List<RangeEntry> getMatches() {
return matchedItems;
}
private void insertionSort(final RangeEntry newEntry, final SortOptions sortOptions) {
boolean inserted = false;
final String s = sortOptions.generateSortString(newEntry);
LOG.debug("insertionSort: new entry=" + s);
int index = 0;
while (index < matchedItems.size()) {
final RangeEntry re = matchedItems.get(index);
final String res = sortOptions.generateSortString(re);
LOG.debug("insertionSort: compare to " + res);
if (s.compareTo(res) < 0) {
LOG.debug("insertionSort: insert at " + index);
matchedItems.add(index, newEntry);
inserted = true;
break;
}
index++;
}
if (!inserted) {
LOG.debug("insertionSort: add " + s + " to end");
matchedItems.add(newEntry);
}
}
public boolean hasMatches() {
return matchedItems.size() > 0;
}
public void emit(Emitter emitter) {
for (RangeEntry rangeEntry : matchedItems) {
rangeEntry.emit(emitter);
}
}
public void rearrangeRuleItems(List<ClassContentsEntry> entries,
RearrangerSettings settings)
{
MethodEntry.rearrangeRelatedItems(
entries,
this,
settings.getExtractedMethodsSettings()
);
}
public void addRuleInstanceToPopupTree(DefaultMutableTreeNode node, RearrangerSettings settings) {
/**
* if we are supposed to show rules, create a node for the rule and put its contents below.
* Otherwise, delegate to each of the matches.
*/
DefaultMutableTreeNode top = node;
if (settings.isShowRules() &&
(!settings.isShowMatchedRules() || hasMatches()))
{
top = new DefaultMutableTreeNode(this);
node.add(top);
}
/**
* append each of the matches to the top level.
*/
for (PopupTreeRangeEntry entry : getMatches()) {
entry.addToPopupTree(top, settings);
}
}
public String getTypeIconName() {
return "general/templateGroup";
}
public String[] getAdditionalIconNames() {
return null;
}
public JLabel getPopupEntryText(RearrangerSettings settings) {
JLabel label = new JLabel(toString());
Font font = label.getFont().deriveFont(Font.ITALIC);
label.setFont(font);
return label;
}
public String toString() {
return getRule().toString();
}
}
plugins/rearranger/src/com/wrq/rearranger/ruleinstance/DefaultRuleInstance.java
-35
View File
@@ -1,35 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.ruleinstance;
import com.wrq.rearranger.settings.attributeGroups.Rule;
/** Collects any remaining RangeEntries after all explicit rule matching is done. */
public class DefaultRuleInstance extends CommonRuleInstance {
public DefaultRuleInstance(Rule defaultRule) {
super(defaultRule);
}
public String toString() {
return getRule().toString();
}
}
plugins/rearranger/src/com/wrq/rearranger/ruleinstance/EmitAlwaysCommentRuleInstance.java
-43
View File
@@ -1,43 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.ruleinstance;
import com.wrq.rearranger.settings.CommentRule;
import java.util.List;
/** Used to store a generated comment which is always emitted. */
public class EmitAlwaysCommentRuleInstance
extends CommentRuleInstance
{
public EmitAlwaysCommentRuleInstance(final CommentRule commentRule) {
super(commentRule);
}
/**
* Determine if this comment, in this instance, should be emitted.
* For an "Emit Always" type of comment, it should always be emitted.
*/
public void determineEmit(List<RuleInstance> resultRuleInstances, int startIndex) {
setEmit(true);
}
}
plugins/rearranger/src/com/wrq/rearranger/ruleinstance/HeaderTrailerRuleInstance.java
-80
View File
@@ -1,80 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.ruleinstance;
import com.wrq.rearranger.entry.ClassContentsEntry;
import com.wrq.rearranger.entry.RangeEntry;
import com.wrq.rearranger.rearrangement.Emitter;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.settings.attributeGroups.Rule;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import javax.swing.tree.DefaultMutableTreeNode;
import java.util.ArrayList;
import java.util.List;
/** Instance to pick up header text. */
public class HeaderTrailerRuleInstance implements RuleInstance {
@NotNull private final Rule myRule;
@Nullable private RangeEntry myEntry;
public HeaderTrailerRuleInstance(@NotNull Rule rule) {
myRule = rule;
}
public boolean hasMatches() {
return false; // comments are never emitted based on whether header text is emitted, so false is fine.
}
public List<RangeEntry> getMatches() {
List<RangeEntry> list = null;
if (myEntry != null) {
list = new ArrayList<RangeEntry>();
list.add(myEntry);
}
return list;
}
@NotNull
public Rule getRule() {
return myRule;
}
public void addEntry(@Nullable RangeEntry entry) {
myEntry = entry; // a header only has one entry
}
public void emit(Emitter emitter) {
if (myEntry != null) {
myEntry.emit(emitter);
}
}
public void rearrangeRuleItems(List<ClassContentsEntry> entries, RearrangerSettings settings) {
}
public void addRuleInstanceToPopupTree(DefaultMutableTreeNode node, RearrangerSettings settings) {
// don't show header/trailer junk in popup tree
}
}
plugins/rearranger/src/com/wrq/rearranger/ruleinstance/InterfaceInstance.java
-147
View File
@@ -1,147 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.ruleinstance;
import com.wrq.rearranger.entry.MethodEntry;
import com.wrq.rearranger.popup.FilePopupEntry;
import com.wrq.rearranger.rearrangement.Emitter;
import com.wrq.rearranger.settings.CommentRule;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.settings.attributeGroups.InterfaceAttributes;
import javax.swing.*;
import javax.swing.tree.DefaultMutableTreeNode;
import java.awt.*;
import java.util.ArrayList;
import java.util.List;
/** Corresponds to a single interface with one or more implementing methods. */
public class InterfaceInstance
implements FilePopupEntry
{
// ------------------------------------------------------- FIELDS ------------------------------------------------------
private String interfaceName;
public String getInterfaceName() {
return interfaceName;
}
private List<MethodEntry> methods;
private InterfaceAttributes rule;
// ---------------------------------------------------- CONSTRUCTORS ---------------------------------------------------
public InterfaceInstance(String interfaceName, InterfaceAttributes rule) {
this.interfaceName = interfaceName;
methods = new ArrayList<MethodEntry>();
this.rule = rule;
}
// ---------------------------------------------- GETTER / SETTER METHODS ----------------------------------------------
public String[] getAdditionalIconNames() {
return null;
}
public String getTypeIconName() {
return null;
}
// ------------------------------------------------- INTERFACE METHODS -------------------------------------------------
// --------------------------------------------- Interface IFilePopupEntry ---------------------------------------------
public JLabel getPopupEntryText(RearrangerSettings settings) {
JLabel label = new JLabel("methods of interface " + interfaceName);
Font font = label.getFont().deriveFont(Font.ITALIC);
label.setFont(font);
return label;
}
// --------------------------------------------------- OTHER METHODS ---------------------------------------------------
/**
* add the method to the list of methods, in the order specified by the configuration settings (alphabetical,
* in order declared in the interface, or in order encountered).
*
* @param entry method to add.
*/
void addMethod(MethodEntry entry) {
switch (rule.getMethodOrder()) {
case InterfaceAttributes.METHOD_ORDER_ALPHABETICAL:
entry.insertAlphabetically(methods);
break;
case InterfaceAttributes.METHOD_ORDER_ENCOUNTERED:
methods.add(entry);
break;
case InterfaceAttributes.METHOD_ORDER_INTERFACE_ORDER:
entry.insertInterfaceOrder(methods);
break;
}
}
public void addToPopupTree(DefaultMutableTreeNode node, RearrangerSettings settings) {
/**
* if we are supposed to show rules, create a node for the rule and put its contents below.
* Otherwise, delegate to each of the matches.
*/
DefaultMutableTreeNode top = node;
if (settings.isShowRules()) {
top = new DefaultMutableTreeNode(this);
node.add(top);
}
/**
* append each of the matches to the top level.
*/
for (MethodEntry entry : methods) {
entry.addToPopupTree(top, settings);
}
}
@SuppressWarnings("MismatchedQueryAndUpdateOfStringBuilder")
void emit(Emitter emitter) {
StringBuilder buffer = emitter.getTextBuffer();
String commentString = expandComment(rule.getPrecedingComment());
if (commentString.length() > 0) {
buffer.append("\n");
buffer.append(commentString);
}
for (MethodEntry rangeEntry : methods) {
rangeEntry.emit(emitter);
}
commentString = expandComment(rule.getTrailingComment());
if (commentString.length() > 0) {
buffer.append("\n");
buffer.append(commentString);
}
}
private String expandComment(CommentRule comment) {
if (comment == null || comment.getCommentText() == null) return "";
comment.setCommentFillString(rule.getCommentFillString());
String result = comment.getCommentText().replaceAll("%IF%", interfaceName);
result = rule.getCommentFillString().getExpandedCommentText(result);
return result;
}
}
plugins/rearranger/src/com/wrq/rearranger/ruleinstance/InterfaceRuleInstance.java
-136
View File
@@ -1,136 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.ruleinstance;
import com.wrq.rearranger.entry.ClassContentsEntry;
import com.wrq.rearranger.entry.MethodEntry;
import com.wrq.rearranger.entry.RangeEntry;
import com.wrq.rearranger.rearrangement.Emitter;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.settings.attributeGroups.Rule;
import com.wrq.rearranger.settings.attributeGroups.InterfaceAttributes;
import javax.swing.tree.DefaultMutableTreeNode;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
/** Handles interface rule processing. */
public class InterfaceRuleInstance
extends CommonRuleInstance
{
// ------------------------------ FIELDS ------------------------------
List<InterfaceInstance> interfaceInstances;
// --------------------------- CONSTRUCTORS ---------------------------
public InterfaceRuleInstance(Rule rule) {
super(rule);
interfaceInstances = new ArrayList<InterfaceInstance>();
}
// -------------------------- OTHER METHODS --------------------------
/**
* override the supermethod because we never want to alphabetize methods based on the "alphabetize" flag; that
* flag controls whether interfaces are alphabetized or not. Just add the methods to the list in order encountered.
*
* @param entry
*/
public void addEntry(RangeEntry entry) {
matchedItems.add((MethodEntry)entry);
}
public void addRuleInstanceToPopupTree(DefaultMutableTreeNode node, RearrangerSettings settings) {
/**
* if we are supposed to show rules, create a node for the rule and put its contents below.
* Otherwise, delegate to each of the matches.
*/
DefaultMutableTreeNode top = node;
if (settings.isShowRules()) {
top = new DefaultMutableTreeNode(this);
node.add(top);
}
/**
* An InterfaceRuleInstance has a list of InterfaceInstances, which in turn list the methods which matched
* the name of the interface. Build the tree accordingly.
*/
for (InterfaceInstance instance : interfaceInstances) {
instance.addToPopupTree(top, settings);
}
}
public void emit(Emitter emitter) {
for (Object interfaceInstance : interfaceInstances) {
InterfaceInstance instance = (InterfaceInstance)interfaceInstance;
instance.emit(emitter);
}
}
public void rearrangeRuleItems(List<ClassContentsEntry> entries,
RearrangerSettings settings)
{
/**
* create a list of interface instances, one for each interface specified by any of the matched methods.
* Alphabetize this list if specified.
*/
for (RangeEntry re : matchedItems) {
MethodEntry me = (MethodEntry)re;
InterfaceInstance instance = null;
for (InterfaceInstance interfaceInstance : interfaceInstances) {
if (interfaceInstance.getInterfaceName().equals(me.getInterfaceName())) {
instance = interfaceInstance;
}
}
if (instance == null) {
final InterfaceAttributes interfaceRule = (InterfaceAttributes)getRule();
instance = new InterfaceInstance(me.getInterfaceName(), interfaceRule);
if (interfaceRule.isAlphabetize()) {
boolean inserted = false;
String s = instance.getInterfaceName();
ListIterator<InterfaceInstance> lii = interfaceInstances.listIterator();
while (lii.hasNext()) {
InterfaceInstance entry = (lii.next());
final String ename = entry.getInterfaceName();
if (s.compareTo(ename) < 0) {
interfaceInstances.add(lii.nextIndex() - 1, instance);
inserted = true;
break;
}
}
if (!inserted) {
interfaceInstances.add(instance);
}
}
else {
interfaceInstances.add(instance);
}
}
instance.addMethod(me);
}
MethodEntry.rearrangeRelatedItems(entries,
this,
settings.getExtractedMethodsSettings());
}
}
plugins/rearranger/src/com/wrq/rearranger/ruleinstance/PrecedingCommentRuleInstance.java
-47
View File
@@ -1,47 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.ruleinstance;
import com.wrq.rearranger.settings.CommentRule;
import java.util.List;
/** Used to store a generated comment which is emitted based on whether it matches preceding rules. */
public class PrecedingCommentRuleInstance extends CommentRuleInstance {
public PrecedingCommentRuleInstance(final CommentRule commentRule) {
super(commentRule);
}
/** Determine if this comment, in this instance, should be emitted. */
public void determineEmit(List<RuleInstance> resultRuleInstances, int startIndex) {
if (match(
resultRuleInstances,
myCommentRule.getNPrecedingRulesToMatch(),
-1,
startIndex,
myCommentRule.isAllPrecedingRules()))
{
setEmit(true);
}
}
}
plugins/rearranger/src/com/wrq/rearranger/ruleinstance/RuleInstance.java
-74
View File
@@ -1,74 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.ruleinstance;
import com.wrq.rearranger.entry.ClassContentsEntry;
import com.wrq.rearranger.entry.RangeEntry;
import com.wrq.rearranger.rearrangement.Emitter;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.settings.attributeGroups.Rule;
import org.jetbrains.annotations.Nullable;
import javax.swing.tree.DefaultMutableTreeNode;
import java.util.List;
/**
* One {@link RuleInstance} exists for every execution of every rule. An execution of a rule is the process by which
* items are matched to a rule.
*/
public interface RuleInstance {
/** @return true if one or more items matched the rule in this instance. */
boolean hasMatches();
/** @return list of items matching the rule in this instance. */
@Nullable
List<RangeEntry> getMatches();
/**
* Causes the text representation of this item to be emitted to a buffer, and from there into the final Document.
*
* @param emitter Emitter target object with buffer and Document.
*/
void emit(Emitter emitter);
/** @return the rule associated with this instance. */
Rule getRule();
/**
* Adds an item to the list of items matching the rule in this instance. Order is preserved.
*
* @param entry matching item
*/
void addEntry(RangeEntry entry);
/**
* Perform any rearranging based on rule or item relationships indicated by the settings.
*
* @param entries list of items (fields, methods, etc.)
* @param settings
*/
void rearrangeRuleItems(List<ClassContentsEntry> entries, RearrangerSettings settings);
/** add the contents of this rule to the file structure popup tree. */
void addRuleInstanceToPopupTree(DefaultMutableTreeNode node, RearrangerSettings settings);
}
plugins/rearranger/src/com/wrq/rearranger/ruleinstance/SubsequentCommentRuleInstance.java
-48
View File
@@ -1,48 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.ruleinstance;
import com.wrq.rearranger.settings.CommentRule;
import java.util.List;
/** Used to store a generated comment which is emitted based on whether it matches subsequent rules. */
public class SubsequentCommentRuleInstance extends CommentRuleInstance {
public SubsequentCommentRuleInstance(final CommentRule commentRule) {
super(commentRule);
}
/** Determine if this comment, in this instance, should be emitted. */
public void determineEmit(List<RuleInstance> resultRuleInstances, int startIndex) {
if (match(
resultRuleInstances,
myCommentRule.getNSubsequentRulesToMatch(),
+1,
startIndex,
myCommentRule.isAllSubsequentRules()
))
{
setEmit(true);
}
}
}
plugins/rearranger/src/com/wrq/rearranger/ruleinstance/SurroundingCommentRuleInstance.java
-57
View File
@@ -1,57 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.ruleinstance;
import com.wrq.rearranger.settings.CommentRule;
import java.util.List;
/** Used to store a generated comment which is emitted based on whether it matches surrounding rules. */
public class SurroundingCommentRuleInstance
extends CommentRuleInstance
{
public SurroundingCommentRuleInstance(final CommentRule commentRule) {
super(commentRule);
}
/** Determine if this comment, in this instance, should be emitted. */
public void determineEmit(List<RuleInstance> resultRuleInstances, int startIndex) {
if (match(
resultRuleInstances,
myCommentRule.getNPrecedingRulesToMatch(),
-1,
startIndex,
myCommentRule.isAllPrecedingRules()
) &&
match(
resultRuleInstances,
myCommentRule.getNSubsequentRulesToMatch(),
+1,
startIndex,
myCommentRule.isAllSubsequentRules()
))
{
setEmit(true);
}
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/CommentFillString.java
-180
View File
@@ -1,180 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings;
import com.wrq.rearranger.RearrangerActionHandler;
import com.wrq.rearranger.configuration.IntTextField;
import com.wrq.rearranger.settings.attributeGroups.RegexUtil;
import com.wrq.rearranger.util.CommentUtil;
import com.wrq.rearranger.util.Constraints;
import org.jdom.Attribute;
import org.jdom.Element;
import javax.swing.*;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
/** Implements routines for handling comment fill string expansion. */
public class CommentFillString {
private String fillString; // replicate in place of %FS%
private boolean useProjectWidthForFill;
private int fillWidth;
public CommentFillString() {
fillString = "";
useProjectWidthForFill = true;
fillWidth = 0;
}
public final String getExpandedCommentText(String commentText) {
int width = useProjectWidthForFill ? RearrangerActionHandler.getRightMargin() : fillWidth;
int tabSize = RearrangerActionHandler.getTabSize();
return CommentUtil.expandFill(commentText, width, tabSize, fillString);
}
public String getFillString() {
return fillString;
}
public void setFillString(String fillString) {
this.fillString = fillString;
}
public final boolean equals(final Object object) {
if (!(object instanceof CommentFillString)) return false;
final CommentFillString c = (CommentFillString)object;
return fillString.equals(c.fillString) &&
useProjectWidthForFill == c.useProjectWidthForFill &&
fillWidth == c.fillWidth;
}
public final CommentFillString deepCopy() {
final CommentFillString comment = new CommentFillString();
comment.fillString = fillString;
comment.useProjectWidthForFill = useProjectWidthForFill;
comment.fillWidth = fillWidth;
return comment;
}
public static CommentFillString readExternal(final Element item) {
final CommentFillString result = new CommentFillString();
Attribute fillAttr = RearrangerSettings.getAttribute(item, "fillString");
if (fillAttr == null) {
result.fillString = "";
}
else {
String fill = fillAttr.getValue();
result.fillString = CommentRule.unescape(fill);
}
result.useProjectWidthForFill = RearrangerSettings.getBooleanAttribute(item, "useProjectWidthForFill", true);
result.fillWidth = RearrangerSettings.getIntAttribute(item, "fillWidth", 0);
return result;
}
public final void writeExternal(final Element me) {
me.setAttribute("fillString", CommentRule.escape(fillString));
me.setAttribute("useProjectWidthForFill", String.valueOf(useProjectWidthForFill));
me.setAttribute("fillWidth", String.valueOf(fillWidth));
}
public final JPanel getCommentFillStringPanel() {
final JPanel cfsPanel = new JPanel(new GridBagLayout());
final Constraints constraints = new Constraints(GridBagConstraints.NORTHWEST);
constraints.fill = GridBagConstraints.BOTH;
constraints.insets = new Insets(4, 4, 4, 0);
constraints.newRow();
final JLabel fillStringLabel = new JLabel("Fill string:");
fillStringLabel.setToolTipText("Occurrences of %FS% in the comment separator text will be replaced with equal \n" +
"amounts of the fill string, replicated to make the comment end at the specified column");
cfsPanel.add(fillStringLabel, constraints.firstCol());
final JTextField fillString = new JTextField(this.fillString);
cfsPanel.add(fillString, constraints.weightedLastCol());
constraints.newRow();
final JCheckBox useProjectWidthBox = new JCheckBox("Use project right margin as fill width");
useProjectWidthBox.setSelected(useProjectWidthForFill);
cfsPanel.add(useProjectWidthBox, constraints.weightedLastCol());
constraints.lastRow();
constraints.insets = new Insets(4, 15, 4, 4);
final JLabel fillWidthLabel = new JLabel("Fill width:");
cfsPanel.add(fillWidthLabel, constraints.firstCol());
final IntTextField fillWidthField = new IntTextField(
new IntTextField.IGetSet() {
public int get() {
return fillWidth;
}
public void set(int value) {
fillWidth = value;
}
},
0,
999
);
cfsPanel.add(fillWidthField, constraints.nextCol());
cfsPanel.add(new JLabel(), constraints.weightedLastCol());
fillWidthLabel.setEnabled(!useProjectWidthForFill);
fillWidthField.setEnabled(!useProjectWidthForFill);
fillString.getDocument().addDocumentListener(new DocumentListener() {
public void insertUpdate(DocumentEvent e) {
setFillString(fillString.getText());
}
public void removeUpdate(DocumentEvent e) {
setFillString(fillString.getText());
}
public void changedUpdate(DocumentEvent e) {
setFillString(fillString.getText());
}
});
useProjectWidthBox.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
useProjectWidthForFill = useProjectWidthBox.isSelected();
fillWidthLabel.setEnabled(!useProjectWidthForFill);
fillWidthField.setEnabled(!useProjectWidthForFill);
}
});
return cfsPanel;
}
/** Returns a regular expression that will match the fill string. */
public String getFillStringPattern() {
String fs = fillString;
if (fs.length() == 0) fs = " ";
final int length = fs.length();
StringBuilder sb = new StringBuilder(length * (length + 1) / 2 + length * 3);
sb.append('(');
sb.append(RegexUtil.escape(fs));
sb.append(")*");
if (length > 1) {
sb.append('(');
for (int i = length - 1; i > 0; i--) {
sb.append(RegexUtil.escape(fs.substring(0, i)));
sb.append(i <= 1 ? ")?" : "|");
}
}
return sb.toString();
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/CommentRule.java
-616
View File
@@ -1,616 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings;
import com.wrq.rearranger.entry.PopupTreeRangeEntry;
import com.wrq.rearranger.entry.RangeEntry;
import com.wrq.rearranger.popup.FilePopupEntry;
import com.wrq.rearranger.popup.RearrangerTreeNode;
import com.wrq.rearranger.ruleinstance.CommentRuleInstanceFactory;
import com.wrq.rearranger.ruleinstance.RuleInstance;
import com.wrq.rearranger.settings.attributeGroups.AttributeGroup;
import com.wrq.rearranger.settings.attributeGroups.RegexUtil;
import com.wrq.rearranger.util.Constraints;
import org.jdom.Attribute;
import org.jdom.Element;
import org.jetbrains.annotations.NotNull;
import javax.swing.*;
import javax.swing.border.Border;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import javax.swing.tree.DefaultMutableTreeNode;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.List;
/** Handles insertion of comment separators between sections of the rearranged file. */
public final class CommentRule
implements AttributeGroup,
PopupTreeRangeEntry,
FilePopupEntry
{
// ------------------------------------------------------- FIELDS ------------------------------------------------------
public static final int EMIT_ALWAYS = 0;
public static final int EMIT_IF_ITEMS_MATCH_PRECEDING_RULE = 1;
public static final int EMIT_IF_ITEMS_MATCH_SUBSEQUENT_RULE = 2;
public static final int EMIT_IF_ITEMS_MATCH_SURROUNDING_RULES = 3;
private String commentText;
public final String getCommentText() {
return commentText;
}
public final void setCommentText(final String commentText) {
StringBuffer sb = new StringBuffer(commentText);
while (sb.length() > 0 &&
Character.isWhitespace(sb.charAt(sb.length() - 1)) &&
sb.charAt(sb.length() - 1) != '\n')
{
sb.setLength(sb.length() - 1);
}
this.commentText = sb.toString();
}
private int emitCondition;
public final int getEmitCondition() {
return emitCondition;
}
public final void setEmitCondition(final int emitCondition) {
this.emitCondition = emitCondition;
}
private int myNPrecedingRulesToMatch; // default 1
private int myNSubsequentRulesToMatch; // default 1
private boolean myAllPrecedingRules; // if false, ANY preceding rules
public final boolean isAllPrecedingRules() {
return myAllPrecedingRules;
}
public final void setAllPrecedingRules(final boolean allPrecedingRules) {
this.myAllPrecedingRules = allPrecedingRules;
}
private boolean myAllSubsequentRules; // if false, ANY subsequent rules
public final boolean isAllSubsequentRules() {
return myAllSubsequentRules;
}
public final void setAllSubsequentRules(final boolean allSubsequentRules) {
this.myAllSubsequentRules = allSubsequentRules;
}
private CommentFillString commentFillString;
public CommentFillString getCommentFillString() {
return commentFillString;
}
public void setCommentFillString(CommentFillString commentFillString) {
this.commentFillString = commentFillString;
}
// --------------------------------------------------- STATIC METHODS --------------------------------------------------
public static CommentRule readExternal(final Element item) {
final CommentRule result = new CommentRule();
final Attribute attr = RearrangerSettings.getAttribute(item, "commentText");
// backward compatibility. Comment text was formerly saved as an attribute.
// Newline characters were lost this way. Now comment text is saved as element text.
// If there's no text but there is an attribute, load the old format. It will be
// saved as element text next time IDEA is exited.
// Turns out that IDEA strips newlines in the element text. Maybe it's due to document
// formatting options. In any case, we have to escape newline characters.
String text = item.getText();
if (text == null || text.length() == 0) {
result.commentText = (attr == null ? "" : ((java.lang.String)attr.getValue()));
}
else {
result.commentText = unescape(text);
}
result.emitCondition = RearrangerSettings.getIntAttribute(item, "condition", 0);
result.myNPrecedingRulesToMatch = RearrangerSettings.getIntAttribute(item, "nPrecedingRulesToMatch", 1);
result.myNSubsequentRulesToMatch = RearrangerSettings.getIntAttribute(item, "nSubsequentRulesToMatch", 1);
result.myAllPrecedingRules = RearrangerSettings.getBooleanAttribute(item, "allPrecedingRules", true);
result.myAllSubsequentRules = RearrangerSettings.getBooleanAttribute(item, "allSubsequentRules", true);
result.commentFillString = CommentFillString.readExternal(item);
return result;
}
public static String unescape(String text) {
StringBuffer s = new StringBuffer(text);
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) == '\\' && (i + 1 < s.length())) {
switch (s.charAt(i + 1)) {
case 'n':
s.setCharAt(i, '\n');
s.deleteCharAt(i + 1);
break;
case '\\':
s.deleteCharAt(i + 1);
break;
case 't':
s.setCharAt(i, '\t');
s.deleteCharAt(i + 1);
break;
case ' ':
s.deleteCharAt(i);
break;
}
}
}
return s.toString();
}
public static String escape(String s) {
StringBuffer sb = new StringBuffer(s);
// for reasons given in readExternal(), escape certain characters in the comment text.
for (int i = 0; i < sb.length(); i++) {
switch (sb.charAt(i)) {
case '\\':
case ' ':
sb.insert(i, '\\');
i++;
break;
case '\n':
sb.replace(i, i + 1, "\\n");
i++;
break;
case '\t':
sb.replace(i, i + 1, "\\t");
i++;
break;
}
}
return sb.toString();
}
// ---------------------------------------------------- CONSTRUCTORS ---------------------------------------------------
public CommentRule() {
commentText = "";
emitCondition = EMIT_ALWAYS;
myNPrecedingRulesToMatch = 1;
myNSubsequentRulesToMatch = 1;
myAllPrecedingRules = true;
myAllSubsequentRules = true;
commentFillString = new CommentFillString();
}
// ---------------------------------------------- GETTER / SETTER METHODS ----------------------------------------------
public String[] getAdditionalIconNames() {
return null;
}
public int getCommentCount() {
return (commentText != null && commentText.length() > 0) ? 1 : 0;
}
public final JPanel getCommentPanel() {
final JPanel commentPanel = new JPanel(new GridBagLayout());
final Border border = BorderFactory.createEtchedBorder();
commentPanel.setBorder(border);
final Constraints constraints = new Constraints(GridBagConstraints.NORTHWEST);
constraints.fill = GridBagConstraints.BOTH;
constraints.insets = new Insets(4, 4, 4, 0);
final JLabel emitLabel = new JLabel("Emit comment:");
final JRadioButton alwaysButton = new JRadioButton("Always"),
whenButton = new JRadioButton("When");
final ButtonGroup group = new ButtonGroup();
group.add(alwaysButton);
group.add(whenButton);
if (emitCondition == 0) {
alwaysButton.setSelected(true);
}
else {
whenButton.setSelected(true);
}
commentPanel.add(emitLabel, constraints.weightedLastCol());
constraints.newRow();
constraints.insets = new Insets(0, 14, 0, 0);
commentPanel.add(alwaysButton, constraints.weightedLastCol());
constraints.newRow();
commentPanel.add(whenButton, constraints.weightedLastCol());
constraints.insets = new Insets(0, 24, 0, 4);
constraints.newRow();
final JPanel anyAllPreviousPanel = new AnyAllPanel(true);
commentPanel.add(anyAllPreviousPanel, constraints.weightedLastCol());
constraints.newRow();
constraints.insets = new Insets(0, 24, 10, 4);
final JPanel anyAllSubsequentPanel = new AnyAllPanel(false);
commentPanel.add(anyAllSubsequentPanel, constraints.weightedLastCol());
anyAllPreviousPanel.setEnabled(emitCondition > 0);
anyAllSubsequentPanel.setEnabled(emitCondition > 0);
final JLabel commentLabel = new JLabel("Comment separator text:");
constraints.insets = new Insets(4, 4, 4, 4);
constraints.newRow();
commentPanel.add(commentLabel, constraints.weightedLastCol());
final JTextArea commentArea = new JTextArea(4, 40);
commentArea.setText(getCommentText());
constraints.weightedNewRow();
final JScrollPane scrollPane = new JScrollPane(commentArea);
scrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
scrollPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
commentPanel.add(scrollPane, constraints.weightedLastCol());
constraints.newRow();
final JPanel cfsPanel = commentFillString.getCommentFillStringPanel();
final JLabel fillStringLabel = new JLabel("Fill string:");
fillStringLabel.setToolTipText("Occurrences of %FS% in the comment separator text will be replaced with equal \n" +
"amounts of the fill string, replicated to make the comment end at the specified column");
commentPanel.add(cfsPanel, constraints.weightedLastCol());
alwaysButton.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
if (alwaysButton.isSelected()) {
emitCondition = EMIT_ALWAYS;
anyAllPreviousPanel.setEnabled(false);
anyAllSubsequentPanel.setEnabled(false);
}
}
});
whenButton.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
if (whenButton.isSelected()) {
anyAllPreviousPanel.setEnabled(true);
anyAllSubsequentPanel.setEnabled(true);
}
}
});
commentArea.getDocument().addDocumentListener(new DocumentListener() {
public void changedUpdate(final DocumentEvent e) {
setCommentText(commentArea.getText());
}
public void insertUpdate(final DocumentEvent e) {
setCommentText(commentArea.getText());
}
public void removeUpdate(final DocumentEvent e) {
setCommentText(commentArea.getText());
}
});
return commentPanel;
}
public String getDescriptiveString() {
final StringBuffer sb = new StringBuffer(commentText.trim());
if (sb.length() > 60) {
// attempt to shorten by removing duplicate (well, quadruplicate) characters.
for (int i = 0; i < sb.length() - 4; i++) {
if (sb.charAt(i) == sb.charAt(i + 1) &&
sb.charAt(i + 1) == sb.charAt(i + 2) &&
sb.charAt(i + 2) == sb.charAt(i + 3))
{
// we have at least 4 characters in a row. Shorten the entire sequence to
// a length of 4 characters and append the length.
int j = 0;
while (i + 4 < sb.length() && sb.charAt(i) == sb.charAt(i + 4)) {
j++;
sb.deleteCharAt(i + 4);
}
if (j > 3) {
sb.insert(i + 4, "<" + j + ">");
}
else {
// compression is quite small, so just output the actual characters.
while (j-- > 0) {
sb.insert(i + 4, sb.charAt(i));
}
}
}
}
}
if (sb.length() > 60) {
sb.delete(60, sb.length());
sb.append("...");
}
String condition = "";
switch (emitCondition) {
case EMIT_ALWAYS:
break;
case EMIT_IF_ITEMS_MATCH_PRECEDING_RULE:
condition = " when " + precedingRuleString();
break;
case EMIT_IF_ITEMS_MATCH_SUBSEQUENT_RULE:
condition = " when " + subsequentRuleString();
break;
case EMIT_IF_ITEMS_MATCH_SURROUNDING_RULES:
condition = " when " + precedingRuleString() + ", and " + subsequentRuleString();
}
return ("Comment (" + sb.toString() + ")" + condition);
}
private String precedingRuleString() {
return (myNPrecedingRulesToMatch == 1) ? "preceding rule is matched" :
(myAllPrecedingRules ? "all" : "any") +
" of preceding " + (myNPrecedingRulesToMatch) + " rules are matched";
}
private String subsequentRuleString() {
return (myNSubsequentRulesToMatch == 1) ? "subsequent rule is matched" :
(myAllSubsequentRules ? "all" : "any") +
" of subsequent " + (myNSubsequentRulesToMatch) + " rules are matched";
}
public final String getExpandedCommentText() {
return commentFillString.getExpandedCommentText(commentText);
}
private String getName() {
return commentText.trim();
}
public int getPriority() {
return -1; // Comments never match anything, so any priority will do.
}
public void setPriority(int priority) {
// does nothing
}
public String getTypeIconName() {
return "nodes/J2eeParameter";
}
public final boolean isAlphabetize() {
throw new UnsupportedOperationException("CommentRule.isAlphabetize() not implemented");
}
public final void setNPrecedingRulesToMatch(final int nPrecedingRulesToMatch) {
this.myNPrecedingRulesToMatch = nPrecedingRulesToMatch;
}
public final void setNSubsequentRulesToMatch(final int nSubsequentRulesToMatch) {
this.myNSubsequentRulesToMatch = nSubsequentRulesToMatch;
}
// ------------------------------------------------- CANONICAL METHODS -------------------------------------------------
public final boolean equals(final Object object) {
if (!(object instanceof CommentRule)) return false;
final CommentRule c = (CommentRule)object;
return commentText.equals(c.commentText) &&
emitCondition == c.emitCondition &&
myNPrecedingRulesToMatch == c.myNPrecedingRulesToMatch &&
myNSubsequentRulesToMatch == c.myNSubsequentRulesToMatch &&
myAllPrecedingRules == c.myAllPrecedingRules &&
myAllSubsequentRules == c.myAllSubsequentRules &&
commentFillString.equals(c.commentFillString);
}
public final String toString() {
return getDescriptiveString();
}
// ================================================= INTERFACE METHODS =================================================
// ---------------------------------------------- Interface AttributeGroup ---------------------------------------------
@NotNull
public final /*CommentRule*/AttributeGroup deepCopy() {
final CommentRule comment = new CommentRule();
comment.commentText = commentText;
comment.emitCondition = emitCondition;
comment.myNPrecedingRulesToMatch = myNPrecedingRulesToMatch;
comment.myNSubsequentRulesToMatch = myNSubsequentRulesToMatch;
comment.myAllPrecedingRules = myAllPrecedingRules;
comment.myAllSubsequentRules = myAllSubsequentRules;
comment.commentFillString = commentFillString.deepCopy();
return comment;
}
public final void writeExternal(@NotNull final Element parent) {
final Element me = new Element("Comment");
me.setText(escape(commentText));
me.setAttribute("condition", "" + emitCondition);
me.setAttribute("nPrecedingRulesToMatch", "" + myNPrecedingRulesToMatch);
me.setAttribute("nSubsequentRulesToMatch", "" + myNSubsequentRulesToMatch);
me.setAttribute("allPrecedingRules", "" + myAllPrecedingRules);
me.setAttribute("allSubsequentRules", "" + myAllSubsequentRules);
commentFillString.writeExternal(me);
parent.getChildren().add(me);
}
// --------------------------------------------- Interface IFilePopupEntry ---------------------------------------------
public JLabel getPopupEntryText(RearrangerSettings settings) {
String s = commentText.trim();
if (commentFillString != null && commentFillString.getFillString().length() > 0) {
s = commentFillString.getExpandedCommentText(s);
}
return new JLabel(s);
}
// ------------------------------------------- Interface IPopupTreeRangeEntry ------------------------------------------
public DefaultMutableTreeNode addToPopupTree(DefaultMutableTreeNode parent, RearrangerSettings settings) {
DefaultMutableTreeNode myNode = new RearrangerTreeNode(this, getName());
parent.add(myNode);
return myNode;
}
// -------------------------------------------------- Interface IRule --------------------------------------------------
@NotNull
public RuleInstance createRuleInstance() {
return CommentRuleInstanceFactory.buildCommentRuleInstance(this);
}
public boolean isMatch(@NotNull RangeEntry rangeEntry) {
return false; // comment rules match no entries -- they're just placeholders to generate comments.
}
public boolean commentsMatchGlobalPattern(String pattern) {
return commentText.matches(pattern);
}
public List<String> getOffendingPatterns(String pattern) {
List<String> result = new ArrayList<String>(1);
result.add(commentText);
return result;
}
public void addCommentPatternsToList(List<String> list) {
if (commentText != null && commentText.length() > 0) {
String esc = RegexUtil.escape(commentText);
String fsp = commentFillString.getFillStringPattern();
esc = esc.replaceAll("%FS%", fsp);
list.add(esc);
}
}
// --------------------------------------------------- OTHER METHODS ---------------------------------------------------
public int getNPrecedingRulesToMatch() {
return myNPrecedingRulesToMatch;
}
public final int getNSubsequentRulesToMatch() {
return myNSubsequentRulesToMatch;
}
// --------------------------------------------------- INNER CLASSES ---------------------------------------------------
final class AnyAllPanel extends JPanel {
final JCheckBox anyAllCheckbox;
final JComboBox anyAllComboBox;
final JLabel anyAllLabel;
final JFormattedTextField anyAllPrevNumber;
final JLabel rulesLabel;
/**
* Return a JPanel that allows user to specify checkbox (enable rule), Any/All combo box, "of the "
* "preceding"/"subsequent", text field for integer >= 1, "rules"
*
* @param preceding true if handling "preceding" rules, otherwise "subsequent" rules
*/
AnyAllPanel(final boolean preceding) {
super(new GridBagLayout());
final Constraints constraints = new Constraints(GridBagConstraints.NORTHWEST);
constraints.lastRow();
constraints.fill = GridBagConstraints.BOTH;
anyAllCheckbox = new JCheckBox("items match");
anyAllCheckbox.setSelected((emitCondition & (preceding ? 1 : 2)) > 0);
anyAllComboBox = new JComboBox(new String[]{"any", "all"});
anyAllComboBox.setSelectedIndex(preceding ? (myAllPrecedingRules ? 1 : 0)
: (myAllSubsequentRules ? 1 : 0));
Dimension d = anyAllComboBox.getPreferredSize();
d.width += 3; // make room for "any", if "all" is narrower and is first selection.
anyAllComboBox.setPreferredSize(d);
anyAllLabel = new JLabel();
anyAllLabel.setText("of the subsequent"); // calculate max size
d = anyAllLabel.getPreferredSize();
anyAllLabel.setText(preceding ? "of the preceding" : "of the subsequent");
anyAllLabel.setMinimumSize(d);
anyAllLabel.setPreferredSize(d);
final NumberFormat integerInstance = NumberFormat.getIntegerInstance();
integerInstance.setMaximumIntegerDigits(2);
integerInstance.setMinimumIntegerDigits(1);
anyAllPrevNumber = new JFormattedTextField(integerInstance);
anyAllPrevNumber.setValue(new Integer("88"));
d = anyAllPrevNumber.getPreferredSize();
d.width += 3;
anyAllPrevNumber.setPreferredSize(d);
anyAllPrevNumber.setValue(preceding ? myNPrecedingRulesToMatch : myNSubsequentRulesToMatch);
anyAllPrevNumber.setFocusLostBehavior(JFormattedTextField.COMMIT_OR_REVERT);
rulesLabel = new JLabel("rules");
constraints.insets = new Insets(0, 10, 0, 0);
add(anyAllCheckbox, constraints.nextCol());
constraints.insets = new Insets(0, 0, 0, 0);
add(anyAllComboBox, constraints.nextCol());
constraints.insets = new Insets(0, 4, 0, 0);
add(anyAllLabel, constraints.nextCol());
constraints.insets = new Insets(0, 4, 0, 0);
add(anyAllPrevNumber, constraints.nextCol());
add(rulesLabel, constraints.weightedLastCol());
anyAllComboBox.setEnabled(anyAllCheckbox.isSelected());
anyAllLabel.setEnabled(anyAllCheckbox.isSelected());
anyAllPrevNumber.setEnabled(anyAllCheckbox.isSelected());
rulesLabel.setEnabled(anyAllCheckbox.isSelected());
anyAllCheckbox.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
if (anyAllCheckbox.isSelected()) {
emitCondition |= (preceding ? 1 : 2);
}
else {
emitCondition &= (preceding ? ~1 : ~2);
}
anyAllComboBox.setEnabled(anyAllCheckbox.isSelected());
anyAllLabel.setEnabled(anyAllCheckbox.isSelected());
anyAllPrevNumber.setEnabled(anyAllCheckbox.isSelected());
rulesLabel.setEnabled(anyAllCheckbox.isSelected());
}
});
anyAllComboBox.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
final int s = anyAllComboBox.getSelectedIndex();
if (preceding) {
myAllPrecedingRules = (s == 1);
}
else {
myAllSubsequentRules = (s == 1);
}
}
});
anyAllPrevNumber.addPropertyChangeListener("value", new PropertyChangeListener() {
public void propertyChange(final PropertyChangeEvent evt) {
int n = ((Number)anyAllPrevNumber.getValue()).intValue();
if (n <= 0) {
n = 1;
anyAllPrevNumber.setValue(n);
}
if (preceding) {
myNPrecedingRulesToMatch = n;
}
else {
myNSubsequentRulesToMatch = n;
}
}
});
}
public final void setEnabled(final boolean enable) {
anyAllCheckbox.setEnabled(enable);
anyAllComboBox.setEnabled(anyAllCheckbox.isSelected() && enable);
anyAllLabel.setEnabled(anyAllCheckbox.isSelected() && enable);
anyAllPrevNumber.setEnabled(anyAllCheckbox.isSelected() && enable);
rulesLabel.setEnabled(anyAllCheckbox.isSelected() && enable);
}
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/ForceBlankLineSetting.java
-131
View File
@@ -1,131 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings;
import org.jdom.Element;
/** Contains a single "force N blank lines before/after" some brace. */
public class ForceBlankLineSetting {
public static final int CLASS_OBJECT = 0;
public static final int METHOD_OBJECT = 1;
public static final int EOF_OBJECT = 2;
boolean force;
int nBlankLines;
final boolean before; // false => after
final boolean openBrace; // false => close brace
final int object;
final String name;
public ForceBlankLineSetting(boolean before, boolean openBrace, int object, String name) {
this.before = before;
this.openBrace = openBrace;
this.object = object;
this.name = name;
}
public boolean isForce() {
return force;
}
public void setForce(boolean force) {
this.force = force;
}
public int getnBlankLines() {
return nBlankLines;
}
public void setnBlankLines(int nBlankLines) {
this.nBlankLines = nBlankLines;
}
public boolean isBefore() {
return before;
}
public boolean isOpenBrace() {
return openBrace;
}
public int getObject() {
return object;
}
public boolean equals(final Object obj) {
if (!(obj instanceof ForceBlankLineSetting)) return false;
final ForceBlankLineSetting fbls = (ForceBlankLineSetting)obj;
if (fbls.force != force) return false;
if (fbls.nBlankLines != nBlankLines) return false;
if (fbls.before != before) return false;
if (fbls.openBrace != openBrace) return false;
if (fbls.object != object) return false;
return true;
}
public final ForceBlankLineSetting deepCopy() {
final ForceBlankLineSetting result = new ForceBlankLineSetting(before, openBrace, object, name);
result.force = force;
result.nBlankLines = nBlankLines;
return result;
}
/**
* Read the contents of this object from the JDOM element.
*
* @param entry JDOM element which contains setting values as attributes.
*/
public static ForceBlankLineSetting readExternal(final Element entry,
boolean before,
boolean openBrace,
int object,
String name)
{
ForceBlankLineSetting fbls;
Element fblsElement = entry.getChild(name);
boolean force = RearrangerSettings.getBooleanAttribute(fblsElement, "Force", false);
int nBlankLines = RearrangerSettings.getIntAttribute(fblsElement, "nBlankLines", 1);
fbls = new ForceBlankLineSetting(before, openBrace, object, name);
fbls.setForce(force);
fbls.setnBlankLines(nBlankLines);
return fbls;
}
public final void writeExternal(final Element entry) {
final Element fblsElement = new Element(name);
entry.getChildren().add(fblsElement);
fblsElement.setAttribute("Force", Boolean.valueOf(force).toString());
fblsElement.setAttribute("nBlankLines", "" + nBlankLines);
}
public String toString() {
return name + ": " + (before ? "before " : "after ") +
getObjectName() +
(openBrace ? " open brace" : " close brace") +
(force ? ", force " + nBlankLines + " lines" : ", leave intact");
}
public String getObjectName() {
return (object == CLASS_OBJECT ? "class" : "method");
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/PrimaryMethodSetting.java
-386
View File
@@ -1,386 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings;
import com.wrq.rearranger.configuration.*;
import javax.swing.*;
import java.awt.*;
import java.util.ArrayList;
import java.util.List;
/**
* Contains settings pertinent to a single related-by-name method setting. A primary field is
* specified
*/
public class PrimaryMethodSetting
implements IListManagerObject
{
/** Description for a single related-by-name method setting. */
String description;
/**
* Regular expression which method name must match. If the method is to be matched to a field, there must be
* at least one capture group (parenthesized subexpression) which will be treated as the field.
* In the case of a traditional getter method, this pattern is "get(\w+)".
*/
String methodNamePattern;
/**
* The number of the capture group in methodNamePattern which corresponds to the field name. If the
* methodNamePattern is "get(\w+)", then the fieldCaptureGroupNumber is 1.
*/
int fieldCaptureGroupNumber;
/** number of parameters the primary method must have. In the case of a traditional getter method, this is zero. */
int numParameters;
/**
* regular expression pattern of the type which primary method must return.
* In the case of a traditional getter method, this is the field type. One substitution is available:
* <pre>
* %FT% field type
* </pre>
*/
String methodTypePattern;
/**
* regular expression pattern of the attributes of the method.
* In the case of a traditional getter method, this is ".*public.*" (i.e., any public method).
*/
String methodAttributePattern;
/**
* pattern of method body (excluding comments and newline characters). Substitutions are available as follows:
* <pre>
* %FN% field name
* %FT% field type (if field is valid field, else empty string)
* %MT% method return type
* %P1% parameter 1 name (%P2%, %P3% etc for additional parameters)
* %T1% parameter 1 type name
* </pre>
*/
String body;
/** list of secondary method configurations, e.g. for "set" and "is". */
ArrayList<SecondaryMethodSetting> secondaryMethodList = new ArrayList<SecondaryMethodSetting>();
public PrimaryMethodSetting() {
methodNamePattern = "get(\\w+)";
fieldCaptureGroupNumber = 1;
numParameters = 0;
methodTypePattern = "%FT%";
methodAttributePattern = ".*public.*";
body = "{\\s*return\\s*%fn%;\\s*}";
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getMethodNamePattern() {
return methodNamePattern;
}
public void setMethodNamePattern(String methodNamePattern) {
this.methodNamePattern = methodNamePattern;
}
public int getFieldCaptureGroupNumber() {
return fieldCaptureGroupNumber;
}
public void setFieldCaptureGroupNumber(int fieldCaptureGroupNumber) {
this.fieldCaptureGroupNumber = fieldCaptureGroupNumber;
}
public int getNumParameters() {
return numParameters;
}
public void setNumParameters(int numParameters) {
this.numParameters = numParameters;
}
public String getMethodTypePattern() {
return methodTypePattern;
}
public void setMethodTypePattern(String methodTypePattern) {
this.methodTypePattern = methodTypePattern;
}
public String getMethodAttributePattern() {
return methodAttributePattern;
}
public void setMethodAttributePattern(String methodAttributePattern) {
this.methodAttributePattern = methodAttributePattern;
}
public String getBody() {
return body;
}
public void setBody(String body) {
this.body = body;
}
public ArrayList<SecondaryMethodSetting> getSecondaryMethodList() {
return secondaryMethodList;
}
public String toString() {
return description;
}
public boolean equals(Object obj) {
if (!(obj instanceof PrimaryMethodSetting)) return false;
PrimaryMethodSetting pms = (PrimaryMethodSetting)obj;
if (!pms.description.equals(description)) return false;
if (!pms.methodNamePattern.equals(methodNamePattern)) return false;
if (pms.fieldCaptureGroupNumber != fieldCaptureGroupNumber) return false;
if (pms.numParameters != numParameters) return false;
if (!pms.methodTypePattern.equals(methodTypePattern)) return false;
if (!pms.methodAttributePattern.equals(methodAttributePattern)) return false;
if (!pms.body.equals(body)) return false;
return true;
}
public JPanel getPanel() {
IListManagerObjectFactory lmof = new IListManagerObjectFactory() {
public IListManagerObject create(String name) {
SecondaryMethodSetting sms = new SecondaryMethodSetting();
sms.setDescription(name);
return sms;
}
public List/*<? extends IListManagerObject>*/ getObjectList() {
return secondaryMethodList;
}
};
ListManager Lmgr = new ListManager(lmof, "Description:");
JPanel pmsPanel = new JPanel(new GridBagLayout());
GridBagConstraints constraints = new GridBagConstraints();
constraints.anchor = GridBagConstraints.NORTHWEST;
constraints.fill = GridBagConstraints.NONE;
constraints.gridwidth = 1;
constraints.gridheight = 1;
constraints.weightx = 0.0d;
constraints.weighty = 0.0d;
constraints.gridy = constraints.gridx = 0;
constraints.insets = new Insets(3, 3, 3, 3);
pmsPanel.setBorder(BorderFactory.createTitledBorder(
BorderFactory.createEtchedBorder(),
"Primary (\"Getter\") Method Criteria"));
constraints.gridwidth = 1;
constraints.gridy++;
JLabel methodNamePatternLabel = new JLabel("Method name:");
methodNamePatternLabel.setToolTipText(
"Regular expression which method name must match. " +
"If the method is to be matched to a field, there must be\n" +
" at least one capture group (parenthesized subexpression) which will be treated as the field.\n" +
" In the case of a traditional getter method, this pattern is \"get(\\w+)\".");
pmsPanel.add(methodNamePatternLabel, constraints);
constraints.gridx++;
constraints.fill = GridBagConstraints.HORIZONTAL;
constraints.weightx = .5;
StringTextField primaryPrefixText = new StringTextField() {
public void setValue(String value) {
setMethodNamePattern(value);
}
public String getValue() {
return getMethodNamePattern();
}
};
pmsPanel.add(primaryPrefixText, constraints);
constraints.fill = GridBagConstraints.NONE;
constraints.weightx = 0;
constraints.gridx++;
JLabel fieldCaptureGroupLabel = new JLabel("Field capture group:");
fieldCaptureGroupLabel.setToolTipText(
"The number of the capture group in methodNamePattern which corresponds to the field name. If the\n" +
" methodNamePattern is \"get(\\w+)\", then the fieldCaptureGroupNumber is 1."
);
pmsPanel.add(fieldCaptureGroupLabel, constraints);
IntTextField itf = new IntTextField(
new IntTextField.IGetSet() {
public void set(int value) {
fieldCaptureGroupNumber = value;
}
public int get() {
return fieldCaptureGroupNumber;
}
},
null, null
);
constraints.gridx++;
pmsPanel.add(itf, constraints);
constraints.gridx++;
JLabel nParamLabel = new JLabel("Number of parameters:");
nParamLabel.setToolTipText(
"number of parameters the primary method must have.\n" +
"In the case of a traditional getter method, this is zero.");
pmsPanel.add(nParamLabel, constraints);
constraints.gridx++;
IntTextField nParamText = new IntTextField(
new IntTextField.IGetSet() {
public void set(int value) {
numParameters = value;
}
public int get() {
return numParameters;
}
}, null, null);
constraints.fill = GridBagConstraints.HORIZONTAL;
constraints.gridwidth = GridBagConstraints.REMAINDER;
pmsPanel.add(nParamText, constraints);
constraints.gridx = 0;
constraints.gridy++;
constraints.gridwidth = 1;
constraints.weightx = 0;
constraints.fill = GridBagConstraints.NONE;
JLabel returnTypeLabel = new JLabel("Return type:");
returnTypeLabel.setToolTipText(
"regular expression pattern of the type which primary method must return.\n" +
" In the case of a traditional getter method, this is the field type. One substitution is available:\n" +
" * %FT% field type");
pmsPanel.add(returnTypeLabel, constraints);
constraints.gridx++;
constraints.weightx = .5;
constraints.fill = GridBagConstraints.HORIZONTAL;
StringTextField returnTypeField = new StringTextField() {
public void setValue(String value) {
methodTypePattern = value;
}
public String getValue() {
return methodTypePattern;
}
};
pmsPanel.add(returnTypeField, constraints);
constraints.fill = GridBagConstraints.NONE;
constraints.gridx++;
constraints.weightx = 0;
JLabel methodAttributeLabel = new JLabel("Method attributes:");
methodAttributeLabel.setToolTipText("Protection level or other attributes for the method.\n" +
"In the case of a getter method, this is usually \".*public.*\".");
pmsPanel.add(methodAttributeLabel, constraints);
StringTextField methodAttributeField = new StringTextField() {
public void setValue(String value) {
methodAttributePattern = value;
}
public String getValue() {
return methodAttributePattern;
}
};
constraints.gridx++;
constraints.gridwidth = GridBagConstraints.REMAINDER;
constraints.weightx = .5;
constraints.fill = GridBagConstraints.HORIZONTAL;
pmsPanel.add(methodAttributeField, constraints);
constraints.gridx++;
constraints.weightx = 0;
constraints.fill = GridBagConstraints.NONE;
constraints.gridy++;
constraints.gridx = 0;
JLabel bodyLabel = new JLabel("Body:");
bodyLabel.setToolTipText("regular expression pattern of method body (excluding comments and newline characters).\n" +
"Substitutions are available as follows:\n" +
" %FN% field name\n" +
" %FT% field type (if field is valid field, else empty string)\n" +
" %MT% method return type\n" +
" %P1% parameter 1 name (%P2%, %P3% etc for additional parameters)\n" +
" %T1% parameter 1 type name");
constraints.gridwidth = 1;
constraints.weightx = 0;
constraints.fill = GridBagConstraints.NONE;
pmsPanel.add(bodyLabel, constraints);
constraints.gridx++;
StringTextArea bodyField = new StringTextArea() {
public void setValue(String value) {
body = value;
}
public String getValue() {
return body;
}
};
constraints.gridwidth = GridBagConstraints.REMAINDER;
constraints.weightx = 1;
constraints.weighty = .35;
constraints.fill = GridBagConstraints.BOTH;
JScrollPane sp = new JScrollPane(bodyField);
pmsPanel.add(sp, constraints);
constraints.gridx = 0;
constraints.gridy++;
constraints.gridheight = GridBagConstraints.REMAINDER;
constraints.fill = GridBagConstraints.NONE;
constraints.fill = GridBagConstraints.BOTH;
constraints.weightx = 1;
constraints.weighty = .65;
final JPanel pane = Lmgr.getPane();
pane.setBorder(BorderFactory.createTitledBorder(
BorderFactory.createEtchedBorder(), "Related Methods"));
pmsPanel.add(pane, constraints);
return pmsPanel;
}
public IListManagerObject deepcopy() {
PrimaryMethodSetting pms = new PrimaryMethodSetting();
pms.description = getDescription();
pms.methodNamePattern = getMethodNamePattern();
pms.fieldCaptureGroupNumber = getFieldCaptureGroupNumber();
pms.numParameters = getNumParameters();
pms.methodTypePattern = getMethodTypePattern();
pms.methodAttributePattern = getMethodAttributePattern();
pms.body = getBody();
pms.secondaryMethodList = new ArrayList<SecondaryMethodSetting>();
for (SecondaryMethodSetting sms : secondaryMethodList) {
pms.secondaryMethodList.add((SecondaryMethodSetting)sms.deepcopy());
}
return pms;
}
public static void main(String[] args) {
PrimaryMethodSetting ms = new PrimaryMethodSetting();
final JDialog frame = new JDialog((Frame)null, "SwingApplication");
final GridBagConstraints constraints = new GridBagConstraints();
constraints.anchor = GridBagConstraints.NORTHWEST;
constraints.fill = GridBagConstraints.BOTH;
constraints.weightx = 1.0d;
constraints.weighty = 1.0d;
constraints.gridwidth = GridBagConstraints.REMAINDER;
constraints.gridx = 0;
constraints.gridy = 0;
frame.getContentPane().setLayout(new GridBagLayout());
frame.getContentPane().add(ms.getPanel(), constraints);
//Finish setting up the frame, and show it.
frame.pack();
frame.setResizable(true);
frame.setModal(true);
frame.setVisible(true);
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/RearrangerSettings.java
-725
View File
@@ -1,725 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings;
import com.intellij.openapi.diagnostic.Logger;
import com.wrq.rearranger.Rearranger;
import com.wrq.rearranger.settings.attributeGroups.AttributeGroup;
import com.wrq.rearranger.settings.attributeGroups.ClassAttributes;
import com.wrq.rearranger.settings.attributeGroups.GetterSetterDefinition;
import com.wrq.rearranger.settings.attributeGroups.ItemAttributes;
import com.wrq.rearranger.util.RearrangerConstants;
import org.jdom.Attribute;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.io.*;
import java.net.URL;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
/**
* Holds two lists of rearrangement settings, one for the outer level classes, the other for class members. Each
* list contains objects of type CommonAttributes.
*/
public final class RearrangerSettings {
// ------------------------------ FIELDS ------------------------------
// BEGINNING OF FIELDS
private static final Logger LOG = Logger.getInstance("#" + RearrangerSettings.class.getName());
public static final int OVERLOADED_ORDER_RETAIN_ORIGINAL = 0;
public static final int OVERLOADED_ORDER_ASCENDING_PARAMETERS = 1;
public static final int OVERLOADED_ORDER_DESCENDING_PARAMETERS = 2;
private final List<AttributeGroup> myItemOrderAttributeList;
private final List<AttributeGroup> myClassOrderAttributeList;
private RelatedMethodsSettings myRelatedMethodsSettings;
private boolean myKeepGettersSettersTogether;
private boolean myKeepGettersSettersWithProperty;
private boolean myKeepOverloadedMethodsTogether;
private String myGlobalCommentPattern;
private boolean myAskBeforeRearranging;
private boolean myRearrangeInnerClasses;
private boolean myShowParameterTypes;
private boolean myShowParameterNames;
private boolean myShowFields;
private boolean myShowTypeAfterMethod;
private boolean myShowRules;
private boolean myShowMatchedRules;
private boolean myShowComments;
private ForceBlankLineSetting myAfterClassLBrace;
private ForceBlankLineSetting myAfterClassRBrace;
private ForceBlankLineSetting myBeforeClassRBrace;
private ForceBlankLineSetting beforeMethodLBrace;
private ForceBlankLineSetting myAfterMethodLBrace;
private ForceBlankLineSetting myAfterMethodRBrace;
private ForceBlankLineSetting myBeforeMethodRBrace;
private boolean myRemoveBlanksInsideCodeBlocks;
private ForceBlankLineSetting myNewLinesAtEOF;
private int myOverloadedOrder;
private GetterSetterDefinition myDefaultGSDefinition;
private List<PrimaryMethodSetting> myPrimaryMethodList;
// -------------------------- STATIC METHODS --------------------------
static public int getIntAttribute(final Element me, final String attr) {
return getIntAttribute(me, attr, 0);
}
static public boolean getBooleanAttribute(final Element me, final String attr) {
return getBooleanAttribute(me, attr, false);
}
@Nullable
public static RearrangerSettings getDefaultSettings() throws IllegalStateException {
LOG.debug("enter loadDefaultSettings");
URL settingsURL = Rearranger.class.getClassLoader().getResource(RearrangerConstants.DEFAULT_CONFIG_PATH);
if (settingsURL == null) {
throw new IllegalStateException(String.format(
"Can't find default configuration (tried path '%s'",
RearrangerConstants.DEFAULT_CONFIG_PATH
));
}
LOG.debug("settings URL=" + settingsURL.getFile());
try {
InputStream is = settingsURL.openStream();
return getSettingsFromStream(is);
}
catch (IOException e) {
LOG.debug("getDefaultSettings:" + e);
return null;
}
}
@Nullable
public static RearrangerSettings getSettingsFromStream(InputStream is) {
Document document = null;
try {
SAXBuilder builder = new SAXBuilder();
document = builder.build(is);
}
catch (JDOMException jde) {
LOG.debug("JDOM exception building document:" + jde);
return null;
}
catch (IOException e) {
LOG.debug("I/O exception building document:" + e);
return null;
}
finally {
if (is != null) {
try {
is.close();
}
catch (IOException e) {
// Do nothing
}
}
}
Element app = document.getRootElement();
Element component = null;
if (app.getName().equals("application")) {
for (Object o : app.getChildren()) {
Element child = (Element)o;
if (child.getName().equals("component") &&
child.getAttribute("name") != null &&
child.getAttribute("name").getValue().equals(Rearranger.COMPONENT_NAME)) {
component = child;
break;
}
}
}
else {
if (app.getName().equals("component") &&
app.getAttribute("name") != null &&
app.getAttribute("name").getValue().equals(Rearranger.COMPONENT_NAME))
{
component = app;
}
}
if (component != null) {
Element rearranger = component.getChild(Rearranger.COMPONENT_NAME);
if (rearranger != null) {
RearrangerSettings rs = new RearrangerSettings();
rs.readExternal(rearranger);
return rs;
}
}
return null;
}
// Level 1 methods
/** @param entry JDOM element named "Rearranger" which contains setting values as attributes. */
public final void readExternal(final Element entry) {
final Element items = entry.getChild("Items");
final Element classes = entry.getChild("Classes");
final List itemList = items.getChildren();
final List classList = classes.getChildren();
ListIterator li;
li = itemList.listIterator();
while (li.hasNext())
// for (Element element : itemList)
{
Element element = (Element)li.next();
myItemOrderAttributeList.add(ItemAttributes.readExternal(element));
}
li = classList.listIterator();
// for (Element element : classList)
while (li.hasNext()) {
Element element = (Element)li.next();
myClassOrderAttributeList.add(ClassAttributes.readExternal(element));
}
final Element gsd = entry.getChild("DefaultGetterSetterDefinition");
myDefaultGSDefinition = GetterSetterDefinition.readExternal(gsd);
final Element relatedItems = entry.getChild("RelatedMethods");
myRelatedMethodsSettings = RelatedMethodsSettings.readExternal(relatedItems);
myKeepGettersSettersTogether = getBooleanAttribute(entry, "KeepGettersSettersTogether", true);
myKeepGettersSettersWithProperty = getBooleanAttribute(entry, "KeepGettersSettersWithProperty", false);
myKeepOverloadedMethodsTogether = getBooleanAttribute(entry, "KeepOverloadedMethodsTogether", true);
final Attribute attr = getAttribute(entry, "globalCommentPattern");
myAskBeforeRearranging = getBooleanAttribute(entry, "ConfirmBeforeRearranging", false);
myRearrangeInnerClasses = getBooleanAttribute(entry, "RearrangeInnerClasses", false);
myGlobalCommentPattern = (attr == null ? "" : attr.getValue());
myOverloadedOrder = getIntAttribute(entry, "overloadedOrder", OVERLOADED_ORDER_RETAIN_ORIGINAL);
myShowParameterTypes = getBooleanAttribute(entry, "ShowParameterTypes", true);
myShowParameterNames = getBooleanAttribute(entry, "ShowParameterNames", true);
myShowFields = getBooleanAttribute(entry, "ShowFields", true);
myShowRules = getBooleanAttribute(entry, "ShowRules", false);
myShowMatchedRules = getBooleanAttribute(entry, "ShowMatchedRules", false);
myShowComments = getBooleanAttribute(entry, "ShowComments", false);
myShowTypeAfterMethod = getBooleanAttribute(entry, "ShowTypeAfterMethod", true);
myRemoveBlanksInsideCodeBlocks = getBooleanAttribute(entry, "RemoveBlanksInsideCodeBlocks", false);
myAfterClassLBrace = ForceBlankLineSetting.readExternal(entry, false, true, ForceBlankLineSetting.CLASS_OBJECT, "AfterClassLBrace");
myAfterClassRBrace = ForceBlankLineSetting.readExternal(entry, false, false, ForceBlankLineSetting.CLASS_OBJECT, "AfterClassRBrace");
myBeforeClassRBrace = ForceBlankLineSetting.readExternal(entry, true, false, ForceBlankLineSetting.CLASS_OBJECT, "BeforeClassRBrace");
beforeMethodLBrace = ForceBlankLineSetting.readExternal(entry, true, true, ForceBlankLineSetting.METHOD_OBJECT, "BeforeMethodLBrace");
myAfterMethodLBrace = ForceBlankLineSetting.readExternal(entry, false, true, ForceBlankLineSetting.METHOD_OBJECT, "AfterMethodLBrace");
myAfterMethodRBrace = ForceBlankLineSetting.readExternal(entry, false, false, ForceBlankLineSetting.METHOD_OBJECT, "AfterMethodRBrace");
myBeforeMethodRBrace = ForceBlankLineSetting.readExternal(entry, true, false, ForceBlankLineSetting.METHOD_OBJECT, "BeforeMethodRBrace");
myNewLinesAtEOF = ForceBlankLineSetting.readExternal(entry, false, false, ForceBlankLineSetting.EOF_OBJECT, "NewlinesAtEOF");
}
// Level 2 methods
@Nullable
static public Attribute getAttribute(Element element, String attributeName) {
if (element == null) return null;
return element.getAttribute(attributeName);
}
static public int getIntAttribute(final Element item, final String attributeName, int defaultValue) {
if (item == null) return defaultValue;
final Attribute a = item.getAttribute(attributeName);
if (a == null) return defaultValue;
final String r = a.getValue();
if (r == null) return defaultValue;
if (r.length() == 0) return defaultValue;
return Integer.parseInt(r);
}
static public boolean getBooleanAttribute(final Element me, final String attr, boolean defaultValue) {
if (me == null) return defaultValue;
final Attribute a = me.getAttribute(attr);
if (a == null) return defaultValue;
final String r = a.getValue();
if (r == null) return defaultValue;
return (r.equalsIgnoreCase("true"));
}
@Nullable
public static RearrangerSettings getSettingsFromFile(File f) {
try {
final FileInputStream stream = new FileInputStream(f);
try {
return getSettingsFromStream(stream);
}
finally {
try {
stream.close();
}
catch (IOException e) {
// Ignore.
}
}
}
catch (FileNotFoundException e) {
LOG.debug("getSettingsFromFile:" + e);
}
return null;
}
// --------------------------- CONSTRUCTORS ---------------------------
// END OF ALL FIELDS
public RearrangerSettings() {
myItemOrderAttributeList = new ArrayList<AttributeGroup>();
myClassOrderAttributeList = new ArrayList<AttributeGroup>();
myRelatedMethodsSettings = new RelatedMethodsSettings();
myKeepGettersSettersTogether = false;
myKeepGettersSettersWithProperty = false;
myKeepOverloadedMethodsTogether = false;
myGlobalCommentPattern = "";
myOverloadedOrder = OVERLOADED_ORDER_RETAIN_ORIGINAL;
myAskBeforeRearranging = false;
myRearrangeInnerClasses = false;
myShowParameterTypes = true;
myShowParameterNames = false;
myShowFields = true;
myShowTypeAfterMethod = true;
myShowRules = false;
myShowMatchedRules = false;
myShowComments = false;
myRemoveBlanksInsideCodeBlocks = false;
myAfterClassLBrace = new ForceBlankLineSetting(false, true, ForceBlankLineSetting.CLASS_OBJECT, "AfterClassLBrace");
myAfterClassRBrace = new ForceBlankLineSetting(false, false, ForceBlankLineSetting.CLASS_OBJECT, "AfterClassRBrace");
myBeforeClassRBrace = new ForceBlankLineSetting(true, false, ForceBlankLineSetting.CLASS_OBJECT, "BeforeClassRBrace");
beforeMethodLBrace = new ForceBlankLineSetting(true, true, ForceBlankLineSetting.METHOD_OBJECT, "BeforeMethodLBrace");
myAfterMethodLBrace = new ForceBlankLineSetting(false, true, ForceBlankLineSetting.METHOD_OBJECT, "AfterMethodLBrace");
myBeforeMethodRBrace = new ForceBlankLineSetting(true, false, ForceBlankLineSetting.METHOD_OBJECT, "BeforeMethodRBrace");
myAfterMethodRBrace = new ForceBlankLineSetting(false, false, ForceBlankLineSetting.METHOD_OBJECT, "AfterMethodRBrace");
myNewLinesAtEOF = new ForceBlankLineSetting(false, false, ForceBlankLineSetting.EOF_OBJECT, "NewlinesAtEOF");
myDefaultGSDefinition = new GetterSetterDefinition();
myPrimaryMethodList = new LinkedList<PrimaryMethodSetting>();
}
// --------------------- GETTER / SETTER METHODS ---------------------
public ForceBlankLineSetting getAfterClassLBrace() {
return myAfterClassLBrace;
}
public ForceBlankLineSetting getAfterClassRBrace() {
return myAfterClassRBrace;
}
public ForceBlankLineSetting getBeforeMethodLBrace() {
return beforeMethodLBrace;
}
public ForceBlankLineSetting getAfterMethodLBrace() {
return myAfterMethodLBrace;
}
public ForceBlankLineSetting getAfterMethodRBrace() {
return myAfterMethodRBrace;
}
public ForceBlankLineSetting getBeforeClassRBrace() {
return myBeforeClassRBrace;
}
public ForceBlankLineSetting getBeforeMethodRBrace() {
return myBeforeMethodRBrace;
}
public final List<AttributeGroup> getClassOrderAttributeList() {
return myClassOrderAttributeList;
}
public GetterSetterDefinition getDefaultGSDefinition() {
return myDefaultGSDefinition;
}
// Level 1 methods
public String getGlobalCommentPattern() {
return myGlobalCommentPattern;
}
// Level 2 methods
public void setGlobalCommentPattern(String globalCommentPattern) {
myGlobalCommentPattern = globalCommentPattern;
}
// end of Level 2 methods
// end of Level 1 methods
public final List<AttributeGroup> getItemOrderAttributeList() {
return myItemOrderAttributeList;
}
public ForceBlankLineSetting getNewLinesAtEOF() {
return myNewLinesAtEOF;
}
// Level 1 methods
public int getOverloadedOrder() {
return myOverloadedOrder;
}
// Level 2 methods
public void setOverloadedOrder(int overloadedOrder) {
myOverloadedOrder = overloadedOrder;
}
// end of Level 2 methods
// end of Level 1 methods
public RelatedMethodsSettings getExtractedMethodsSettings() {
return myRelatedMethodsSettings;
}
// Level 1 methods
public boolean isAskBeforeRearranging() {
return myAskBeforeRearranging;
}
// Level 2 methods
public void setAskBeforeRearranging(boolean askBeforeRearranging) {
myAskBeforeRearranging = askBeforeRearranging;
}
public boolean isKeepGettersSettersTogether() {
return myKeepGettersSettersTogether;
}
// Level 2 methods
public void setKeepGettersSettersTogether(boolean keepGettersSettersTogether) {
myKeepGettersSettersTogether = keepGettersSettersTogether;
}
public boolean isKeepGettersSettersWithProperty() {
return myKeepGettersSettersWithProperty;
}
public void setKeepGettersSettersWithProperty(boolean keepGettersSettersWithProperty) {
myKeepGettersSettersWithProperty = keepGettersSettersWithProperty;
}
// end of Level 2 methods
// end of Level 1 methods
// Level 1 methods
public boolean isKeepOverloadedMethodsTogether() {
return myKeepOverloadedMethodsTogether;
}
// Level 2 methods
public void setKeepOverloadedMethodsTogether(boolean keepOverloadedMethodsTogether) {
myKeepOverloadedMethodsTogether = keepOverloadedMethodsTogether;
}
// end of Level 2 methods
// end of Level 1 methods
// Level 1 methods
public boolean isRearrangeInnerClasses() {
return myRearrangeInnerClasses;
}
public void setRearrangeInnerClasses(boolean rearrangeInnerClasses) {
myRearrangeInnerClasses = rearrangeInnerClasses;
}
// end of Level 2 methods
// end of Level 1 methods
// Level 1 methods
public boolean isRemoveBlanksInsideCodeBlocks() {
return myRemoveBlanksInsideCodeBlocks;
}
// Level 2 methods
public void setRemoveBlanksInsideCodeBlocks(boolean removeBlanksInsideCodeBlocks) {
myRemoveBlanksInsideCodeBlocks = removeBlanksInsideCodeBlocks;
}
public boolean isShowComments() {
return myShowComments;
}
public void setShowComments(boolean showComments) {
myShowComments = showComments;
}
// end of Level 2 methods
// end of Level 1 methods
// Level 1 methods
public boolean isShowFields() {
return myShowFields;
}
// Level 2 methods
public void setShowFields(boolean showFields) {
myShowFields = showFields;
}
public boolean isShowMatchedRules() {
return myShowMatchedRules;
}
public void setShowMatchedRules(boolean showMatchedRules) {
myShowMatchedRules = showMatchedRules;
}
public boolean isShowParameterNames() {
return myShowParameterNames;
}
// Level 2 methods
public void setShowParameterNames(boolean showParameterNames) {
myShowParameterNames = showParameterNames;
}
// end of Level 2 methods
// end of Level 1 methods
// Level 1 methods
public boolean isShowParameterTypes() {
return myShowParameterTypes;
}
// Level 2 methods
public void setShowParameterTypes(boolean showParameterTypes) {
myShowParameterTypes = showParameterTypes;
}
// end of Level 2 methods
// end of Level 1 methods
// Level 1 methods
public boolean isShowRules() {
return myShowRules;
}
public void setShowRules(boolean showRules) {
myShowRules = showRules;
}
// end of Level 2 methods
// end of Level 1 methods
public boolean isShowTypeAfterMethod() {
return myShowTypeAfterMethod;
}
public void setShowTypeAfterMethod(boolean showTypeAfterMethod) {
myShowTypeAfterMethod = showTypeAfterMethod;
}
// ------------------------ CANONICAL METHODS ------------------------
public boolean equals(final Object object) {
if (!(object instanceof RearrangerSettings)) return false;
final RearrangerSettings rs = (RearrangerSettings)object;
if (rs.getClassOrderAttributeList().size() != getClassOrderAttributeList().size()) return false;
if (rs.getItemOrderAttributeList().size() != getItemOrderAttributeList().size()) return false;
for (int i = 0; i < getClassOrderAttributeList().size(); i++) {
if (!getClassOrderAttributeList().get(i).equals(rs.getClassOrderAttributeList().get(i))) return false;
}
for (int i = 0; i < getItemOrderAttributeList().size(); i++) {
if (!getItemOrderAttributeList().get(i).equals(rs.getItemOrderAttributeList().get(i))) return false;
}
if (!rs.getExtractedMethodsSettings().equals(getExtractedMethodsSettings())) return false;
if (rs.isKeepGettersSettersTogether() != isKeepGettersSettersTogether()) return false;
if (rs.isKeepGettersSettersWithProperty() != isKeepGettersSettersWithProperty()) return false;
if (rs.isKeepOverloadedMethodsTogether() != isKeepOverloadedMethodsTogether()) return false;
if (rs.myOverloadedOrder != myOverloadedOrder) return false;
if (!rs.myGlobalCommentPattern.equals(myGlobalCommentPattern)) return false;
if (rs.myAskBeforeRearranging != myAskBeforeRearranging) return false;
if (rs.myRearrangeInnerClasses != myRearrangeInnerClasses) return false;
if (rs.myShowParameterTypes != myShowParameterTypes) return false;
if (rs.myShowParameterNames != myShowParameterNames) return false;
if (rs.myShowFields != myShowFields) return false;
if (rs.myShowTypeAfterMethod != myShowTypeAfterMethod) return false;
if (rs.myShowRules != myShowRules) return false;
if (rs.myShowMatchedRules != myShowMatchedRules) return false;
if (rs.myShowComments != myShowComments) return false;
if (rs.myRemoveBlanksInsideCodeBlocks != myRemoveBlanksInsideCodeBlocks) return false;
if (!rs.myAfterClassLBrace.equals(myAfterClassLBrace)) return false;
if (!rs.myAfterClassRBrace.equals(myAfterClassRBrace)) return false;
if (!rs.myBeforeClassRBrace.equals(myBeforeClassRBrace)) return false;
if (!rs.beforeMethodLBrace.equals(beforeMethodLBrace)) return false;
if (!rs.myAfterMethodLBrace.equals(myAfterMethodLBrace)) return false;
if (!rs.myAfterMethodRBrace.equals(myAfterMethodRBrace)) return false;
if (!rs.myBeforeMethodRBrace.equals(myBeforeMethodRBrace)) return false;
if (!rs.myNewLinesAtEOF.equals(myNewLinesAtEOF)) return false;
if (!rs.myDefaultGSDefinition.equals(myDefaultGSDefinition)) return false;
if (myPrimaryMethodList.size() != rs.myPrimaryMethodList.size()) return false;
for (int i = 0; i < myPrimaryMethodList.size(); i++) {
PrimaryMethodSetting pms = myPrimaryMethodList.get(i);
PrimaryMethodSetting rspms = rs.myPrimaryMethodList.get(i);
if (!rspms.equals(pms)) return false;
}
return true;
}
// -------------------------- OTHER METHODS --------------------------
public void addClass(@NotNull AttributeGroup group) {
myClassOrderAttributeList.add(group);
}
public final void insertClass(@NotNull final AttributeGroup ca, final int index) {
if (myClassOrderAttributeList.size() < index) {
myClassOrderAttributeList.add(ca);
}
else {
myClassOrderAttributeList.add(index, ca);
}
}
public void addItem(@NotNull AttributeGroup group) {
myItemOrderAttributeList.add(group);
}
public final void insertItem(@NotNull final AttributeGroup ia, final int index) {
if (myItemOrderAttributeList.size() < index) {
myItemOrderAttributeList.add(ia);
}
else {
myItemOrderAttributeList.add(index, ia);
}
}
public final RearrangerSettings deepCopy() {
final RearrangerSettings result = new RearrangerSettings();
for (AttributeGroup itemAttributes : myItemOrderAttributeList) {
result.myItemOrderAttributeList.add(itemAttributes.deepCopy());
}
for (AttributeGroup classAttributes : myClassOrderAttributeList) {
result.myClassOrderAttributeList.add(classAttributes.deepCopy());
}
result.myRelatedMethodsSettings = myRelatedMethodsSettings.deepCopy();
result.myKeepGettersSettersTogether = myKeepGettersSettersTogether;
result.myKeepGettersSettersWithProperty = myKeepGettersSettersWithProperty;
result.myKeepOverloadedMethodsTogether = myKeepOverloadedMethodsTogether;
result.myGlobalCommentPattern = myGlobalCommentPattern;
result.myOverloadedOrder = myOverloadedOrder;
result.myAskBeforeRearranging = myAskBeforeRearranging;
result.myRearrangeInnerClasses = myRearrangeInnerClasses;
result.myShowParameterNames = myShowParameterNames;
result.myShowParameterTypes = myShowParameterTypes;
result.myShowFields = myShowFields;
result.myShowTypeAfterMethod = myShowTypeAfterMethod;
result.myShowRules = myShowRules;
result.myShowMatchedRules = myShowMatchedRules;
result.myShowComments = myShowComments;
result.myRemoveBlanksInsideCodeBlocks = myRemoveBlanksInsideCodeBlocks;
result.myAfterClassLBrace = myAfterClassLBrace.deepCopy();
result.myAfterClassRBrace = myAfterClassRBrace.deepCopy();
result.myBeforeClassRBrace = myBeforeClassRBrace.deepCopy();
result.beforeMethodLBrace = beforeMethodLBrace.deepCopy();
result.myAfterMethodLBrace = myAfterMethodLBrace.deepCopy();
result.myAfterMethodRBrace = myAfterMethodRBrace.deepCopy();
result.myBeforeMethodRBrace = myBeforeMethodRBrace.deepCopy();
result.myNewLinesAtEOF = myNewLinesAtEOF.deepCopy();
result.myDefaultGSDefinition = myDefaultGSDefinition.deepCopy();
return result;
}
@SuppressWarnings("IOResourceOpenedButNotSafelyClosed")
public void writeSettingsToFile(File f) {
Element component = new Element("component");
component.setAttribute("name", Rearranger.COMPONENT_NAME);
Element r = new Element(Rearranger.COMPONENT_NAME);
component.getChildren().add(r);
writeExternal(r);
Format format = Format.getPrettyFormat();
XMLOutputter outputter = new XMLOutputter(format);
FileOutputStream fileOutputStream = null;
try {
fileOutputStream = new FileOutputStream(f);
outputter.output(component, fileOutputStream);
fileOutputStream.close();
}
catch (IOException e) {
throw new RuntimeException(e);
}
finally {
if (fileOutputStream != null) {
try {
fileOutputStream.close();
}
catch (IOException e) {
// Ignore
}
}
}
}
// end of Level 2 methods
// end of Level 1 methods
public final void writeExternal(final Element entry) {
final Element items = new Element("Items");
final Element classes = new Element("Classes");
entry.getChildren().add(items);
entry.getChildren().add(classes);
for (AttributeGroup item : myItemOrderAttributeList) {
item.writeExternal(items);
}
for (AttributeGroup attributes : myClassOrderAttributeList) {
attributes.writeExternal(classes);
}
final Element gsd = new Element("DefaultGetterSetterDefinition");
entry.getChildren().add(gsd);
myDefaultGSDefinition.writeExternal(gsd);
final Element relatedItems = new Element("RelatedMethods");
entry.getChildren().add(relatedItems);
entry.setAttribute("KeepGettersSettersTogether", Boolean.valueOf(myKeepGettersSettersTogether).toString());
entry.setAttribute("KeepGettersSettersWithProperty", Boolean.valueOf(myKeepGettersSettersWithProperty).toString());
entry.setAttribute("KeepOverloadedMethodsTogether", Boolean.valueOf(myKeepOverloadedMethodsTogether).toString());
entry.setAttribute("ConfirmBeforeRearranging", Boolean.valueOf(myAskBeforeRearranging).toString());
entry.setAttribute("RearrangeInnerClasses", Boolean.valueOf(myRearrangeInnerClasses).toString());
entry.setAttribute("globalCommentPattern", myGlobalCommentPattern);
entry.setAttribute("overloadedOrder", "" + myOverloadedOrder);
entry.setAttribute("ShowParameterTypes", Boolean.valueOf(myShowParameterTypes).toString());
entry.setAttribute("ShowParameterNames", Boolean.valueOf(myShowParameterNames).toString());
entry.setAttribute("ShowFields", Boolean.valueOf(myShowFields).toString());
entry.setAttribute("ShowTypeAfterMethod", Boolean.valueOf(myShowTypeAfterMethod).toString());
entry.setAttribute("ShowRules", Boolean.valueOf(myShowRules).toString());
entry.setAttribute("ShowMatchedRules", Boolean.valueOf(myShowMatchedRules).toString());
entry.setAttribute("ShowComments", Boolean.valueOf(myShowComments).toString());
entry.setAttribute("RemoveBlanksInsideCodeBlocks", Boolean.valueOf(myRemoveBlanksInsideCodeBlocks).toString());
myRelatedMethodsSettings.writeExternal(relatedItems);
myAfterClassLBrace.writeExternal(entry);
myAfterClassRBrace.writeExternal(entry);
myBeforeClassRBrace.writeExternal(entry);
beforeMethodLBrace.writeExternal(entry);
myAfterMethodLBrace.writeExternal(entry);
myAfterMethodRBrace.writeExternal(entry);
myBeforeMethodRBrace.writeExternal(entry);
myNewLinesAtEOF.writeExternal(entry);
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/RelatedByNameMethodsSettings.java
-45
View File
@@ -1,45 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings;
import java.util.ArrayList;
/** Contains settings pertaining to methods related by name, e.g. getter/setters. */
public class RelatedByNameMethodsSettings {
ArrayList<PrimaryMethodSetting> methodList;
public RelatedByNameMethodsSettings() {
methodList = new ArrayList<PrimaryMethodSetting>();
}
public ArrayList<PrimaryMethodSetting>/*<IListManagerObject>*/ getMethodList() {
return methodList;
}
public void addMethod(PrimaryMethodSetting pms) {
methodList.add(pms);
}
public void removeMethod(PrimaryMethodSetting pms) {
methodList.remove(pms);
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/RelatedMethodsSettings.java
-247
View File
@@ -1,247 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings;
import com.wrq.rearranger.settings.attributeGroups.RegexUtil;
import org.jdom.Element;
import java.util.List;
/** Contains settings regarding placement of related methods. */
public class RelatedMethodsSettings {
private boolean moveExtractedMethods;
private boolean belowFirstCaller; // false means below last caller
private boolean depthFirstOrdering; // false means breadth first ordering
public static final int INVOCATION_ORDER = 0;
public static final int RETAIN_ORIGINAL_ORDER = 1;
public static final int ALPHABETICAL_ORDER = 2;
private int ordering;
public static final int NON_PRIVATE_EXTRACTED_NEVER = 0;
public static final int NON_PRIVATE_EXTRACTED_ONE_CALLER = 1;
public static final int NON_PRIVATE_EXTRACTED_ANY_CALLERS = 2;
private int nonPrivateTreatment;
public static final int COMMENT_TYPE_TOP_LEVEL = 0;
public static final int COMMENT_TYPE_EACH_LEVEL = 1;
public static final int COMMENT_TYPE_EACH_METHOD = 2;
public static final int COMMENT_TYPE_NEW_FAMILY = 3;
private int commentType;
private CommentRule precedingComment;
private CommentRule trailingComment;
private CommentFillString commentFillString;
private RelatedByNameMethodsSettings rbnms;
public RelatedByNameMethodsSettings getRbnms() {
return rbnms;
}
public RelatedMethodsSettings() {
belowFirstCaller = true;
depthFirstOrdering = true;
ordering = INVOCATION_ORDER;
nonPrivateTreatment = NON_PRIVATE_EXTRACTED_ANY_CALLERS;
commentType = COMMENT_TYPE_TOP_LEVEL;
precedingComment = new CommentRule();
trailingComment = new CommentRule();
rbnms = new RelatedByNameMethodsSettings();
commentFillString = new CommentFillString();
}
public boolean isMoveExtractedMethods() {
return moveExtractedMethods;
}
public void setMoveExtractedMethods(boolean moveExtractedMethods) {
this.moveExtractedMethods = moveExtractedMethods;
}
public boolean isBelowFirstCaller() {
return belowFirstCaller;
}
public void setBelowFirstCaller(boolean belowFirstCaller) {
this.belowFirstCaller = belowFirstCaller;
}
public boolean isDepthFirstOrdering() {
return depthFirstOrdering;
}
public void setDepthFirstOrdering(boolean depthFirstOrdering) {
this.depthFirstOrdering = depthFirstOrdering;
}
public int getOrdering() {
return ordering;
}
public void setOrdering(int ordering) {
this.ordering = ordering;
}
public int getNonPrivateTreatment() {
return nonPrivateTreatment;
}
public void setNonPrivateTreatment(int nonPrivateTreatment) {
this.nonPrivateTreatment = nonPrivateTreatment;
}
public int getCommentType() {
return commentType;
}
public void setCommentType(int commentType) {
this.commentType = commentType;
}
public CommentRule getPrecedingComment() {
return precedingComment;
}
public void setPrecedingComment(CommentRule precedingComment) {
this.precedingComment = precedingComment;
}
public CommentRule getTrailingComment() {
return trailingComment;
}
public void setTrailingComment(CommentRule trailingComment) {
this.trailingComment = trailingComment;
}
public CommentFillString getCommentFillString() {
return commentFillString;
}
public boolean equals(Object object) {
if (object instanceof RelatedMethodsSettings) {
RelatedMethodsSettings rms = (RelatedMethodsSettings)object;
return (rms.moveExtractedMethods == moveExtractedMethods &&
rms.belowFirstCaller == belowFirstCaller &&
rms.depthFirstOrdering == depthFirstOrdering &&
rms.ordering == ordering &&
rms.nonPrivateTreatment == nonPrivateTreatment &&
rms.commentType == commentType &&
rms.precedingComment.equals(precedingComment) &&
rms.trailingComment.equals(trailingComment) &&
rms.commentFillString.equals(commentFillString));
}
return false;
}
public RelatedMethodsSettings deepCopy() {
RelatedMethodsSettings result = new RelatedMethodsSettings();
result.moveExtractedMethods = moveExtractedMethods;
result.belowFirstCaller = belowFirstCaller;
result.depthFirstOrdering = depthFirstOrdering;
result.ordering = ordering;
result.nonPrivateTreatment = nonPrivateTreatment;
result.commentType = commentType;
result.precedingComment = (CommentRule)precedingComment.deepCopy();
result.trailingComment = (CommentRule)trailingComment.deepCopy();
result.commentFillString = commentFillString.deepCopy();
return result;
}
public String toString() {
return "moveExtractedMethods=" + moveExtractedMethods +
", belowFirstCaller=" + belowFirstCaller +
", depthFirstOrdering=" + depthFirstOrdering +
", ordering=" + ordering +
", non-private treatment=" + nonPrivateTreatment +
", comment type=" + commentType;
}
public void loadAttributes(final Element me) {
moveExtractedMethods = RearrangerSettings.getBooleanAttribute(me, "moveExtractedMethods");
belowFirstCaller = RearrangerSettings.getBooleanAttribute(me, "belowFirstCaller", true);
depthFirstOrdering = RearrangerSettings.getBooleanAttribute(me, "depthFirstOrdering", true);
ordering = RearrangerSettings.getIntAttribute(me,
"ordering",
INVOCATION_ORDER);
nonPrivateTreatment = RearrangerSettings.getIntAttribute(me,
"nonPrivateTreatment",
NON_PRIVATE_EXTRACTED_ANY_CALLERS);
commentType = RearrangerSettings.getIntAttribute(me,
"commentType",
COMMENT_TYPE_TOP_LEVEL);
Element prc = me.getChild("PrecedingComment");
if (prc != null) prc = prc.getChild("Comment");
precedingComment = CommentRule.readExternal(prc);
Element trc = me.getChild("TrailingComment");
if (trc != null) trc = trc.getChild("Comment");
trailingComment = CommentRule.readExternal(trc);
commentFillString = CommentFillString.readExternal(me);
}
public static RelatedMethodsSettings readExternal(final Element item) {
final RelatedMethodsSettings result = new RelatedMethodsSettings();
result.loadAttributes(item);
return result;
}
public final void writeExternal(final Element me) {
me.setAttribute("moveExtractedMethods", Boolean.valueOf(moveExtractedMethods).toString());
me.setAttribute("belowFirstCaller", Boolean.valueOf(belowFirstCaller).toString());
me.setAttribute("depthFirstOrdering", Boolean.valueOf(depthFirstOrdering).toString());
me.setAttribute("ordering", "" + ordering);
me.setAttribute("nonPrivateTreatment", "" + nonPrivateTreatment);
me.setAttribute("commentType", "" + commentType);
Element prc = new Element("PrecedingComment");
Element trc = new Element("TrailingComment");
me.getChildren().add(prc);
me.getChildren().add(trc);
precedingComment.writeExternal(prc);
trailingComment.writeExternal(trc);
commentFillString.writeExternal(me);
}
public void addCommentPatternsToList(List<String> list) {
addCommentPatternToList(precedingComment, list);
addCommentPatternToList(trailingComment, list);
}
private void addCommentPatternToList(CommentRule comment, List<String> list) {
String s = null;
if (comment != null) {
s = comment.getCommentText();
}
if (s != null && s.length() > 0) {
String esc = RegexUtil.escape(s);
String fsp = commentFillString.getFillStringPattern();
s = RegexUtil.replaceAllFS(esc, fsp);
s = s.replaceAll("%TL%", "[A-Za-z0-9_()]+");
s = s.replaceAll("%MN%", "[A-Za-z0-9_()]+");
s = s.replaceAll("%AM%", "[A-Za-z0-9_\\\\[\\\\],.]+");
s = s.replaceAll("%LV%", "[0-9]+");
list.add(s);
}
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/SecondaryMethodSetting.java
-307
View File
@@ -1,307 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings;
import com.wrq.rearranger.configuration.IListManagerObject;
import com.wrq.rearranger.configuration.IntTextField;
import com.wrq.rearranger.configuration.StringTextArea;
import com.wrq.rearranger.configuration.StringTextField;
import javax.swing.*;
import java.awt.*;
/**
* Contains settings for each secondary method (e.g., "set", "is"). Any number of secondary method definitions
* may be associated with a primary method definition.
*/
public class SecondaryMethodSetting
implements IListManagerObject
{
/** Description of the related method. */
String description;
/**
* Regular expression which method name must match. If the method is to be matched to a field, there must be
* at least one capture group (parenthesized subexpression) which will be treated as the field.
* In the case of a traditional setter method, this pattern is "set%FN%". One substitution is available:
* <pre>
* %FN% field name
* </pre>
*/
String methodNamePattern;
/** number of parameters the secondary method must have. In the case of a traditional setter method, this is one. */
int numParameters;
/**
* regular expression pattern of the type which the secondary method must return.
* In the case of a traditional getter method, this is the field type. One substitution is available:
* <pre>
* %FT% field type
* </pre>
*/
String methodTypePattern;
/**
* regular expression pattern of the attributes of the method.
* In the case of a traditional getter method, this is ".*public.*" (i.e., any public method).
*/
String methodAttributePattern;
/**
* pattern of method body (excluding comments and newline characters). Substitutions are available as follows:
* <pre>
* %FN% field name
* %FT% field type (if field is valid field, else empty string)
* %MT% method return type
* %P1% parameter 1 name (%P2%, %P3% etc for additional parameters)
* %T1% parameter 1 type name
* </pre>
*/
String body;
public SecondaryMethodSetting() {
methodNamePattern = "set%FN%";
numParameters = 1;
methodTypePattern = "void";
methodAttributePattern = ".*public.*";
body = "{\\s*return\\s*%FN%;\\s*}";
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getMethodNamePattern() {
return methodNamePattern;
}
public void setMethodNamePattern(String methodNamePattern) {
this.methodNamePattern = methodNamePattern;
}
public int getNumParameters() {
return numParameters;
}
public void setNumParameters(int numParameters) {
this.numParameters = numParameters;
}
public String getMethodTypePattern() {
return methodTypePattern;
}
public void setMethodTypePattern(String methodTypePattern) {
this.methodTypePattern = methodTypePattern;
}
public String getMethodAttributePattern() {
return methodAttributePattern;
}
public void setMethodAttributePattern(String methodAttributePattern) {
this.methodAttributePattern = methodAttributePattern;
}
public String getBody() {
return body;
}
public void setBody(String body) {
this.body = body;
}
public String toString() {
return description;
}
public com.wrq.rearranger.configuration.IListManagerObject deepcopy() {
SecondaryMethodSetting pms = new SecondaryMethodSetting();
pms.description = getDescription();
pms.methodNamePattern = getMethodNamePattern();
pms.numParameters = getNumParameters();
pms.methodTypePattern = getMethodTypePattern();
pms.methodAttributePattern = getMethodAttributePattern();
pms.body = getBody();
return pms;
}
public boolean equals(Object obj) {
if (!(obj instanceof PrimaryMethodSetting)) return false;
PrimaryMethodSetting pms = (PrimaryMethodSetting)obj;
if (!pms.description.equals(description)) return false;
if (!pms.methodNamePattern.equals(methodNamePattern)) return false;
if (pms.numParameters != numParameters) return false;
if (!pms.methodTypePattern.equals(methodTypePattern)) return false;
if (!pms.methodAttributePattern.equals(methodAttributePattern)) return false;
if (!pms.body.equals(body)) return false;
return true;
}
public JPanel getPanel() {
JPanel panel = new JPanel(new GridBagLayout());
panel.setBorder(BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder(),
"Matching Method (\"Setter\") Criteria"));
GridBagConstraints constraints = new GridBagConstraints();
constraints.anchor = GridBagConstraints.NORTHWEST;
constraints.fill = GridBagConstraints.NONE;
constraints.gridwidth = 1;
constraints.gridheight = 1;
constraints.weightx = 0.0d;
constraints.weighty = 0.0d;
constraints.gridy = constraints.gridx = 0;
constraints.insets = new Insets(3, 3, 3, 3);
JLabel methodNamePatternLabel = new JLabel("Method name:");
methodNamePatternLabel.setToolTipText(
"Regular expression which method name must match. " +
"If the method is to be matched to a field, there must be\n" +
" at least one capture group (parenthesized subexpression) which will be treated as the field.\n" +
" In the case of a traditional setter method, this pattern is \"set%FN%\".\n" +
" One substitution is available:\n" +
" %FN% field name");
panel.add(methodNamePatternLabel, constraints);
constraints.gridx++;
constraints.fill = GridBagConstraints.HORIZONTAL;
constraints.weightx = .5;
StringTextField primaryPrefixText = new StringTextField() {
public void setValue(String value) {
setMethodNamePattern(value);
}
public String getValue() {
return getMethodNamePattern();
}
};
panel.add(primaryPrefixText, constraints);
constraints.fill = GridBagConstraints.NONE;
constraints.weightx = 0;
constraints.gridx++;
JLabel nParamLabel = new JLabel("Number of parameters:");
nParamLabel.setToolTipText(
"number of parameters the secondary method must have.\n" +
"In the case of a traditional setter method, this is 1.");
panel.add(nParamLabel, constraints);
constraints.gridx++;
IntTextField nParamText = new IntTextField(
new IntTextField.IGetSet() {
public int get() {
return numParameters;
}
public void set(int value) {
numParameters = value;
}
}, null, null
);
constraints.fill = GridBagConstraints.HORIZONTAL;
constraints.gridwidth = GridBagConstraints.REMAINDER;
panel.add(nParamText, constraints);
constraints.gridx = 0;
constraints.gridy++;
constraints.gridwidth = 1;
constraints.weightx = 0;
constraints.fill = GridBagConstraints.NONE;
JLabel returnTypeLabel = new JLabel("Return type:");
returnTypeLabel.setToolTipText(
"regular expression pattern of the type which the secondary method must return.\n" +
" In the case of a traditional setter method, this is void. One substitution is available:\n" +
" * %FT% field type");
panel.add(returnTypeLabel, constraints);
constraints.gridx++;
constraints.weightx = .5;
constraints.fill = GridBagConstraints.HORIZONTAL;
StringTextField returnTypeField = new StringTextField() {
public void setValue(String value) {
methodTypePattern = value;
}
public String getValue() {
return methodTypePattern;
}
};
panel.add(returnTypeField, constraints);
constraints.fill = GridBagConstraints.NONE;
constraints.gridx++;
constraints.weightx = 0;
JLabel methodAttributeLabel = new JLabel("Method attributes:");
methodAttributeLabel.setToolTipText("Protection level or other attributes for the method.\n" +
"In the case of a getter method, this is usually \".*public.*\".");
panel.add(methodAttributeLabel, constraints);
StringTextField methodAttributeField = new StringTextField() {
public void setValue(String value) {
methodAttributePattern = value;
}
public String getValue() {
return methodAttributePattern;
}
};
constraints.gridx++;
constraints.gridwidth = GridBagConstraints.REMAINDER;
constraints.weightx = .5;
constraints.fill = GridBagConstraints.HORIZONTAL;
panel.add(methodAttributeField, constraints);
constraints.gridx++;
constraints.weightx = 0;
constraints.fill = GridBagConstraints.NONE;
constraints.gridy++;
constraints.gridx = 0;
JLabel bodyLabel = new JLabel("Body:");
bodyLabel.setToolTipText("regular expression pattern of method body (excluding comments and newline characters).\n" +
"Substitutions are available as follows:\n" +
" %FN% field name\n" +
" %FT% field type (if field is valid field, else empty string)\n" +
" %MT% method return type\n" +
" %P1% parameter 1 name (%P2%, %P3% etc for additional parameters)\n" +
" %T1% parameter 1 type name");
constraints.gridwidth = 1;
constraints.weightx = 0;
constraints.fill = GridBagConstraints.NONE;
panel.add(bodyLabel, constraints);
constraints.gridx++;
StringTextArea bodyField = new StringTextArea() {
public void setValue(String value) {
body = value;
}
public String getValue() {
return body;
}
};
constraints.gridwidth = GridBagConstraints.REMAINDER;
constraints.weightx = 1;
constraints.weighty = .35;
constraints.fill = GridBagConstraints.BOTH;
JScrollPane sp = new JScrollPane(bodyField);
panel.add(sp, constraints);
constraints.gridx = 0;
constraints.gridy++;
constraints.gridheight = GridBagConstraints.REMAINDER;
constraints.fill = GridBagConstraints.NONE;
constraints.fill = GridBagConstraints.BOTH;
constraints.weightx = 1;
constraints.weighty = .65;
return panel;
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/atomicAttributes/AbstractAttribute.java
-55
View File
@@ -1,55 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings.atomicAttributes;
import org.jdom.Element;
import java.lang.reflect.Modifier;
/** Common routines for 'abstract' modifier. */
public final class AbstractAttribute
extends AndNotAttribute
{
// -------------------------- STATIC METHODS --------------------------
public static AbstractAttribute readExternal(final Element item) {
final AbstractAttribute result = new AbstractAttribute();
result.loadAttributes(item.getChild(result.getElementName()));
return result;
}
// --------------------------- CONSTRUCTORS ---------------------------
public AbstractAttribute() {
super("abstract", Modifier.ABSTRACT);
}
// -------------------------- OTHER METHODS --------------------------
public final /*AbstractAttribute*/AtomicAttribute deepCopy() {
final AbstractAttribute aba = new AbstractAttribute();
aba.value = value;
aba.invert = invert;
return aba;
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/atomicAttributes/AndNotAttribute.java
-150
View File
@@ -1,150 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings.atomicAttributes;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.util.Constraints;
import org.jdom.Element;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
/** Base class for all boolean attributes. */
abstract public class AndNotAttribute extends AtomicAttribute {
// ------------------------------ FIELDS ------------------------------
boolean value;
boolean invert;
private final String valueName;
private final int modifierBit;
// --------------------------- CONSTRUCTORS ---------------------------
AndNotAttribute(final String s, final int modifierBit) {
valueName = s;
this.modifierBit = modifierBit;
}
// --------------------- GETTER / SETTER METHODS ---------------------
public final JPanel getAndNotPanel() {
final JPanel andNotPanel = new JPanel(new GridBagLayout());
final Constraints constraints = new Constraints(GridBagConstraints.WEST);
final JCheckBox andBox = new JCheckBox("And");
andBox.setSelected(isValue());
final JCheckBox notBox = new JCheckBox("not");
notBox.setSelected(isInvert());
notBox.setEnabled(andBox.isSelected());
notBox.setForeground(notBox.isSelected() ? Color.BLACK : Color.GRAY);
final JLabel nameLabel = new JLabel(getName());
nameLabel.setEnabled(andBox.isSelected());
andNotPanel.add(andBox, constraints.firstCol());
andNotPanel.add(notBox, constraints.nextCol());
constraints.insets = new Insets(0, 0, 0, 4);
andNotPanel.add(nameLabel, constraints.weightedLastCol());
andBox.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
setValue(andBox.isSelected());
notBox.setEnabled(andBox.isSelected());
nameLabel.setEnabled(andBox.isSelected());
}
});
notBox.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
setInvert(notBox.isSelected());
notBox.setForeground(notBox.isSelected() ? Color.BLACK : Color.GRAY);
}
});
return andNotPanel;
}
private String getName() {
return valueName;
}
public final boolean isInvert() {
return invert;
}
public final void setInvert(final boolean invert) {
this.invert = invert;
}
public final boolean isValue() {
return value;
}
public final void setValue(final boolean value) {
this.value = value;
}
// ------------------------ CANONICAL METHODS ------------------------
public final boolean equals(final Object obj) {
if (!(obj instanceof AndNotAttribute)) return false;
final AndNotAttribute ana = (AndNotAttribute)obj;
return (value == ana.value &&
invert == ana.invert &&
valueName.equals(ana.valueName) &&
modifierBit == ana.modifierBit);
}
// -------------------------- OTHER METHODS --------------------------
public final void appendAttributes(final Element me) {
final Element stElement = new Element(getElementName());
me.getChildren().add(stElement);
stElement.setAttribute("value", Boolean.valueOf(value).toString());
stElement.setAttribute("invert", Boolean.valueOf(invert).toString());
}
final String getElementName() {
final StringBuffer sb = new StringBuffer(valueName.length());
sb.append(valueName);
sb.replace(0, 1, new String("" + sb.charAt(0)).toUpperCase());
for (int i = 1; i < sb.length(); i++) {
if (sb.charAt(i) == ' ') {
sb.deleteCharAt(i);
sb.replace(i, i + 1, new String("" + sb.charAt(i)).toUpperCase());
}
}
return sb.toString();
}
public final String getDescriptiveString() {
return (isValue() ?
isInvert() ? "non-" + valueName + " " : valueName + " "
: "");
}
public final boolean isMatch(final int modifiers) {
return (!isValue()) ? true : ((modifiers & modifierBit) > 0) ^ isInvert();
}
public final void loadAttributes(final Element item) {
value = RearrangerSettings.getBooleanAttribute(item, "value");
invert = RearrangerSettings.getBooleanAttribute(item, "invert");
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/atomicAttributes/AtomicAttribute.java
-33
View File
@@ -1,33 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings.atomicAttributes;
/** base class for all individual attributes that a field, method or class may have. */
abstract public class AtomicAttribute {
/**
* All subclasses will implement a static public AtomicAttribute readExternal(final Element item) method.
* However, because it is static, the interface can't contain it.
*/
// abstract public AtomicAttribute readExternal(final Element item);
}
plugins/rearranger/src/com/wrq/rearranger/settings/atomicAttributes/EnumAttribute.java
-55
View File
@@ -1,55 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings.atomicAttributes;
import com.wrq.rearranger.ModifierConstants;
import org.jdom.Element;
/** Routines to handle 'enum' class attribute. */
public class EnumAttribute
extends AndNotAttribute
{
// -------------------------- STATIC METHODS --------------------------
public static EnumAttribute readExternal(final Element item) {
final EnumAttribute result = new EnumAttribute();
result.loadAttributes(item.getChild(result.getElementName()));
return result;
}
// --------------------------- CONSTRUCTORS ---------------------------
public EnumAttribute() {
super("enum", ModifierConstants.ENUM);
}
// -------------------------- OTHER METHODS --------------------------
/** final attribute. */
public final /*EnumAttribute*/AtomicAttribute deepCopy() {
final EnumAttribute result = new EnumAttribute();
result.value = value;
result.invert = invert;
return result;
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/atomicAttributes/FinalAttribute.java
-53
View File
@@ -1,53 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings.atomicAttributes;
import org.jdom.Element;
import java.lang.reflect.Modifier;
/** Routines to handle the 'final' modifier. */
public final class FinalAttribute extends AndNotAttribute {
// -------------------------- STATIC METHODS --------------------------
public static FinalAttribute readExternal(final Element item) {
final FinalAttribute result = new FinalAttribute();
result.loadAttributes(item.getChild(result.getElementName()));
return result;
}
// --------------------------- CONSTRUCTORS ---------------------------
public FinalAttribute() {
super("final", Modifier.FINAL);
}
// -------------------------- OTHER METHODS --------------------------
public final /*FinalAttribute*/AtomicAttribute deepCopy() {
final FinalAttribute result = new FinalAttribute();
result.value = value;
result.invert = invert;
return result;
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/atomicAttributes/ImplementedAttribute.java
-54
View File
@@ -1,54 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings.atomicAttributes;
import com.wrq.rearranger.ModifierConstants;
import org.jdom.Element;
public final class ImplementedAttribute
extends AndNotAttribute
{
// -------------------------- STATIC METHODS --------------------------
public static ImplementedAttribute readExternal(final Element item) {
final ImplementedAttribute result = new ImplementedAttribute();
result.loadAttributes(item.getChild(result.getElementName()));
return result;
}
// --------------------------- CONSTRUCTORS ---------------------------
public ImplementedAttribute() {
super("implemented", ModifierConstants.IMPLEMENTED);
}
// -------------------------- OTHER METHODS --------------------------
public final /*ImplementedAttribute*/AtomicAttribute deepCopy() {
final ImplementedAttribute result = new ImplementedAttribute();
result.value = value;
result.invert = invert;
return result;
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/atomicAttributes/ImplementingAttribute.java
-53
View File
@@ -1,53 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings.atomicAttributes;
import com.wrq.rearranger.ModifierConstants;
import org.jdom.Element;
public final class ImplementingAttribute
extends AndNotAttribute
{
// -------------------------- STATIC METHODS --------------------------
public static ImplementingAttribute readExternal(final Element item) {
final ImplementingAttribute result = new ImplementingAttribute();
result.loadAttributes(item.getChild(result.getElementName()));
return result;
}
// --------------------------- CONSTRUCTORS ---------------------------
public ImplementingAttribute() {
super("implementing", ModifierConstants.IMPLEMENTING);
}
// -------------------------- OTHER METHODS --------------------------
public final /*ImplementingAttribute*/AtomicAttribute deepCopy() {
final ImplementingAttribute result = new ImplementingAttribute();
result.value = value;
result.invert = invert;
return result;
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/atomicAttributes/InitialisedByAnonymousClassAttribute.java
-51
View File
@@ -1,51 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings.atomicAttributes;
import com.wrq.rearranger.ModifierConstants;
import org.jdom.Element;
public final class InitialisedByAnonymousClassAttribute extends AndNotAttribute {
// -------------------------- STATIC METHODS --------------------------
public static InitialisedByAnonymousClassAttribute readExternal(final Element item) {
final InitialisedByAnonymousClassAttribute result = new InitialisedByAnonymousClassAttribute();
result.loadAttributes(item.getChild(result.getElementName()));
return result;
}
// --------------------------- CONSTRUCTORS ---------------------------
public InitialisedByAnonymousClassAttribute() {
super("initialized to anonymous class", ModifierConstants.INIT_TO_ANON_CLASS);
}
// -------------------------- OTHER METHODS --------------------------
public final /*InitToAnonClassAttribute*/AtomicAttribute deepCopy() {
final InitialisedByAnonymousClassAttribute result = new InitialisedByAnonymousClassAttribute();
result.value = value;
result.invert = invert;
return result;
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/atomicAttributes/InitializerAttribute.java
-53
View File
@@ -1,53 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings.atomicAttributes;
import com.wrq.rearranger.ModifierConstants;
import org.jdom.Element;
/** Routines to handle a static initializer method. */
public final class InitializerAttribute extends AndNotAttribute {
// -------------------------- STATIC METHODS --------------------------
public static InitializerAttribute readExternal(final Element item) {
final InitializerAttribute result = new InitializerAttribute();
result.loadAttributes(item.getChild(result.getElementName()));
return result;
}
// --------------------------- CONSTRUCTORS ---------------------------
public InitializerAttribute() {
super("initializer", ModifierConstants.INITIALIZER);
}
// -------------------------- OTHER METHODS --------------------------
public final /*InitializerAttribute*/AtomicAttribute deepCopy() {
final InitializerAttribute result = new InitializerAttribute();
result.value = value;
result.invert = invert;
return result;
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/atomicAttributes/IntegerAttribute.java
-172
View File
@@ -1,172 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings.atomicAttributes;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiMethod;
import com.wrq.rearranger.configuration.IntTextField;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.util.Constraints;
import com.wrq.rearranger.util.MethodUtil;
import org.jdom.Element;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
/** Allow item selection by comparison with an integer attribute. */
abstract public class IntegerAttribute extends AtomicAttribute {
public static final int OP_GE = 0;
public static final int OP_LE = 1;
// ------------------------------ FIELDS ------------------------------
protected int value;
protected int opType;
protected boolean match; // when true, condition applies
private final String attributeDisplayName; // should be plural
private final String storageName;
// --------------------------- CONSTRUCTORS ---------------------------
IntegerAttribute(final String attributeDisplayName,
final String storageName,
final int opType)
{
this.attributeDisplayName = attributeDisplayName;
this.storageName = storageName;
this.opType = opType;
}
// --------------------- GETTER / SETTER METHODS ---------------------
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public int getOpType() {
return opType;
}
public final boolean isMatch() {
return match;
}
public final void setMatch(final boolean match) {
this.match = match;
}
public final JPanel getIntegerPanel() {
final JPanel intPanel = new JPanel(new GridBagLayout());
final Constraints constraints = new Constraints();
constraints.weightedLastRow();
final JCheckBox enableBox = new JCheckBox(opType == OP_GE ? "with at least" : "with at most");
intPanel.add(enableBox, constraints.firstCol());
final IntTextField intField = new IntTextField(
new IntTextField.IGetSet() {
public int get() {
return value;
}
public void set(int v) {
value = v;
}
},
0, 99);
constraints.insets = new Insets(0, 3, 0, 0);
intPanel.add(intField, constraints.nextCol());
final JLabel attribLabel = new JLabel(attributeDisplayName + "s");
intPanel.add(attribLabel, constraints.weightedLastCol());
enableBox.setSelected(match);
enableBox.setForeground(enableBox.isSelected() ? Color.BLACK : Color.GRAY);
intField.setEnabled(match);
attribLabel.setEnabled(match);
enableBox.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
setMatch(enableBox.isSelected());
intPanel.setEnabled(enableBox.isSelected());
enableBox.setSelected(match);
enableBox.setForeground(enableBox.isSelected() ? Color.BLACK : Color.GRAY);
intField.setEnabled(match);
attribLabel.setEnabled(match);
}
});
return intPanel;
}
// ------------------------ CANONICAL METHODS ------------------------
public boolean equals(final Object obj) {
if (!(obj instanceof IntegerAttribute)) return false;
final IntegerAttribute na = (IntegerAttribute)obj;
return match == na.match &&
opType == na.opType &&
value == na.value;
}
// -------------------------- OTHER METHODS --------------------------
public final void appendAttributes(final Element me) {
final Element stElement = new Element(storageName);
me.getChildren().add(stElement);
stElement.setAttribute("match", Boolean.valueOf(match).toString());
stElement.setAttribute("opType", "" + opType);
stElement.setAttribute("value", "" + value);
}
protected final void deepCopy(IntegerAttribute result) {
result.match = match;
result.opType = opType;
result.value = value;
}
public final String getDescriptiveString() {
return (match ?
(opType == OP_GE ? "with at least " : "with at most ") +
value + " " + attributeDisplayName + (value != 1 ? "s" : "")
: "");
}
public final boolean isMatch(PsiElement value) {
if (!match) return true;
if (!(value instanceof PsiMethod)) return false;
PsiMethod method = (PsiMethod)value;
int n = MethodUtil.nofParameters(method);
if (opType == OP_GE) {
return n >= this.value;
}
else {
return n <= this.value;
}
}
public final void loadAttributes(final Element item) {
match = RearrangerSettings.getBooleanAttribute(item, "match", false);
// opType = RearrangerSettings.getIntAttribute(item, "opType", opType); -- never load opType, it is immutable
value = RearrangerSettings.getIntAttribute(item, "value", 0);
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/atomicAttributes/MaxParamsAttribute.java
-53
View File
@@ -1,53 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings.atomicAttributes;
import org.jdom.Element;
/** Common routines for 'maximum number of params' modifier. */
public class MaxParamsAttribute
extends IntegerAttribute
{
private static final String PROPNAME = "MAX_PARAMS";
// -------------------------- STATIC METHODS --------------------------
public static MaxParamsAttribute readExternal(final Element item) {
final MaxParamsAttribute result = new MaxParamsAttribute();
result.loadAttributes(item.getChild(PROPNAME));
return result;
}
// --------------------------- CONSTRUCTORS ---------------------------
public MaxParamsAttribute() {
super("parameter", PROPNAME, IntegerAttribute.OP_LE);
}
// -------------------------- OTHER METHODS --------------------------
public final /*AbstractAttribute*/AtomicAttribute deepCopy() {
final MaxParamsAttribute mpa = new MaxParamsAttribute();
mpa.value = value;
mpa.match = match;
return mpa;
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/atomicAttributes/MinParamsAttribute.java
-53
View File
@@ -1,53 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings.atomicAttributes;
import org.jdom.Element;
/** Common routines for 'minimum number of params' modifier. */
public class MinParamsAttribute
extends IntegerAttribute
{
private static final String PROPNAME = "MIN_PARAMS";
// -------------------------- STATIC METHODS --------------------------
public static MinParamsAttribute readExternal(final Element item) {
final MinParamsAttribute result = new MinParamsAttribute();
result.loadAttributes(item.getChild(PROPNAME));
return result;
}
// --------------------------- CONSTRUCTORS ---------------------------
public MinParamsAttribute() {
super("parameter", PROPNAME, IntegerAttribute.OP_GE);
}
// -------------------------- OTHER METHODS --------------------------
public final /*AbstractAttribute*/AtomicAttribute deepCopy() {
final MinParamsAttribute mpa = new MinParamsAttribute();
mpa.value = value;
mpa.match = match;
return mpa;
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/atomicAttributes/NameAttribute.java
-57
View File
@@ -1,57 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings.atomicAttributes;
import org.jdom.Element;
/** Allows item selection by matching its name to a regular expression. */
public final class NameAttribute extends StringAttribute {
// -------------------------- STATIC METHODS --------------------------
public static NameAttribute readExternal(final Element item) {
final NameAttribute result = new NameAttribute();
result.loadAttributes(item.getChild("NameMatch"));
return result;
}
// --------------------------- CONSTRUCTORS ---------------------------
public NameAttribute() {
super("names", "NameMatch");
}
// ------------------------ CANONICAL METHODS ------------------------
public final boolean equals(final Object object) {
if (!(object instanceof NameAttribute)) return false;
return super.equals(object);
}
// -------------------------- OTHER METHODS --------------------------
public final /*NameAttribute*/AtomicAttribute deepCopy() {
final NameAttribute result = new NameAttribute();
super.deepCopy(result);
return result;
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/atomicAttributes/NativeAttribute.java
-55
View File
@@ -1,55 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings.atomicAttributes;
import org.jdom.Element;
import java.lang.reflect.Modifier;
/** Handles the 'native' modifier. */
public final class NativeAttribute
extends AndNotAttribute
{
// -------------------------- STATIC METHODS --------------------------
public static NativeAttribute readExternal(final Element item) {
final NativeAttribute result = new NativeAttribute();
result.loadAttributes(item.getChild(result.getElementName()));
return result;
}
// --------------------------- CONSTRUCTORS ---------------------------
public NativeAttribute() {
super("native", Modifier.NATIVE);
}
// -------------------------- OTHER METHODS --------------------------
public final /*NativeAttribute*/AtomicAttribute deepCopy() {
final NativeAttribute result = new NativeAttribute();
result.value = value;
result.invert = invert;
return result;
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/atomicAttributes/OverriddenAttribute.java
-54
View File
@@ -1,54 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings.atomicAttributes;
import com.wrq.rearranger.ModifierConstants;
import org.jdom.Element;
public final class OverriddenAttribute
extends AndNotAttribute
{
// -------------------------- STATIC METHODS --------------------------
public static OverriddenAttribute readExternal(final Element item) {
final OverriddenAttribute result = new OverriddenAttribute();
result.loadAttributes(item.getChild(result.getElementName()));
return result;
}
// --------------------------- CONSTRUCTORS ---------------------------
public OverriddenAttribute() {
super("overridden", ModifierConstants.OVERRIDDEN);
}
// -------------------------- OTHER METHODS --------------------------
public final /*OverriddenAttribute*/AtomicAttribute deepCopy() {
final OverriddenAttribute result = new OverriddenAttribute();
result.value = value;
result.invert = invert;
return result;
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/atomicAttributes/OverridingAttribute.java
-53
View File
@@ -1,53 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings.atomicAttributes;
import com.wrq.rearranger.ModifierConstants;
import org.jdom.Element;
public final class OverridingAttribute
extends AndNotAttribute
{
// -------------------------- STATIC METHODS --------------------------
public static OverridingAttribute readExternal(final Element item) {
final OverridingAttribute result = new OverridingAttribute();
result.loadAttributes(item.getChild(result.getElementName()));
return result;
}
// --------------------------- CONSTRUCTORS ---------------------------
public OverridingAttribute() {
super("overriding", ModifierConstants.OVERRIDING);
}
// -------------------------- OTHER METHODS --------------------------
public final /*OverridingAttribute*/AtomicAttribute deepCopy() {
final OverridingAttribute result = new OverridingAttribute();
result.value = value;
result.invert = invert;
return result;
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/atomicAttributes/ProtectionLevelAttributes.java
-264
View File
@@ -1,264 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings.atomicAttributes;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.util.Constraints;
import org.jdom.Element;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.lang.reflect.Modifier;
/** Routines to handle the four protection level modifiers. */
public final class ProtectionLevelAttributes
extends AtomicAttribute
{
// ------------------------------ FIELDS ------------------------------
/** protection levels. */
private boolean plPublic;
private boolean plPrivate;
private boolean plProtected;
private boolean plPackage;
private boolean invertProtectionLevel;
// -------------------------- STATIC METHODS --------------------------
public static ProtectionLevelAttributes readExternal(final Element item) {
final ProtectionLevelAttributes result = new ProtectionLevelAttributes();
final Element me = item.getChild("ProtectionLevel");
result.loadAttributes(me);
return result;
}
private void loadAttributes(final Element me) {
plPublic = RearrangerSettings.getBooleanAttribute(me, "public");
plPrivate = RearrangerSettings.getBooleanAttribute(me, "private");
plProtected = RearrangerSettings.getBooleanAttribute(me, "protected");
plPackage = RearrangerSettings.getBooleanAttribute(me, "package");
invertProtectionLevel = RearrangerSettings.getBooleanAttribute(me, "invert");
}
// --------------------- GETTER / SETTER METHODS ---------------------
private boolean isInvertProtectionLevel() {
return invertProtectionLevel;
}
public final void setInvertProtectionLevel(final boolean invertProtectionLevel) {
this.invertProtectionLevel = invertProtectionLevel;
}
private boolean isPlPackage() {
return plPackage;
}
public final void setPlPackage(final boolean plPackage) {
this.plPackage = plPackage;
}
private boolean isPlPrivate() {
return plPrivate;
}
public void setPlPrivate(final boolean plPrivate) {
this.plPrivate = plPrivate;
}
private boolean isPlProtected() {
return plProtected;
}
public final void setPlProtected(final boolean plProtected) {
this.plProtected = plProtected;
}
private boolean isPlPublic() {
return plPublic;
}
public final void setPlPublic(final boolean plPublic) {
this.plPublic = plPublic;
}
// ------------------------ CANONICAL METHODS ------------------------
public boolean equals(final Object obj) {
if (!(obj instanceof ProtectionLevelAttributes)) return false;
final ProtectionLevelAttributes pla = (ProtectionLevelAttributes)obj;
return plPublic == pla.plPublic &&
plPrivate == pla.plPrivate &&
plProtected == pla.plProtected &&
plPackage == pla.plPackage &&
invertProtectionLevel == pla.invertProtectionLevel;
}
// -------------------------- OTHER METHODS --------------------------
public final void appendAttributes(final Element me) {
final Element plElement = new Element("ProtectionLevel");
me.getChildren().add(plElement);
plElement.setAttribute("public", Boolean.valueOf(plPublic).toString());
plElement.setAttribute("private", Boolean.valueOf(plPrivate).toString());
plElement.setAttribute("protected", Boolean.valueOf(plProtected).toString());
plElement.setAttribute("package", Boolean.valueOf(plPackage).toString());
plElement.setAttribute("invert", Boolean.valueOf(invertProtectionLevel).toString());
}
public final /*ProtectionLevelAttributes*/AtomicAttribute deepCopy() {
final ProtectionLevelAttributes pla = new ProtectionLevelAttributes();
pla.plPublic = plPublic;
pla.plPrivate = plPrivate;
pla.plProtected = plProtected;
pla.plPackage = plPackage;
pla.invertProtectionLevel = invertProtectionLevel;
return pla;
}
public final JPanel getProtectionLevelPanel() {
final JPanel plPanel = new JPanel(new GridBagLayout());
final Constraints constraints = new Constraints();
constraints.weightedLastRow();
constraints.fill = GridBagConstraints.BOTH;
final JCheckBox notBox = new JCheckBox("not");
notBox.setSelected(isInvertProtectionLevel());
notBox.setForeground(notBox.isSelected() ? Color.BLACK : Color.GRAY);
plPanel.add(notBox, constraints.firstCol());
final JPanel plLevels = getProtLevels();
plPanel.add(plLevels, constraints.weightedLastCol());
notBox.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
setInvertProtectionLevel(notBox.isSelected());
notBox.setForeground(notBox.isSelected() ? Color.BLACK : Color.GRAY);
}
});
return plPanel;
}
private JPanel getProtLevels() {
final JPanel plPanel = new JPanel(new GridBagLayout());
final Constraints constraints = new Constraints();
final JCheckBox publicBox = new JCheckBox("public or");
publicBox.setSelected(isPlPublic());
final JCheckBox privateBox = new JCheckBox("private or");
privateBox.setSelected(isPlPrivate());
final JCheckBox protectedBox = new JCheckBox("protected or");
protectedBox.setSelected(isPlProtected());
final JCheckBox packageBox = new JCheckBox("package");
packageBox.setSelected(isPlPackage());
plPanel.add(publicBox, constraints.weightedLastCol());
constraints.newRow();
plPanel.add(privateBox, constraints.weightedLastCol());
constraints.newRow();
plPanel.add(protectedBox, constraints.weightedLastCol());
constraints.weightedLastRow();
plPanel.add(packageBox, constraints.weightedLastCol());
publicBox.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
setPlPublic(publicBox.isSelected());
}
});
privateBox.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
setPlPrivate(privateBox.isSelected());
}
});
protectedBox.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
setPlProtected(protectedBox.isSelected());
}
});
packageBox.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
setPlPackage(packageBox.isSelected());
}
});
return plPanel;
}
public final String getProtectionLevelString() {
final StringBuffer sb = new StringBuffer(60);
final int nProtLevels = (isPlPublic() ? 1 : 0) +
(isPlPrivate() ? 1 : 0) +
(isPlProtected() ? 1 : 0) +
(isPlPackage() ? 1 : 0);
int nProtLevelsSeen = 0;
if (isPlPublic()) {
sb.append(isInvertProtectionLevel() ? "non-public" : "public");
nProtLevelsSeen++;
if (nProtLevelsSeen < nProtLevels) {
sb.append("/");
}
}
if (isPlPrivate()) {
sb.append(isInvertProtectionLevel() ? "non-private" : "private");
nProtLevelsSeen++;
if (nProtLevelsSeen < nProtLevels) {
sb.append("/");
}
}
if (isPlProtected()) {
sb.append(isInvertProtectionLevel() ? "non-protected" : "protected");
nProtLevelsSeen++;
if (nProtLevelsSeen < nProtLevels) {
sb.append("/");
}
}
if (isPlPackage()) {
sb.append(isInvertProtectionLevel() ? "non-package" : "package");
nProtLevelsSeen++;
if (nProtLevelsSeen < nProtLevels) {
sb.append("/");
}
}
if (nProtLevels > 0) {
sb.append(' ');
}
return sb.toString();
}
/**
* @param modifiers Java modifiers for the field, method or class.
* @return true if the supplied protection level modifiers match this object's modifier requirements.
*/
public final boolean isMatch(final int modifiers) {
boolean result;
if (!plPublic && !plPrivate && !plProtected && !plPackage) {
return true; // nothing selected, so don't take protection level into account.
}
result =
(plPublic && Modifier.isPublic(modifiers)) ||
(plPrivate && Modifier.isPrivate(modifiers)) ||
(plProtected && Modifier.isProtected(modifiers)) ||
(plPackage && !(Modifier.isPublic(modifiers) ||
Modifier.isPrivate(modifiers) ||
Modifier.isProtected(modifiers)));
result ^= invertProtectionLevel;
return result;
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/atomicAttributes/ReturnTypeAttribute.java
-57
View File
@@ -1,57 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings.atomicAttributes;
import org.jdom.Element;
/** Allows method selection by matching its return type to a regular expression. */
public final class ReturnTypeAttribute extends StringAttribute {
// -------------------------- STATIC METHODS --------------------------
public static ReturnTypeAttribute readExternal(final Element item) {
final ReturnTypeAttribute result = new ReturnTypeAttribute();
result.loadAttributes(item.getChild("ReturnTypeMatch"));
return result;
}
// --------------------------- CONSTRUCTORS ---------------------------
public ReturnTypeAttribute() {
super("return types", "ReturnTypeMatch");
}
// ------------------------ CANONICAL METHODS ------------------------
public final boolean equals(final Object object) {
if (!(object instanceof ReturnTypeAttribute)) return false;
return super.equals(object);
}
// -------------------------- OTHER METHODS --------------------------
public final /*ReturnTypeAttribute*/AtomicAttribute deepCopy() {
final ReturnTypeAttribute result = new ReturnTypeAttribute();
super.deepCopy(result);
return result;
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/atomicAttributes/SortOptions.java
-259
View File
@@ -1,259 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings.atomicAttributes;
import com.wrq.rearranger.entry.RangeEntry;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.util.Constraints;
import org.jdom.Element;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
/**
* Contains sorting attributes (part of common attributes; applies to fields, methods, inner and outer classes).
* <p/>
* Originally, methods and classes could only be sorted alphabetically by name (case sensitive). Fields could be
* sorted by type (optionally ignoring case), by name (case sensitive), or both.
* <p/>
* Beginning with release 4.4, all of these types (fields, methods and classes) can be sorted optionally by
* modifiers, optionally by type (optionally ignoring case), and by name (optionally ignoring case). This covers
* all permutations. Modifiers are always lower case so no need to ask about whether to ignore case.
*/
public class SortOptions
extends AtomicAttribute
{
private boolean byModifiers;
private boolean byType;
private boolean isTypeCaseInsensitive;
private boolean byName;
private boolean isNameCaseInsensitive;
public SortOptions() {
byModifiers = false;
byType = false;
isTypeCaseInsensitive = false;
byName = false;
isNameCaseInsensitive = false;
}
public boolean isByModifiers() {
return byModifiers;
}
public void setByModifiers(boolean byModifiers) {
this.byModifiers = byModifiers;
}
public boolean isByName() {
return byName;
}
public void setByName(boolean byName) {
this.byName = byName;
}
public boolean isByType() {
return byType;
}
public void setByType(boolean byType) {
this.byType = byType;
}
public boolean isNameCaseInsensitive() {
return isNameCaseInsensitive;
}
public void setNameCaseInsensitive(boolean nameCaseInsensitive) {
isNameCaseInsensitive = nameCaseInsensitive;
}
public boolean isTypeCaseInsensitive() {
return isTypeCaseInsensitive;
}
public void setTypeCaseInsensitive(boolean typeCaseInsensitive) {
isTypeCaseInsensitive = typeCaseInsensitive;
}
public final boolean equals(final Object obj) {
if (!(obj instanceof SortOptions)) return false;
SortOptions so = (SortOptions)obj;
return byModifiers == so.byModifiers &&
byType == so.byType &&
isTypeCaseInsensitive == so.isTypeCaseInsensitive &&
byName == so.byName &&
isNameCaseInsensitive == so.isNameCaseInsensitive;
}
public static SortOptions readExternal(final Element item) {
SortOptions result = new SortOptions();
final Element me = item.getChild("SortOptions");
result.loadAttributes(me);
// support old settings
result.byName |= RearrangerSettings.getBooleanAttribute(item, "alphabetize");
result.byType |= RearrangerSettings.getBooleanAttribute(item, "sortByType", false);
result.isTypeCaseInsensitive |= RearrangerSettings.getBooleanAttribute(item, "ignoreTypeCase", false);
return result;
}
private void loadAttributes(final Element me) {
byModifiers = RearrangerSettings.getBooleanAttribute(me, "byModifiers");
byType = RearrangerSettings.getBooleanAttribute(me, "byType");
isTypeCaseInsensitive = RearrangerSettings.getBooleanAttribute(me, "isTypeCaseInsensitive");
byName = RearrangerSettings.getBooleanAttribute(me, "byName");
isNameCaseInsensitive = RearrangerSettings.getBooleanAttribute(me, "isNameCaseInsensitive");
}
public final /*SortOptions*/ AtomicAttribute deepCopy() {
final SortOptions result = new SortOptions();
result.byModifiers = byModifiers;
result.byType = byType;
result.isTypeCaseInsensitive = isTypeCaseInsensitive;
result.byName = byName;
result.isNameCaseInsensitive = isNameCaseInsensitive;
return result;
}
public final void appendAttributes(final Element me) {
final Element plElement = new Element("SortOptions");
me.getChildren().add(plElement);
plElement.setAttribute("byModifiers", Boolean.valueOf(byModifiers).toString());
plElement.setAttribute("byType", Boolean.valueOf(byType).toString());
plElement.setAttribute("isTypeCaseInsensitive", Boolean.valueOf(isTypeCaseInsensitive).toString());
plElement.setAttribute("byName", Boolean.valueOf(byName).toString());
plElement.setAttribute("isNameCaseInsensitive", Boolean.valueOf(isNameCaseInsensitive).toString());
}
public final String getDescriptiveString() {
StringBuilder sb = new StringBuilder(80);
if (byName && !isNameCaseInsensitive && !byModifiers && !byType) {
return " (alphabetized)";
}
if (byModifiers || byType || byName) {
sb.append(" (sorted by");
boolean needComma = false;
if (byModifiers) {
sb.append(" modifiers");
needComma = true;
}
if (byType) {
if (needComma) {
sb.append(',');
}
sb.append(" type");
if (isTypeCaseInsensitive) {
sb.append("(CI)");
}
needComma = true;
}
if (byName) {
if (needComma) {
sb.append(',');
}
sb.append(" name");
if (isNameCaseInsensitive) {
sb.append("(CI)");
}
}
sb.append(")");
}
return sb.toString();
}
public final JPanel getSortOptionsPanel() {
final JPanel abPanel = new JPanel(new GridBagLayout());
final Constraints constraints = new Constraints();
final JLabel sortLabel = new JLabel("Sort");
constraints.insets = new Insets(0, 5, 0, 5);
abPanel.add(sortLabel, constraints.firstCol());
final JCheckBox byModifiersBox = new JCheckBox("by modifiers");
final JCheckBox byTypeBox = new JCheckBox("by type");
final JCheckBox typeCIBox = new JCheckBox("case insensitive");
final JCheckBox byNameBox = new JCheckBox("by name");
final JCheckBox nameCIBox = new JCheckBox("case insensitive");
constraints.insets = new Insets(0, 0, 0, 0);
abPanel.add(byModifiersBox, constraints.weightedLastCol());
constraints.newRow();
constraints.nextCol();
abPanel.add(byTypeBox, constraints.nextCol());
abPanel.add(typeCIBox, constraints.weightedLastCol());
constraints.weightedLastRow();
constraints.nextCol();
abPanel.add(byNameBox, constraints.nextCol());
abPanel.add(nameCIBox, constraints.weightedLastCol());
byModifiersBox.setSelected(isByModifiers());
byTypeBox.setSelected(isByType());
typeCIBox.setSelected(isTypeCaseInsensitive());
byNameBox.setSelected(isByName());
nameCIBox.setSelected(isNameCaseInsensitive());
byModifiersBox.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
setByModifiers(byModifiersBox.isSelected());
}
});
byTypeBox.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
setByType(byTypeBox.isSelected());
}
});
typeCIBox.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
setTypeCaseInsensitive(typeCIBox.isSelected());
}
});
byNameBox.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
setByName(byNameBox.isSelected());
}
});
nameCIBox.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
setNameCaseInsensitive(nameCIBox.isSelected());
}
});
return abPanel;
}
public String generateSortString(RangeEntry entry) {
String modifiers = entry.getModifierString();
String type = entry.getType();
String name = entry.getName();
StringBuilder sb = new StringBuilder(modifiers.length() + type.length() + name.length());
if (byModifiers) {
sb.append(modifiers);
}
if (byType) {
sb.append(isTypeCaseInsensitive ? type.toLowerCase() : type);
}
if (byName) {
sb.append(isNameCaseInsensitive ? name.toLowerCase() : name);
}
return sb.toString();
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/atomicAttributes/StaticAttribute.java
-53
View File
@@ -1,53 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings.atomicAttributes;
import org.jdom.Element;
import java.lang.reflect.Modifier;
/** Routines to handle the 'static' modifier. */
public final class StaticAttribute extends AndNotAttribute {
// -------------------------- STATIC METHODS --------------------------
public static StaticAttribute readExternal(final Element item) {
final StaticAttribute result = new StaticAttribute();
result.loadAttributes(item.getChild(result.getElementName()));
return result;
}
// --------------------------- CONSTRUCTORS ---------------------------
public StaticAttribute() {
super("static", Modifier.STATIC);
}
// -------------------------- OTHER METHODS --------------------------
public final /*StaticAttribute*/AtomicAttribute deepCopy() {
final StaticAttribute result = new StaticAttribute();
result.value = value;
result.invert = invert;
return result;
}
}
plugins/rearranger/src/com/wrq/rearranger/settings/atomicAttributes/StringAttribute.java
-171
View File
@@ -1,171 +0,0 @@
/*
* Copyright (c) 2003, 2010, Dave Kriewall
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wrq.rearranger.settings.atomicAttributes;
import com.wrq.rearranger.settings.RearrangerSettings;
import com.wrq.rearranger.util.Constraints;
import org.jdom.Attribute;
import org.jdom.Element;
import javax.swing.*;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
/** Allows item selection by matching a string attribute to a regular expression. */
abstract public class StringAttribute extends AtomicAttribute {
// ------------------------------ FIELDS ------------------------------
private String expression;
private boolean match;
private boolean invert;
private final String attributeDisplayName; // should be plural
private final String storageName;
// --------------------------- CONSTRUCTORS ---------------------------
StringAttribute(String attributeDisplayName, String storageName) {
this.attributeDisplayName = attributeDisplayName;
this.storageName = storageName;
}
// --------------------- GETTER / SETTER METHODS ---------------------
public final String getExpression() {
return expression;
}
public final void setExpression(final String expression) {
this.expression = expression;
}
public final JPanel getStringPanel() {
final JPanel stringPanel = new JPanel(new GridBagLayout());
final Constraints constraints = new Constraints();
constraints.weightedLastRow();
final JCheckBox enableBox = new JCheckBox("whose " + attributeDisplayName);
stringPanel.add(enableBox, constraints.firstCol());
final JComboBox invertBox = new JComboBox(new Object[]{"match", "do not match"});
invertBox.setSelectedIndex(isInvert() ? 1 : 0);
final JTextField patternField = new JTextField(20);
stringPanel.add(invertBox, constraints.nextCol());
stringPanel.add(patternField, constraints.weightedLastCol());
enableBox.setSelected(isMatch());
invertBox.setEnabled(isMatch());
patternField.setEnabled(isMatch());
patternField.setText(getExpression());
enableBox.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
setMatch(enableBox.isSelected());
invertBox.setEnabled(enableBox.isSelected());
patternField.setEnabled(enableBox.isSelected());
}
});
invertBox.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
setInvert(invertBox.getSelectedIndex() == 1);
}
});
patternField.getDocument().addDocumentListener(new DocumentListener() {
public void changedUpdate(final DocumentEvent e) {
setExpression(patternField.getText());
}
public void insertUpdate(final DocumentEvent e) {
setExpression(patternField.getText());
}
public void removeUpdate(final DocumentEvent e) {
setExpression(patternField.getText());
}
});
return stringPanel;
}
public final boolean isInvert() {
return invert;
}
private void setInvert(final boolean invert) {
this.invert = invert;
}
public final boolean isMatch() {
return match;
}
public final void setMatch(final boolean match) {
this.match = match;
}
// ------------------------ CANONICAL METHODS ------------------------
public boolean equals(final Object object) {
if (!(object instanceof StringAttribute)) return false;
final StringAttribute na = (StringAttribute)object;
return match == na.match &&
(expression == null || na.expression == null ?
expression == null && na.expression == null : expression.equals(na.expression)) &&
invert == na.invert;
}
// -------------------------- OTHER METHODS --------------------------
public final void appendAttributes(final Element me) {
final Element stElement = new Element(storageName);
if (expression == null) {
expression = "";
}
me.getChildren().add(stElement);
stElement.setAttribute("match", Boolean.valueOf(match).toString());
stElement.setAttribute("invert", Boolean.valueOf(invert).toString());
stElement.setAttribute("pattern", expression);
}
protected final void deepCopy(StringAttribute result) {
result.match = match;
result.expression = expression;
result.invert = invert;
}
public final String getDescriptiveString() {
return (match ? "whose " +
attributeDisplayName +
(invert ? " do not match '" : " match '") +
expression + "'"
: "");
}
public final boolean isMatch(final String string) {
return !match || string.matches(expression) ^ invert;
}
public final void loadAttributes(final Element item) {
match = RearrangerSettings.getBooleanAttribute(item, "match", false);
invert = RearrangerSettings.getBooleanAttribute(item, "invert", false);
final Attribute attr = RearrangerSettings.getAttribute(item, "pattern");
expression = (attr == null ? "" : ((java.lang.String)attr.getValue()));
}
}

Some files were not shown because too many files have changed in this diff Show More