+ * This method is useful for capturing screenshots. This method can be called from a thread other than the EDT. + *
+ * + * @param g The graphics context on which to draw the map; must not be {@code null}. + */ + public void drawMapImage(final Graphics g) { + final Graphics2D g2d = (Graphics2D) checkNotNull(g); // make sure we use the same data for the entire print final GameData gameData = m_data; final Rectangle2D.Double bounds = new Rectangle2D.Double(0, 0, getImageWidth(), getImageHeight()); diff --git a/src/games/strategy/triplea/ui/TripleAFrame.java b/src/games/strategy/triplea/ui/TripleAFrame.java index 697682f29db..ac4eba39f1c 100644 --- a/src/games/strategy/triplea/ui/TripleAFrame.java +++ b/src/games/strategy/triplea/ui/TripleAFrame.java @@ -140,10 +140,10 @@ import games.strategy.triplea.formatter.MyFormatter; import games.strategy.triplea.image.TileImageFactory; import games.strategy.triplea.settings.scrolling.ScrollSettings; +import games.strategy.triplea.ui.export.ScreenshotExporter; import games.strategy.triplea.ui.history.HistoryDetailsPanel; import games.strategy.triplea.ui.history.HistoryLog; import games.strategy.triplea.ui.history.HistoryPanel; -import games.strategy.triplea.ui.menubar.ExportMenu; import games.strategy.triplea.ui.menubar.HelpMenu; import games.strategy.triplea.ui.menubar.TripleAMenuBar; import games.strategy.triplea.ui.screen.UnitsDrawer; @@ -1735,7 +1735,7 @@ public void actionPerformed(final ActionEvent ae) { @Override public void actionPerformed(final ActionEvent ae) { - ExportMenu.saveScreenshot(historyPanel.getCurrentPopupNode(), TripleAFrame.this, data); + ScreenshotExporter.exportScreenshot(TripleAFrame.this, data, historyPanel.getCurrentPopupNode()); historyPanel.clearCurrentPopupNode(); } }); diff --git a/src/games/strategy/triplea/ui/export/ScreenshotExporter.java b/src/games/strategy/triplea/ui/export/ScreenshotExporter.java new file mode 100644 index 00000000000..ea7f3c7f817 --- /dev/null +++ b/src/games/strategy/triplea/ui/export/ScreenshotExporter.java @@ -0,0 +1,137 @@ +package games.strategy.triplea.ui.export; + +import static com.google.common.base.Preconditions.checkNotNull; + +import java.awt.Color; +import java.awt.Font; +import java.awt.Graphics2D; +import java.awt.geom.AffineTransform; +import java.awt.image.BufferedImage; +import java.io.File; +import java.io.IOException; +import java.util.Optional; + +import javax.imageio.ImageIO; +import javax.swing.JOptionPane; +import javax.swing.SwingUtilities; + +import games.strategy.engine.data.GameData; +import games.strategy.engine.history.HistoryNode; +import games.strategy.engine.history.Round; +import games.strategy.triplea.ui.IUIContext; +import games.strategy.triplea.ui.MapPanel; +import games.strategy.triplea.ui.TripleAFrame; +import games.strategy.triplea.ui.mapdata.MapData; +import games.strategy.ui.SwingComponents; +import games.strategy.ui.Util; + +public final class ScreenshotExporter { + private final TripleAFrame frame; + + private ScreenshotExporter(final TripleAFrame frame) { + this.frame = frame; + } + + /** + * Prompts the user for the file to which the screenshot will be saved and saves the screenshot for the specified game + * at the specified history step to that file. + * + * @param frame The frame associated with the game screenshot to export; must not be {@code null}. + * @param gameData The game data; must not be {@code null}. + * @param node The history step at which the game screenshot is to be captured; must not be {@code null}. + */ + public static void exportScreenshot(final TripleAFrame frame, final GameData gameData, final HistoryNode node) { + checkNotNull(frame); + checkNotNull(gameData); + checkNotNull(node); + + final ScreenshotExporter exporter = new ScreenshotExporter(frame); + exporter.promptSaveFile().ifPresent(file -> exporter.runSave(gameData, node, file)); + } + + private Optional+ * The user will be asked to confirm the save if the selected file already exists. + *
+ * + * @param parent Determines the {@code Frame} in which the dialog is displayed; if {@code null}, or if {@code parent} + * has no {@code Frame}, a default {@code Frame} is used. + * @param fileExtension The extension of the file to save, with or without a leading period; must not be {@code null}. + * This extension will be automatically appended to the file name if not present. + * @param fileExtensionDescription The description of the file extension to be displayed in the file chooser; must not + * be {@code null}. + * + * @return The file selected by the user or empty if the user aborted the save; never {@code null}. + */ + public static Optional+ * Use this class when it is necessary to display progress during a potentially long-running operation. If the Event + * Dispatch Thread must be blocked until the operation is complete (i.e. the user should not be allowed to perform + * any other actions in the UI), it is recommended you use a modal dialog. + *
+ * + *+ * For example: + *
+ * + *+ * JDialog dialog = new JDialog(owner, true); + * swingWorker.addPropertyChangeListener( + * new SwingWorkerCompletionWaiter(dialog)); + * swingWorker.execute(); + * // the dialog will be visible between the + * // SwingWorker STARTED and DONE states + *+ */ +public final class SwingWorkerCompletionWaiter implements PropertyChangeListener { + static final String SWING_WORKER_STATE_PROPERTY_NAME = "state"; + + private final ProgressWindow progressWindow; + + /** + * Initializes a new instance of the {@code SwingWorkerCompletionWaiter} class. + * + * @param window The window to display while the operation is in progress; must not be {@code null}. + */ + public SwingWorkerCompletionWaiter(final Window window) { + this.progressWindow = ProgressWindow.fromWindow(checkNotNull(window)); + } + + @VisibleForTesting + SwingWorkerCompletionWaiter(final ProgressWindow progressWindow) { + this.progressWindow = progressWindow; + } + + @Override + public void propertyChange(final PropertyChangeEvent event) { + if (SWING_WORKER_STATE_PROPERTY_NAME.equals(event.getPropertyName())) { + if (SwingWorker.StateValue.STARTED == event.getNewValue()) { + progressWindow.open(); + } else if (SwingWorker.StateValue.DONE == event.getNewValue()) { + progressWindow.close(); + } + } + } + + @VisibleForTesting + static interface ProgressWindow { + void close(); + + void open(); + + static ProgressWindow fromWindow(final Window window) { + return new ProgressWindow() { + @Override + public void close() { + window.setVisible(false); + window.dispose(); + } + + @Override + public void open() { + window.setVisible(true); + } + }; + } + } +} diff --git a/test/games/strategy/ui/SwingComponentsTest.java b/test/games/strategy/ui/SwingComponentsTest.java new file mode 100644 index 00000000000..30d901ac548 --- /dev/null +++ b/test/games/strategy/ui/SwingComponentsTest.java @@ -0,0 +1,68 @@ +package games.strategy.ui; + +import static games.strategy.ui.SwingComponents.appendExtensionIfAbsent; +import static games.strategy.ui.SwingComponents.extensionWithLeadingPeriod; +import static games.strategy.ui.SwingComponents.extensionWithoutLeadingPeriod; +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertThat; + +import java.io.File; + +import org.junit.Test; + +public final class SwingComponentsTest { + @Test + public void testAppendExtensionIfAbsent_ShouldAppendExtensionWhenExtensionAbsent() { + assertThat(appendExtensionIfAbsent(new File("path/file.aaa"), "bbb"), is(new File("path/file.aaa.bbb"))); + assertThat(appendExtensionIfAbsent(new File("path/filebbb"), "bbb"), is(new File("path/filebbb.bbb"))); + } + + @Test + public void testAppendExtensionIfAbsent_ShouldNotAppendExtensionWhenExtensionPresent() { + assertThat(appendExtensionIfAbsent(new File("path/file.bbb"), "bbb"), is(new File("path/file.bbb"))); + } + + @Test + public void testAppendExtensionIfAbsent_ShouldHandleExtensionThatStartsWithPeriod() { + assertThat(appendExtensionIfAbsent(new File("path/file.aaa"), ".bbb"), is(new File("path/file.aaa.bbb"))); + } + + @Test + public void testAppendExtensionIfAbsent_ShouldUseCaseInsensitiveComparisonForExtension() { + assertThat(appendExtensionIfAbsent(new File("path/file.bBb"), "BbB"), is(new File("path/file.bBb"))); + } + + @Test + public void testExtensionWithLeadingPeriod() { + assertThat(extensionWithLeadingPeriod(""), is("")); + + assertThat(extensionWithLeadingPeriod("a"), is(".a")); + assertThat(extensionWithLeadingPeriod(".a"), is(".a")); + + assertThat(extensionWithLeadingPeriod("aa"), is(".aa")); + assertThat(extensionWithLeadingPeriod(".aa"), is(".aa")); + + assertThat(extensionWithLeadingPeriod("aaa"), is(".aaa")); + assertThat(extensionWithLeadingPeriod(".aaa"), is(".aaa")); + + assertThat(extensionWithLeadingPeriod("aaa.aaa"), is(".aaa.aaa")); + assertThat(extensionWithLeadingPeriod(".aaa.aaa"), is(".aaa.aaa")); + } + + @Test + public void testExtensionWithoutLeadingPeriod() { + assertThat(extensionWithoutLeadingPeriod(""), is("")); + + assertThat(extensionWithoutLeadingPeriod("a"), is("a")); + assertThat(extensionWithoutLeadingPeriod(".a"), is("a")); + + assertThat(extensionWithoutLeadingPeriod("aa"), is("aa")); + assertThat(extensionWithoutLeadingPeriod(".aa"), is("aa")); + + assertThat(extensionWithoutLeadingPeriod("aaa"), is("aaa")); + assertThat(extensionWithoutLeadingPeriod(".aaa"), is("aaa")); + + assertThat(extensionWithoutLeadingPeriod("aaa.aaa"), is("aaa.aaa")); + assertThat(extensionWithoutLeadingPeriod(".aaa.aaa"), is("aaa.aaa")); + } +} diff --git a/test/games/strategy/ui/SwingWorkerCompletionWaiterTest.java b/test/games/strategy/ui/SwingWorkerCompletionWaiterTest.java new file mode 100644 index 00000000000..abbf3e543ef --- /dev/null +++ b/test/games/strategy/ui/SwingWorkerCompletionWaiterTest.java @@ -0,0 +1,44 @@ +package games.strategy.ui; + +import static org.mockito.Mockito.verify; + +import java.beans.PropertyChangeEvent; + +import javax.swing.SwingWorker; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.runners.MockitoJUnitRunner; + +@RunWith(MockitoJUnitRunner.class) +public final class SwingWorkerCompletionWaiterTest { + @InjectMocks + private SwingWorkerCompletionWaiter waiter; + + @Mock + private SwingWorkerCompletionWaiter.ProgressWindow progressWindow; + + @Test + public void testShouldOpenProgressWindowWhenWorkerStarted() { + waiter.propertyChange(newSwingWorkerStateEvent(SwingWorker.StateValue.STARTED)); + + verify(progressWindow).open(); + } + + @Test + public void testShouldCloseProgressWindowWhenWorkerDone() { + waiter.propertyChange(newSwingWorkerStateEvent(SwingWorker.StateValue.DONE)); + + verify(progressWindow).close(); + } + + private static PropertyChangeEvent newSwingWorkerStateEvent(final SwingWorker.StateValue stateValue) { + return new PropertyChangeEvent( + new Object(), + SwingWorkerCompletionWaiter.SWING_WORKER_STATE_PROPERTY_NAME, + null, + stateValue); + } +}