org.optaplanner.examples.common.swingui.SolverAndPersistenceFrame Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of optaplanner-examples Show documentation
Show all versions of optaplanner-examples Show documentation
OptaPlanner solves planning problems.
This lightweight, embeddable planning engine implements powerful and scalable algorithms
to optimize business resource scheduling and planning.
This module contains the examples which demonstrate how to use it in a normal Java application.
/*
* Copyright 2010 JBoss Inc
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.optaplanner.examples.common.swingui;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.BorderFactory;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JComponent;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JProgressBar;
import javax.swing.JScrollPane;
import javax.swing.SwingUtilities;
import javax.swing.filechooser.FileFilter;
import org.optaplanner.core.impl.solution.Solution;
import org.optaplanner.examples.common.business.SolutionBusiness;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SolverAndPersistenceFrame extends JFrame {
protected final transient Logger logger = LoggerFactory.getLogger(getClass());
public static final ImageIcon OPTA_PLANNER_ICON = new ImageIcon(
SolverAndPersistenceFrame.class.getResource("optaPlannerIcon.png"));
private SolutionBusiness solutionBusiness;
private SolutionPanel solutionPanel;
private ConstraintMatchesDialog constraintMatchesDialog;
private List loadUnsolvedActionList;
private List loadSolvedActionList;
private Action terminateSolvingEarlyAction;
private JCheckBox refreshScreenDuringSolvingCheckBox;
private Action solveAction;
private Action openAction;
private Action saveAction;
private Action importAction;
private Action exportAction;
private JProgressBar progressBar;
private JLabel resultLabel;
private ShowConstraintMatchesDialogAction showConstraintMatchesDialogAction;
public SolverAndPersistenceFrame(SolutionBusiness solutionBusiness, SolutionPanel solutionPanel, String exampleName) {
super(exampleName + " OptaPlanner example");
setIconImage(OPTA_PLANNER_ICON.getImage());
this.solutionBusiness = solutionBusiness;
this.solutionPanel = solutionPanel;
solutionPanel.setSolutionBusiness(solutionBusiness);
solutionPanel.setSolverAndPersistenceFrame(this);
registerListeners();
constraintMatchesDialog = new ConstraintMatchesDialog(this);
constraintMatchesDialog.setSolutionBusiness(solutionBusiness);
}
private void registerListeners() {
solutionBusiness.registerForBestSolutionChanges(this);
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
// This async, so it doesn't stop the solving immediately
solutionBusiness.terminateSolvingEarly();
}
});
}
public void bestSolutionChanged() {
Solution solution = solutionBusiness.getSolution();
if (refreshScreenDuringSolvingCheckBox.isSelected()) {
solutionPanel.updatePanel(solution);
validate(); // TODO remove me?
}
resultLabel.setText("Latest best score: " + solution.getScore());
}
public void init(Component centerForComponent) {
setContentPane(createContentPane());
pack();
setLocationRelativeTo(centerForComponent);
}
private JPanel createContentPane() {
JPanel panel = new JPanel(new BorderLayout());
panel.add(createButtonPanel(), BorderLayout.NORTH);
if (solutionPanel.isWrapInScrollPane()) {
JScrollPane solutionScrollPane = new JScrollPane(solutionPanel);
panel.add(solutionScrollPane, BorderLayout.CENTER);
} else {
panel.add(solutionPanel, BorderLayout.CENTER);
}
panel.add(createScorePanel(), BorderLayout.SOUTH);
return panel;
}
private JPanel createButtonPanel() {
JPanel panel = new JPanel(new GridLayout(1, 0));
panel.add(createLoadUnsolvedPanel());
panel.add(createLoadSolvedPanel());
panel.add(createProcessingPanel());
return panel;
}
private JComponent createLoadUnsolvedPanel() {
loadUnsolvedActionList = new ArrayList();
JPanel panel = new JPanel(new GridLayout(0, 1));
for (File file : solutionBusiness.getUnsolvedFileList()) {
Action loadUnsolvedAction = new LoadAction(file);
loadUnsolvedActionList.add(loadUnsolvedAction);
panel.add(new JButton(loadUnsolvedAction));
}
JScrollPane scrollPane = new JScrollPane(panel);
scrollPane.getVerticalScrollBar().setUnitIncrement(25);
scrollPane.setPreferredSize(new Dimension(250, 200));
return scrollPane;
}
private JComponent createLoadSolvedPanel() {
loadSolvedActionList = new ArrayList();
JPanel panel = new JPanel(new GridLayout(0, 1));
for (File file : solutionBusiness.getSolvedFileList()) {
Action loadSolvedAction = new LoadAction(file);
loadSolvedActionList.add(loadSolvedAction);
panel.add(new JButton(loadSolvedAction));
}
JScrollPane scrollPane = new JScrollPane(panel);
scrollPane.getVerticalScrollBar().setUnitIncrement(25);
scrollPane.setPreferredSize(new Dimension(250, 200));
return scrollPane;
}
private class LoadAction extends AbstractAction {
private File file;
public LoadAction(File file) {
super("Load " + file.getName());
this.file = file;
}
public void actionPerformed(ActionEvent e) {
setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
try {
solutionBusiness.openSolution(file);
setSolutionLoaded();
} finally {
setCursor(Cursor.getDefaultCursor());
}
}
}
private JComponent createProcessingPanel() {
JPanel panel = new JPanel(new GridLayout(0, 1));
solveAction = new SolveAction();
solveAction.setEnabled(false);
panel.add(new JButton(solveAction));
terminateSolvingEarlyAction = new TerminateSolvingEarlyAction();
terminateSolvingEarlyAction.setEnabled(false);
panel.add(new JButton(terminateSolvingEarlyAction));
refreshScreenDuringSolvingCheckBox = new JCheckBox("Refresh screen during solving",
solutionPanel.isRefreshScreenDuringSolving());
panel.add(refreshScreenDuringSolvingCheckBox);
openAction = new OpenAction();
openAction.setEnabled(true);
panel.add(new JButton(openAction));
saveAction = new SaveAction();
saveAction.setEnabled(false);
panel.add(new JButton(saveAction));
importAction = new ImportAction();
importAction.setEnabled(solutionBusiness.hasImporter());
panel.add(new JButton(importAction));
exportAction = new ExportAction();
exportAction.setEnabled(false);
panel.add(new JButton(exportAction));
return panel;
}
private class SolveAction extends AbstractAction {
// TODO This should be replaced with a java 6 SwingWorker once drools's hudson is on JDK 1.6
private ExecutorService solvingExecutor = Executors.newFixedThreadPool(1);
public SolveAction() {
super("Solve", new ImageIcon(SolverAndPersistenceFrame.class.getResource("solveAction.png")));
}
public void actionPerformed(ActionEvent e) {
setSolvingState(true);
final Solution planningProblem = solutionBusiness.getSolution(); // In event thread
// TODO This should be replaced with a java 6 SwingWorker once drools's hudson is on JDK 1.6
solvingExecutor.submit(new Runnable() {
public void run() {
Solution bestSolution;
try {
bestSolution = solutionBusiness.solve(planningProblem); // Not in event thread
} catch (final Throwable e) {
// Otherwise the newFixedThreadPool will eat the exception...
logger.error("Solving failed.", e);
bestSolution = null;
}
final Solution newSolution = bestSolution;
SwingUtilities.invokeLater(new Runnable() {
public void run() {
if (newSolution != null) {
solutionBusiness.setSolution(newSolution); // In event thread
}
setSolvingState(false);
resetScreen();
}
});
}
});
}
}
private class TerminateSolvingEarlyAction extends AbstractAction {
public TerminateSolvingEarlyAction() {
super("Terminate solving early");
}
public void actionPerformed(ActionEvent e) {
// This async, so it doesn't stop the solving immediately
solutionBusiness.terminateSolvingEarly();
}
}
private class OpenAction extends AbstractAction {
private static final String NAME = "Open...";
public OpenAction() {
super(NAME);
}
public void actionPerformed(ActionEvent e) {
JFileChooser fileChooser = new JFileChooser(solutionBusiness.getUnsolvedDataDir());
fileChooser.setFileFilter(new FileFilter() {
public boolean accept(File file) {
return file.isDirectory() || file.getName().endsWith(".xml");
}
public String getDescription() {
return "Solver xml files";
}
});
fileChooser.setDialogTitle(NAME);
int approved = fileChooser.showOpenDialog(SolverAndPersistenceFrame.this);
if (approved == JFileChooser.APPROVE_OPTION) {
setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
try {
solutionBusiness.openSolution(fileChooser.getSelectedFile());
setSolutionLoaded();
} finally {
setCursor(Cursor.getDefaultCursor());
}
}
}
}
private class SaveAction extends AbstractAction {
private static final String NAME = "Save as...";
public SaveAction() {
super(NAME);
}
public void actionPerformed(ActionEvent e) {
JFileChooser fileChooser = new JFileChooser(solutionBusiness.getSolvedDataDir());
fileChooser.setFileFilter(new FileFilter() {
public boolean accept(File file) {
return file.isDirectory() || file.getName().endsWith(".xml");
}
public String getDescription() {
return "Solver xml files";
}
});
fileChooser.setDialogTitle(NAME);
int approved = fileChooser.showSaveDialog(SolverAndPersistenceFrame.this);
if (approved == JFileChooser.APPROVE_OPTION) {
setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
try {
solutionBusiness.saveSolution(fileChooser.getSelectedFile());
} finally {
setCursor(Cursor.getDefaultCursor());
}
}
}
}
private class ImportAction extends AbstractAction {
private static final String NAME = "Import...";
public ImportAction() {
super(NAME);
}
public void actionPerformed(ActionEvent e) {
JFileChooser fileChooser = new JFileChooser(solutionBusiness.getImportDataDir());
fileChooser.setFileFilter(new FileFilter() {
public boolean accept(File file) {
return file.isDirectory() || solutionBusiness.acceptImportFile(file);
}
public String getDescription() {
return "Import files (*" + solutionBusiness.getImportFileSuffix() + ")";
}
});
fileChooser.setDialogTitle(NAME);
int approved = fileChooser.showOpenDialog(SolverAndPersistenceFrame.this);
if (approved == JFileChooser.APPROVE_OPTION) {
setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
try {
solutionBusiness.importSolution(fileChooser.getSelectedFile());
setSolutionLoaded();
} finally {
setCursor(Cursor.getDefaultCursor());
}
}
}
}
private class ExportAction extends AbstractAction {
private static final String NAME = "Export as...";
public ExportAction() {
super(NAME);
}
public void actionPerformed(ActionEvent e) {
JFileChooser fileChooser = new JFileChooser(solutionBusiness.getExportDataDir());
// fileChooser.setFileFilter(new FileFilter() {
// public boolean accept(File file) {
// return file.isDirectory() || file.getName().endsWith(".xml"); // TODO Not all export files are xml
// }
// public String getDescription() {
// return "Export files";
// }
// });
fileChooser.setDialogTitle(NAME);
int approved = fileChooser.showSaveDialog(SolverAndPersistenceFrame.this);
if (approved == JFileChooser.APPROVE_OPTION) {
setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
try {
solutionBusiness.exportSolution(fileChooser.getSelectedFile());
} finally {
setCursor(Cursor.getDefaultCursor());
}
}
}
}
private JPanel createScorePanel() {
JPanel panel = new JPanel(new BorderLayout());
progressBar = new JProgressBar(0, 100);
panel.add(progressBar, BorderLayout.WEST);
resultLabel = new JLabel("Please load a data set and then click the solve button.");
resultLabel.setBorder(BorderFactory.createLoweredBevelBorder());
panel.add(resultLabel, BorderLayout.CENTER);
showConstraintMatchesDialogAction = new ShowConstraintMatchesDialogAction();
showConstraintMatchesDialogAction.setEnabled(false);
JButton constraintScoreMapButton = new JButton(showConstraintMatchesDialogAction);
panel.add(constraintScoreMapButton, BorderLayout.EAST);
return panel;
}
private class ShowConstraintMatchesDialogAction extends AbstractAction {
public ShowConstraintMatchesDialogAction() {
super("Constraint matches");
}
public void actionPerformed(ActionEvent e) {
constraintMatchesDialog.resetContentPanel();
constraintMatchesDialog.setVisible(true);
}
}
private void setSolutionLoaded() {
solveAction.setEnabled(true);
saveAction.setEnabled(true);
exportAction.setEnabled(solutionBusiness.hasExporter());
showConstraintMatchesDialogAction.setEnabled(true);
resetScreen();
}
private void setSolvingState(boolean solving) {
for (Action action : loadUnsolvedActionList) {
action.setEnabled(!solving);
}
for (Action action : loadSolvedActionList) {
action.setEnabled(!solving);
}
solveAction.setEnabled(!solving);
terminateSolvingEarlyAction.setEnabled(solving);
openAction.setEnabled(!solving);
saveAction.setEnabled(!solving);
importAction.setEnabled(!solving && solutionBusiness.hasImporter());
exportAction.setEnabled(!solving && solutionBusiness.hasExporter());
solutionPanel.setEnabled(!solving);
progressBar.setIndeterminate(solving);
progressBar.setStringPainted(solving);
progressBar.setString(solving ? "Solving..." : null);
showConstraintMatchesDialogAction.setEnabled(!solving);
solutionPanel.setSolvingState(solving);
}
public void resetScreen() {
solutionPanel.resetPanel(solutionBusiness.getSolution());
validate();
resultLabel.setText("Score: " + solutionBusiness.getScore());
}
}