001// License: GPL. For details, see LICENSE file.
002package org.openstreetmap.josm.gui.layer.geoimage;
003
004import static org.openstreetmap.josm.tools.I18n.marktr;
005import static org.openstreetmap.josm.tools.I18n.tr;
006import static org.openstreetmap.josm.tools.I18n.trn;
007
008import java.awt.BorderLayout;
009import java.awt.Component;
010import java.awt.Dimension;
011import java.awt.GridBagConstraints;
012import java.awt.GridBagLayout;
013import java.awt.event.ActionEvent;
014import java.awt.event.ActionListener;
015import java.awt.event.KeyEvent;
016import java.awt.event.WindowEvent;
017import java.beans.PropertyChangeEvent;
018import java.beans.PropertyChangeListener;
019import java.io.IOException;
020import java.io.Serializable;
021import java.time.ZoneOffset;
022import java.time.format.DateTimeFormatter;
023import java.time.format.FormatStyle;
024import java.util.ArrayList;
025import java.util.Arrays;
026import java.util.Collections;
027import java.util.Comparator;
028import java.util.List;
029import java.util.Objects;
030import java.util.Optional;
031import java.util.concurrent.Future;
032import java.util.function.UnaryOperator;
033import java.util.stream.Collectors;
034import java.util.stream.IntStream;
035import java.util.stream.Stream;
036
037import javax.swing.AbstractAction;
038import javax.swing.AbstractButton;
039import javax.swing.BorderFactory;
040import javax.swing.Box;
041import javax.swing.JButton;
042import javax.swing.JLabel;
043import javax.swing.JOptionPane;
044import javax.swing.JPanel;
045import javax.swing.JTabbedPane;
046import javax.swing.JToggleButton;
047import javax.swing.SwingConstants;
048import javax.swing.SwingUtilities;
049
050import org.openstreetmap.josm.actions.ExpertToggleAction;
051import org.openstreetmap.josm.actions.JosmAction;
052import org.openstreetmap.josm.data.ImageData;
053import org.openstreetmap.josm.data.imagery.street_level.IImageEntry;
054import org.openstreetmap.josm.gui.ExtendedDialog;
055import org.openstreetmap.josm.gui.MainApplication;
056import org.openstreetmap.josm.gui.MapFrame;
057import org.openstreetmap.josm.gui.datatransfer.ClipboardUtils;
058import org.openstreetmap.josm.gui.dialogs.DialogsPanel;
059import org.openstreetmap.josm.gui.dialogs.ToggleDialog;
060import org.openstreetmap.josm.gui.dialogs.layer.LayerVisibilityAction;
061import org.openstreetmap.josm.gui.layer.Layer;
062import org.openstreetmap.josm.gui.layer.LayerManager.LayerAddEvent;
063import org.openstreetmap.josm.gui.layer.LayerManager.LayerChangeListener;
064import org.openstreetmap.josm.gui.layer.LayerManager.LayerOrderChangeEvent;
065import org.openstreetmap.josm.gui.layer.LayerManager.LayerRemoveEvent;
066import org.openstreetmap.josm.gui.layer.MainLayerManager;
067import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeEvent;
068import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeListener;
069import org.openstreetmap.josm.gui.layer.imagery.ImageryFilterSettings;
070import org.openstreetmap.josm.gui.util.GuiHelper;
071import org.openstreetmap.josm.gui.util.imagery.Vector3D;
072import org.openstreetmap.josm.gui.widgets.HideableTabbedPane;
073import org.openstreetmap.josm.spi.preferences.Config;
074import org.openstreetmap.josm.tools.ImageProvider;
075import org.openstreetmap.josm.tools.Logging;
076import org.openstreetmap.josm.tools.PlatformManager;
077import org.openstreetmap.josm.tools.Shortcut;
078import org.openstreetmap.josm.tools.date.DateUtils;
079
080/**
081 * Dialog to view and manipulate geo-tagged images from a {@link GeoImageLayer}.
082 */
083public final class ImageViewerDialog extends ToggleDialog implements LayerChangeListener, ActiveLayerChangeListener {
084    private static final String GEOIMAGE_FILLER = marktr("Geoimage: {0}");
085    private static final String DIALOG_FOLDER = "dialogs";
086
087    private final ImageryFilterSettings imageryFilterSettings = new ImageryFilterSettings();
088
089    private final ImageZoomAction imageZoomAction = new ImageZoomAction();
090    private final ImageCenterViewAction imageCenterViewAction = new ImageCenterViewAction();
091    private final ImageExtendedInfoAction imageExtendedInfoAction = new ImageExtendedInfoAction();
092    private final ImageNextAction imageNextAction = new ImageNextAction();
093    private final ImageRemoveAction imageRemoveAction = new ImageRemoveAction();
094    private final ImageRemoveFromDiskAction imageRemoveFromDiskAction = new ImageRemoveFromDiskAction();
095    private final ImagePreviousAction imagePreviousAction = new ImagePreviousAction();
096    private final ImageCollapseAction imageCollapseAction = new ImageCollapseAction();
097    private final ImageFirstAction imageFirstAction = new ImageFirstAction();
098    private final ImageLastAction imageLastAction = new ImageLastAction();
099    private final ImageCopyPathAction imageCopyPathAction = new ImageCopyPathAction();
100    private final ImageOpenExternalAction imageOpenExternalAction = new ImageOpenExternalAction();
101    private final LayerVisibilityAction visibilityAction = new LayerVisibilityAction(Collections::emptyList,
102            () -> Collections.singleton(imageryFilterSettings));
103    private final CloseOtherTabsAction closeAllTabsAction = new CloseOtherTabsAction();
104    private final ImageDisplay imgDisplay = new ImageDisplay(imageryFilterSettings);
105    private Future<?> imgLoadingFuture;
106    private boolean centerView;
107    private boolean extendedImgInfo;
108
109    // Only one instance of that class is present at one time
110    private static volatile ImageViewerDialog dialog;
111
112    private boolean collapseButtonClicked;
113
114    static void createInstance() {
115        if (dialog != null)
116            throw new IllegalStateException("ImageViewerDialog instance was already created");
117        dialog = new ImageViewerDialog();
118    }
119
120    /**
121     * Replies the unique instance of this dialog
122     * @return the unique instance
123     */
124    public static ImageViewerDialog getInstance() {
125        MapFrame map = MainApplication.getMap();
126        synchronized (ImageViewerDialog.class) {
127            if (dialog == null)
128                createInstance();
129            if (map != null && map.getToggleDialog(ImageViewerDialog.class) == null) {
130                map.addToggleDialog(dialog);
131            }
132        }
133        return dialog;
134    }
135
136    /**
137     * Check if there is an instance for the {@link ImageViewerDialog}
138     * @return {@code true} if there is a static singleton instance of {@link ImageViewerDialog}
139     * @since 18613
140     */
141    public static boolean hasInstance() {
142        return dialog != null;
143    }
144
145    /**
146     * Destroy the current dialog
147     */
148    private static void destroyInstance() {
149        MapFrame map = MainApplication.getMap();
150        synchronized (ImageViewerDialog.class) {
151            if (dialog != null && map != null && map.getToggleDialog(ImageViewerDialog.class) != null) {
152                map.removeToggleDialog(dialog);
153            }
154        }
155        dialog = null;
156    }
157
158    private JButton btnLast;
159    private JButton btnNext;
160    private JButton btnPrevious;
161    private JButton btnFirst;
162    private JButton btnCollapse;
163    private JButton btnDelete;
164    private JButton btnCopyPath;
165    private JButton btnOpenExternal;
166    private JButton btnDeleteFromDisk;
167    private JToggleButton tbCentre;
168    private JToggleButton tbImgExtInfo;
169    /** The layer tab (used to select images when multiple layers provide images, makes for easy switching) */
170    private final HideableTabbedPane layers = new HideableTabbedPane();
171
172    private ImageViewerDialog() {
173        super(tr("Geotagged Images"), "geoimage", tr("Display geotagged images"), Shortcut.registerShortcut("tools:geotagged",
174        tr("Windows: {0}", tr("Geotagged Images")), KeyEvent.VK_Y, Shortcut.DIRECT), 200);
175        build();
176        MainApplication.getLayerManager().addActiveLayerChangeListener(this);
177        MainApplication.getLayerManager().addLayerChangeListener(this);
178        for (Layer l: MainApplication.getLayerManager().getLayers()) {
179            registerOnLayer(l);
180        }
181        // This listener gets called _prior to_ the reorder event. If we do not delay the execution of the
182        // model update, then the image will change instead of remaining the same.
183        this.layers.getModel().addChangeListener(l -> {
184            // We need to check to see whether or not the worker is shut down. See #22922 for details.
185            if (!MainApplication.worker.isShutdown() && this.isDialogShowing()) {
186                MainApplication.worker.execute(() -> GuiHelper.runInEDT(this::showNotify));
187            }
188        });
189    }
190
191    @Override
192    public void showNotify() {
193        super.showNotify();
194        Component selected = this.layers.getSelectedComponent();
195        if (selected instanceof MoveImgDisplayPanel) {
196            ((MoveImgDisplayPanel<?>) selected).fireModelUpdate();
197        }
198    }
199
200    private static JButton createButton(AbstractAction action, Dimension buttonDim) {
201        JButton btn = new JButton(action);
202        btn.setPreferredSize(buttonDim);
203        btn.addPropertyChangeListener("enabled", e -> action.setEnabled(Boolean.TRUE.equals(e.getNewValue())));
204        return btn;
205    }
206
207    private static JButton createNavigationButton(AbstractAction action, Dimension buttonDim) {
208        JButton btn = createButton(action, buttonDim);
209        btn.setEnabled(false);
210        action.addPropertyChangeListener(l -> {
211            if ("enabled".equals(l.getPropertyName())) {
212                btn.setEnabled(action.isEnabled());
213            }
214        });
215        return btn;
216    }
217
218    private void build() {
219        JPanel content = new JPanel(new BorderLayout());
220        content.add(this.layers, BorderLayout.CENTER);
221
222        Dimension buttonDim = new Dimension(26, 26);
223
224        btnFirst = createNavigationButton(imageFirstAction, buttonDim);
225        btnPrevious = createNavigationButton(imagePreviousAction, buttonDim);
226
227        btnDelete = createButton(imageRemoveAction, buttonDim);
228        btnDeleteFromDisk = createButton(imageRemoveFromDiskAction, buttonDim);
229        btnCopyPath = createButton(imageCopyPathAction, buttonDim);
230        btnOpenExternal = createButton(imageOpenExternalAction, buttonDim);
231
232        btnNext = createNavigationButton(imageNextAction, buttonDim);
233        btnLast = createNavigationButton(imageLastAction, buttonDim);
234
235        centerView = Config.getPref().getBoolean("geoimage.viewer.centre.on.image", false);
236        tbCentre = new JToggleButton(imageCenterViewAction);
237        tbCentre.setSelected(centerView);
238        tbCentre.setPreferredSize(buttonDim);
239
240        extendedImgInfo = Config.getPref().getBoolean("geoimage.viewer.extendedinfo", false);
241        tbImgExtInfo = new JToggleButton(imageExtendedInfoAction);
242        tbImgExtInfo.setSelected(extendedImgInfo);
243        tbImgExtInfo.setPreferredSize(buttonDim);
244
245        JButton btnZoomBestFit = new JButton(imageZoomAction);
246        btnZoomBestFit.setPreferredSize(buttonDim);
247
248        btnCollapse = createButton(imageCollapseAction, new Dimension(20, 20));
249        btnCollapse.setAlignmentY(Component.TOP_ALIGNMENT);
250
251        JPanel buttons = new JPanel();
252        addButtonGroup(buttons, this.btnFirst, this.btnPrevious, this.btnNext, this.btnLast);
253        addButtonGroup(buttons, this.tbCentre, btnZoomBestFit, this.tbImgExtInfo);
254        addButtonGroup(buttons, this.btnDelete, this.btnDeleteFromDisk);
255        addButtonGroup(buttons, this.btnCopyPath, this.btnOpenExternal);
256        addButtonGroup(buttons, createButton(visibilityAction, buttonDim));
257
258        JPanel bottomPane = new JPanel(new GridBagLayout());
259        GridBagConstraints gc = new GridBagConstraints();
260        gc.gridx = 0;
261        gc.gridy = 0;
262        gc.anchor = GridBagConstraints.CENTER;
263        gc.weightx = 1;
264        bottomPane.add(buttons, gc);
265
266        gc.gridx = 1;
267        gc.gridy = 0;
268        gc.anchor = GridBagConstraints.PAGE_END;
269        gc.weightx = 0;
270        bottomPane.add(btnCollapse, gc);
271
272        content.add(bottomPane, BorderLayout.SOUTH);
273
274        createLayout(content, false, null);
275    }
276
277    /**
278     * Add a button group to a panel
279     * @param buttonPanel The panel holding the buttons
280     * @param buttons The button group to add
281     */
282    private static void addButtonGroup(JPanel buttonPanel, AbstractButton... buttons) {
283        if (buttonPanel.getComponentCount() != 0) {
284            buttonPanel.add(Box.createRigidArea(new Dimension(7, 0)));
285        }
286
287        for (AbstractButton jButton : buttons) {
288            buttonPanel.add(jButton);
289        }
290    }
291
292    /**
293     * Update the tabs for the different image layers
294     * @param changed {@code true} if the tabs changed
295     */
296    private void updateLayers(boolean changed) {
297        MainLayerManager layerManager = MainApplication.getLayerManager();
298        List<IGeoImageLayer> geoImageLayers = layerManager.getLayers().stream()
299                .filter(IGeoImageLayer.class::isInstance).map(IGeoImageLayer.class::cast).collect(Collectors.toList());
300        if (geoImageLayers.isEmpty()) {
301            this.layers.setVisible(false);
302        } else {
303            this.layers.setVisible(true);
304            if (changed) {
305                addButtonsForImageLayers();
306            }
307            MoveImgDisplayPanel<?> selected = (MoveImgDisplayPanel<?>) this.layers.getSelectedComponent();
308            if ((this.imgDisplay.getParent() == null || this.imgDisplay.getParent().getParent() == null)
309                && selected != null && selected.layer.containsImage(this.currentEntry)) {
310                selected.setVisible(selected.isVisible());
311            } else if (selected != null && !selected.layer.containsImage(this.currentEntry)) {
312                this.getImageTabs().filter(m -> m.layer.containsImage(this.currentEntry)).mapToInt(this.layers::indexOfComponent).findFirst()
313                        .ifPresent(this.layers::setSelectedIndex);
314            } else if (selected == null) {
315                updateTitle();
316            }
317            this.layers.invalidate();
318        }
319        this.layers.getParent().invalidate();
320        this.revalidate();
321    }
322
323    /**
324     * Add the buttons for image layers
325     */
326    private void addButtonsForImageLayers() {
327        List<MoveImgDisplayPanel<?>> alreadyAdded = this.getImageTabs().collect(Collectors.toList());
328        List<Layer> availableLayers = MainApplication.getLayerManager().getLayers();
329        List<IGeoImageLayer> geoImageLayers = availableLayers.stream()
330                .sorted(Comparator.comparingInt(entry -> /*reverse*/-availableLayers.indexOf(entry)))
331                .filter(IGeoImageLayer.class::isInstance).map(IGeoImageLayer.class::cast).collect(Collectors.toList());
332        List<IGeoImageLayer> tabLayers = geoImageLayers.stream()
333                .filter(l -> alreadyAdded.stream().anyMatch(m -> Objects.equals(l, m.layer)) || l.containsImage(this.currentEntry))
334                .collect(Collectors.toList());
335        for (IGeoImageLayer layer : tabLayers) {
336            final MoveImgDisplayPanel<?> panel = alreadyAdded.stream()
337                    .filter(m -> Objects.equals(m.layer, layer)).findFirst()
338                    .orElseGet(() -> new MoveImgDisplayPanel<>(this.imgDisplay, (Layer & IGeoImageLayer) layer));
339            int componentIndex = this.layers.indexOfComponent(panel);
340            if (componentIndex == geoImageLayers.indexOf(layer)) {
341                this.layers.setTitleAt(componentIndex, panel.getLabel(availableLayers));
342            } else {
343                this.removeImageTab((Layer) layer);
344                this.layers.insertTab(panel.getLabel(availableLayers), null, panel, null, tabLayers.indexOf(layer));
345                int idx = this.layers.indexOfComponent(panel);
346                CloseableTab closeableTab = new CloseableTab(this.layers, l -> {
347                    Component source = (Component) l.getSource();
348                    do {
349                        int index = layers.indexOfTabComponent(source);
350                        if (index >= 0) {
351                            removeImageTab(((MoveImgDisplayPanel<?>) layers.getComponentAt(index)).layer);
352                            getImageTabs().forEach(m -> m.setVisible(m.isVisible()));
353                            showNotify();
354                            return;
355                        }
356                        source = source.getParent();
357                    } while (source != null);
358                });
359                this.layers.setTabComponentAt(idx, closeableTab);
360            }
361            if (layer.containsImage(this.currentEntry)) {
362                this.layers.setSelectedComponent(panel);
363            }
364        }
365        this.getImageTabs().map(p -> p.layer).filter(layer -> !availableLayers.contains(layer))
366                // We have to collect to a list prior to removal -- if we don't, then the stream may get a layer at index 0,
367                // remove that layer, and then get a layer at index 1, which was previously at index 2.
368                .collect(Collectors.toList()).forEach(this::removeImageTab);
369
370        // After that, trigger the visibility set code
371        this.getImageTabs().forEach(m -> m.setVisible(m.isVisible()));
372    }
373
374    /**
375     * Remove a tab for a layer from the {@link #layers} tab pane
376     * @param layer The layer to remove
377     */
378    private void removeImageTab(Layer layer) {
379        // This must be reversed to avoid removing the wrong tab
380        for (int i = this.layers.getTabCount() - 1; i >= 0; i--) {
381            Component component = this.layers.getComponentAt(i);
382            if (component instanceof MoveImgDisplayPanel) {
383                MoveImgDisplayPanel<?> moveImgDisplayPanel = (MoveImgDisplayPanel<?>) component;
384                if (Objects.equals(layer, moveImgDisplayPanel.layer)) {
385                    this.layers.removeTabAt(i);
386                    this.layers.remove(moveImgDisplayPanel);
387                }
388            }
389        }
390    }
391
392    /**
393     * Get the {@link MoveImgDisplayPanel} objects in {@link #layers}.
394     * @return The individual panels
395     */
396    private Stream<MoveImgDisplayPanel<?>> getImageTabs() {
397        return IntStream.range(0, this.layers.getTabCount())
398                .mapToObj(this.layers::getComponentAt)
399                .filter(MoveImgDisplayPanel.class::isInstance)
400                .map(m -> (MoveImgDisplayPanel<?>) m);
401    }
402
403    @Override
404    public void destroy() {
405        MainApplication.getLayerManager().removeActiveLayerChangeListener(this);
406        MainApplication.getLayerManager().removeLayerChangeListener(this);
407        // Manually destroy actions until JButtons are replaced by standard SideButtons
408        imageFirstAction.destroy();
409        imageLastAction.destroy();
410        imagePreviousAction.destroy();
411        imageNextAction.destroy();
412        imageCenterViewAction.destroy();
413        imageCollapseAction.destroy();
414        imageCopyPathAction.destroy();
415        imageOpenExternalAction.destroy();
416        imageRemoveAction.destroy();
417        imageRemoveFromDiskAction.destroy();
418        imageZoomAction.destroy();
419        toggleAction.destroy();
420        closeAllTabsAction.destroy();
421        cancelLoadingImage();
422        super.destroy();
423        // make sure that Image Display is destroyed here, it might not be a component
424        imgDisplay.destroy();
425        // Ensure that this dialog is removed from memory
426        destroyInstance();
427    }
428
429    /**
430     * This literally exists to silence sonarlint complaints.
431     * @param <I> the type of the operand and result of the operator
432     */
433    @FunctionalInterface
434    private interface SerializableUnaryOperator<I> extends UnaryOperator<I>, Serializable {
435    }
436
437    private abstract class ImageAction extends JosmAction {
438        final SerializableUnaryOperator<IImageEntry<?>> supplier;
439        ImageAction(String name, ImageProvider icon, String tooltip, Shortcut shortcut,
440                boolean registerInToolbar, String toolbarId, boolean installAdaptors,
441                final SerializableUnaryOperator<IImageEntry<?>> supplier) {
442            super(name, icon, tooltip, shortcut, registerInToolbar, toolbarId, installAdaptors);
443            Objects.requireNonNull(supplier);
444            this.supplier = supplier;
445        }
446
447        @Override
448        public void actionPerformed(ActionEvent event) {
449            final IImageEntry<?> entry = ImageViewerDialog.this.currentEntry;
450            if (entry != null) {
451                IImageEntry<?> nextEntry = this.getSupplier().apply(entry);
452                entry.selectImage(ImageViewerDialog.this, nextEntry);
453            }
454            this.resetRememberActions();
455        }
456
457        void resetRememberActions() {
458            for (ImageRememberAction action : Arrays.asList(ImageViewerDialog.this.imageLastAction, ImageViewerDialog.this.imageFirstAction)) {
459                action.last = null;
460                action.updateEnabledState();
461            }
462        }
463
464        SerializableUnaryOperator<IImageEntry<?>> getSupplier() {
465            return this.supplier;
466        }
467
468        @Override
469        protected void updateEnabledState() {
470            final IImageEntry<?> entry = ImageViewerDialog.this.currentEntry;
471            this.setEnabled(entry != null && this.getSupplier().apply(entry) != null);
472        }
473    }
474
475    private class ImageNextAction extends ImageAction {
476        ImageNextAction() {
477            super(null, new ImageProvider(DIALOG_FOLDER, "next"), tr("Next"), Shortcut.registerShortcut(
478                    "geoimage:next", tr(GEOIMAGE_FILLER, tr("Show next Image")), KeyEvent.VK_PAGE_DOWN, Shortcut.DIRECT),
479                  false, null, false, IImageEntry::getNextImage);
480        }
481    }
482
483    private class ImagePreviousAction extends ImageAction {
484        ImagePreviousAction() {
485            super(null, new ImageProvider(DIALOG_FOLDER, "previous"), tr("Previous"), Shortcut.registerShortcut(
486                    "geoimage:previous", tr(GEOIMAGE_FILLER, tr("Show previous Image")), KeyEvent.VK_PAGE_UP, Shortcut.DIRECT),
487                  false, null, false, IImageEntry::getPreviousImage);
488        }
489    }
490
491    /** This class exists to remember the last entry, and go back if clicked again when it would not otherwise be enabled */
492    private abstract class ImageRememberAction extends ImageAction {
493        private final ImageProvider defaultIcon;
494        transient IImageEntry<?> last;
495        ImageRememberAction(String name, ImageProvider icon, String tooltip, Shortcut shortcut,
496                boolean registerInToolbar, String toolbarId, boolean installAdaptors, SerializableUnaryOperator<IImageEntry<?>> supplier) {
497            super(name, icon, tooltip, shortcut, registerInToolbar, toolbarId, installAdaptors, supplier);
498            this.defaultIcon = icon;
499        }
500
501        /**
502         * Update the icon for this action
503         */
504        public void updateIcon() {
505            if (this.last != null) {
506                new ImageProvider(DIALOG_FOLDER, "history").getResource().attachImageIcon(this, true);
507            } else {
508                this.defaultIcon.getResource().attachImageIcon(this, true);
509            }
510        }
511
512        @Override
513        public void actionPerformed(ActionEvent event) {
514            final IImageEntry<?> current = ImageViewerDialog.this.currentEntry;
515            final IImageEntry<?> expected = this.supplier.apply(current);
516            if (current != null) {
517                IImageEntry<?> nextEntry = this.getSupplier().apply(current);
518                current.selectImage(ImageViewerDialog.this, nextEntry);
519            }
520            this.resetRememberActions();
521            if (!Objects.equals(current, expected)) {
522                this.last = current;
523            } else {
524                this.last = null;
525            }
526            this.updateEnabledState();
527        }
528
529        @Override
530        protected void updateEnabledState() {
531            final IImageEntry<?> current = ImageViewerDialog.this.currentEntry;
532            final IImageEntry<?> nextEntry = current != null ? this.getSupplier().apply(current) : null;
533            if (this.last == null && nextEntry != null && nextEntry.equals(current)) {
534                this.setEnabled(false);
535            } else {
536                super.updateEnabledState();
537            }
538            this.updateIcon();
539        }
540
541        @Override
542        SerializableUnaryOperator<IImageEntry<?>> getSupplier() {
543            if (this.last != null) {
544                return entry -> this.last;
545            }
546            return super.getSupplier();
547        }
548    }
549
550    private class ImageFirstAction extends ImageRememberAction {
551        ImageFirstAction() {
552            super(null, new ImageProvider(DIALOG_FOLDER, "first"), tr("First"), Shortcut.registerShortcut(
553                    "geoimage:first", tr(GEOIMAGE_FILLER, tr("Show first Image")), KeyEvent.VK_HOME, Shortcut.DIRECT),
554                  false, null, false, IImageEntry::getFirstImage);
555        }
556    }
557
558    private class ImageLastAction extends ImageRememberAction {
559        ImageLastAction() {
560            super(null, new ImageProvider(DIALOG_FOLDER, "last"), tr("Last"), Shortcut.registerShortcut(
561                    "geoimage:last", tr(GEOIMAGE_FILLER, tr("Show last Image")), KeyEvent.VK_END, Shortcut.DIRECT),
562                  false, null, false, IImageEntry::getLastImage);
563        }
564    }
565
566    private class ImageCenterViewAction extends JosmAction {
567        ImageCenterViewAction() {
568            super(null, new ImageProvider("dialogs/autoscale", "selection"), tr("Center view"), null,
569                  false, null, false);
570        }
571
572        @Override
573        public void actionPerformed(ActionEvent e) {
574            final JToggleButton button = (JToggleButton) e.getSource();
575            centerView = button.isEnabled() && button.isSelected();
576            Config.getPref().putBoolean("geoimage.viewer.centre.on.image", centerView);
577            if (centerView && currentEntry != null && currentEntry.getPos() != null) {
578                MainApplication.getMap().mapView.zoomTo(currentEntry.getPos());
579            }
580        }
581    }
582
583    private class ImageZoomAction extends JosmAction {
584        ImageZoomAction() {
585            super(null, new ImageProvider(DIALOG_FOLDER, "zoom-best-fit"), tr("Zoom best fit and 1:1"), null,
586                  false, null, false);
587        }
588
589        @Override
590        public void actionPerformed(ActionEvent e) {
591            imgDisplay.zoomBestFitOrOne();
592        }
593    }
594
595    private class ImageExtendedInfoAction extends JosmAction {
596        ImageExtendedInfoAction() {
597            super(null, new ImageProvider("info"), tr("Display image extended metadata"), Shortcut.registerShortcut(
598                    "geoimage:extendedinfos", tr(GEOIMAGE_FILLER, tr("Toggle display of extended information")),
599                    KeyEvent.CHAR_UNDEFINED, Shortcut.NONE),
600            false, null, false);
601        }
602
603        @Override
604        public void actionPerformed(ActionEvent e) {
605            final JToggleButton button = (JToggleButton) e.getSource();
606            extendedImgInfo = button.isEnabled() && button.isSelected();
607            Config.getPref().putBoolean("geoimage.viewer.extendedinfo", extendedImgInfo);
608            refresh(false);
609        }
610    }
611
612    private class ImageRemoveAction extends JosmAction {
613        ImageRemoveAction() {
614            super(null, new ImageProvider(DIALOG_FOLDER, "delete"), tr("Remove photo from layer"), Shortcut.registerShortcut(
615                    "geoimage:deleteimagefromlayer", tr(GEOIMAGE_FILLER, tr("Remove photo from layer")), KeyEvent.VK_DELETE, Shortcut.SHIFT),
616                  false, null, false);
617        }
618
619        @Override
620        public void actionPerformed(ActionEvent e) {
621            if (ImageViewerDialog.this.currentEntry != null) {
622                IImageEntry<?> imageEntry = ImageViewerDialog.this.currentEntry;
623                if (imageEntry.isRemoveSupported()) {
624                    imageEntry.remove();
625                }
626                selectNextImageAfterDeletion(imageEntry);
627            }
628        }
629
630        /**
631         * Select the logical next entry after deleting the currently viewed image
632         * @param oldEntry The image entry that was just deleted
633         */
634        private void selectNextImageAfterDeletion(IImageEntry<?> oldEntry) {
635            final IImageEntry<?> currentImageEntry = ImageViewerDialog.this.currentEntry;
636            // This is mostly just in case something changes the displayed entry (aka avoid race condition) or an image provider
637            // sets the next image itself.
638            if (Objects.equals(currentImageEntry, oldEntry)) {
639                final IImageEntry<?> nextImage;
640                if (oldEntry instanceof ImageEntry) {
641                    nextImage = ((ImageEntry) oldEntry).getDataSet().getSelectedImage();
642                } else if (oldEntry.getNextImage() != null) {
643                    nextImage = oldEntry.getNextImage();
644                } else if (oldEntry.getPreviousImage() != null) {
645                    nextImage = oldEntry.getPreviousImage();
646                } else {
647                    nextImage = null;
648                }
649                ImageViewerDialog.getInstance().displayImages(nextImage == null ? null : Collections.singletonList(nextImage));
650            }
651        }
652    }
653
654    private class ImageRemoveFromDiskAction extends JosmAction {
655        ImageRemoveFromDiskAction() {
656            super(null, new ImageProvider(DIALOG_FOLDER, "geoimage/deletefromdisk"), tr("Delete image file from disk"),
657                    Shortcut.registerShortcut("geoimage:deletefilefromdisk",
658                            tr(GEOIMAGE_FILLER, tr("Delete image file from disk")), KeyEvent.VK_DELETE, Shortcut.CTRL_SHIFT),
659                    false, null, false);
660        }
661
662        @Override
663        public void actionPerformed(ActionEvent e) {
664            if (currentEntry != null) {
665                IImageEntry<?> oldEntry = ImageViewerDialog.this.currentEntry;
666                List<IImageEntry<?>> toDelete = oldEntry instanceof ImageEntry ?
667                        new ArrayList<>(((ImageEntry) oldEntry).getDataSet().getSelectedImages())
668                        : Collections.singletonList(oldEntry);
669                int size = toDelete.size();
670
671                int result = new ExtendedDialog(
672                        MainApplication.getMainFrame(),
673                        tr("Delete image file from disk"),
674                        tr("Cancel"), tr("Delete"))
675                        .setButtonIcons("cancel", "dialogs/geoimage/deletefromdisk")
676                        .setContent(new JLabel("<html><h3>"
677                                + trn("Delete the file from disk?",
678                                      "Delete the {0} files from disk?", size, size)
679                                + "<p>" + trn("The image file will be permanently lost!",
680                                              "The images files will be permanently lost!", size) + "</h3></html>",
681                                ImageProvider.get("dialogs/geoimage/deletefromdisk"), SwingConstants.LEADING))
682                        .toggleEnable("geoimage.deleteimagefromdisk")
683                        .setCancelButton(1)
684                        .setDefaultButton(2)
685                        .showDialog()
686                        .getValue();
687
688                if (result == 2) {
689                    final List<ImageData> imageDataCollection = toDelete.stream().filter(ImageEntry.class::isInstance)
690                            .map(ImageEntry.class::cast).map(ImageEntry::getDataSet).distinct().collect(Collectors.toList());
691                    for (IImageEntry<?> delete : toDelete) {
692                        // We have to be able to remove the image from the layer and the image from its storage location
693                        // If either are false, then don't remove the image.
694                        if (delete.isRemoveSupported() && delete.isDeleteSupported() && delete.remove() && delete.delete()) {
695                            Logging.info("File {0} deleted.", delete.getFile());
696                        } else {
697                            JOptionPane.showMessageDialog(
698                                    MainApplication.getMainFrame(),
699                                    tr("Image file could not be deleted."),
700                                    tr("Error"),
701                                    JOptionPane.ERROR_MESSAGE
702                                    );
703                        }
704                    }
705                    imageDataCollection.forEach(data -> {
706                        data.notifyImageUpdate();
707                        data.updateSelectedImage();
708                    });
709                    ImageViewerDialog.this.imageRemoveAction.selectNextImageAfterDeletion(oldEntry);
710                }
711            }
712        }
713    }
714
715    private class ImageCopyPathAction extends JosmAction {
716        ImageCopyPathAction() {
717            super(null, new ImageProvider("copy"), tr("Copy image path"), Shortcut.registerShortcut(
718                    "geoimage:copypath", tr(GEOIMAGE_FILLER, tr("Copy image path")), KeyEvent.VK_C, Shortcut.ALT_CTRL_SHIFT),
719                  false, null, false);
720        }
721
722        @Override
723        public void actionPerformed(ActionEvent e) {
724            if (currentEntry != null) {
725                ClipboardUtils.copyString(String.valueOf(currentEntry.getImageURI()));
726            }
727        }
728    }
729
730    private class ImageCollapseAction extends JosmAction {
731        ImageCollapseAction() {
732            super(null, new ImageProvider(DIALOG_FOLDER, "collapse"), tr("Move dialog to the side pane"), null,
733                  false, null, false);
734        }
735
736        @Override
737        public void actionPerformed(ActionEvent e) {
738            collapseButtonClicked = true;
739            detachedDialog.getToolkit().getSystemEventQueue().postEvent(new WindowEvent(detachedDialog, WindowEvent.WINDOW_CLOSING));
740        }
741    }
742
743    private class ImageOpenExternalAction extends JosmAction {
744        ImageOpenExternalAction() {
745            super(null, new ImageProvider("external-link"), tr("Open image in external viewer"), null, false, null, false);
746        }
747
748        @Override
749        public void actionPerformed(ActionEvent e) {
750            if (currentEntry != null && currentEntry.getImageURI() != null) {
751                try {
752                    PlatformManager.getPlatform().openUrl(currentEntry.getImageURI().toURL().toExternalForm());
753                } catch (IOException ex) {
754                    Logging.error(ex);
755                }
756            }
757        }
758    }
759
760    private class CloseOtherTabsAction extends JosmAction {
761        CloseOtherTabsAction() {
762            super(tr("Close other tabs"), new ImageProvider("misc", "close"), tr("Close other tabs"),
763                    Shortcut.registerShortcut("closeother", "Close other tabs", KeyEvent.VK_Y, Shortcut.ALT), false, null,
764                    false);
765        }
766
767        @Override
768        public void actionPerformed(ActionEvent e) {
769            for (int i = layers.getTabCount() - 1; i >= 0; i--) {
770                Component component = layers.getComponentAt(i);
771                if (component instanceof MoveImgDisplayPanel) {
772                    MoveImgDisplayPanel<?> moveImgDisplayPanel = (MoveImgDisplayPanel<?>) component;
773                    if (moveImgDisplayPanel.layer.containsImage(currentEntry))
774                        continue;
775                    layers.removeTabAt(i);
776                    layers.remove(moveImgDisplayPanel);
777                }
778            }
779        }
780    }
781
782    /**
783     * A tab title renderer for {@link HideableTabbedPane} that allows us to close tabs.
784     */
785    private static class CloseableTab extends JPanel implements PropertyChangeListener {
786        private final JLabel title;
787        private final JButton close;
788
789        /**
790         * Create a new {@link CloseableTab}.
791         * @param parent The parent to add property change listeners to. It should be a {@link HideableTabbedPane} in most cases.
792         * @param closeAction The action to run to close the tab. You probably want to call {@link JTabbedPane#removeTabAt(int)}
793         *                    at the very least.
794         */
795        CloseableTab(Component parent, ActionListener closeAction) {
796            this.title = new JLabel();
797            this.add(this.title);
798            close = new JButton(ImageProvider.get("misc", "close"));
799            close.setBorder(BorderFactory.createEmptyBorder());
800            this.add(close);
801            close.addActionListener(closeAction);
802            close.addActionListener(l -> parent.removePropertyChangeListener("indexForTitle", this));
803            parent.addPropertyChangeListener("indexForTitle", this);
804        }
805
806        @Override
807        public void propertyChange(PropertyChangeEvent evt) {
808            if (evt.getSource() instanceof JTabbedPane) {
809                JTabbedPane source = (JTabbedPane) evt.getSource();
810                if (this.getParent() == null) {
811                    source.removePropertyChangeListener(evt.getPropertyName(), this);
812                }
813                if ("indexForTitle".equals(evt.getPropertyName())) {
814                    int idx = source.indexOfTabComponent(this);
815                    if (idx >= 0) {
816                        this.title.setText(source.getTitleAt(idx));
817                    }
818                }
819                // Used to hack around UI staying visible. This assumes that the parent component is a HideableTabbedPane.
820                this.title.setVisible(source.getTabCount() != 1);
821                this.close.setVisible(source.getTabCount() != 1);
822            }
823        }
824    }
825
826    /**
827     * A JPanel whose entire purpose is to display an image by (a) moving the imgDisplay around and (b) setting the imgDisplay as a child
828     * for this panel.
829     */
830    private static class MoveImgDisplayPanel<T extends Layer & IGeoImageLayer> extends JPanel {
831        private final T layer;
832        private final ImageDisplay imgDisplay;
833
834        MoveImgDisplayPanel(ImageDisplay imgDisplay, T layer) {
835            super(new BorderLayout());
836            this.layer = layer;
837            this.imgDisplay = imgDisplay;
838        }
839
840        /**
841         * Call when the selection model updates
842         */
843        void fireModelUpdate() {
844            JTabbedPane layers = ImageViewerDialog.getInstance().layers;
845            int index = layers.indexOfComponent(this);
846            if (this == layers.getSelectedComponent()) {
847                if (!this.layer.getSelection().isEmpty() && !this.layer.getSelection().contains(ImageViewerDialog.getCurrentImage())) {
848                    ImageViewerDialog.getInstance().displayImages(this.layer.getSelection());
849                    this.layer.invalidate(); // This will force the geoimage layers to update properly.
850                }
851                if (this.imgDisplay.getParent() != this) {
852                    this.add(this.imgDisplay, BorderLayout.CENTER);
853                    this.imgDisplay.invalidate();
854                    this.revalidate();
855                }
856                if (index >= 0) {
857                    layers.setTitleAt(index, "* " + getLabel(MainApplication.getLayerManager().getLayers()));
858                }
859            } else if (index >= 0) {
860                layers.setTitleAt(index, getLabel(MainApplication.getLayerManager().getLayers()));
861            }
862        }
863
864        /**
865         * Get the label for this panel
866         * @param availableLayers The layers to use to get the index
867         * @return The label for this layer
868         */
869        String getLabel(List<Layer> availableLayers) {
870            final int index = availableLayers.size() - availableLayers.indexOf(layer);
871            return (ExpertToggleAction.isExpert() ? "[" + index + "] " : "") + layer.getLabel();
872        }
873    }
874
875    /**
876     * Enables (or disables) the "Previous" button.
877     * @param value {@code true} to enable the button, {@code false} otherwise
878     */
879    public void setPreviousEnabled(boolean value) {
880        this.imageFirstAction.updateEnabledState();
881        this.btnFirst.setEnabled(value || this.imageFirstAction.isEnabled());
882        btnPrevious.setEnabled(value);
883    }
884
885    /**
886     * Enables (or disables) the "Next" button.
887     * @param value {@code true} to enable the button, {@code false} otherwise
888     */
889    public void setNextEnabled(boolean value) {
890        btnNext.setEnabled(value);
891        this.imageLastAction.updateEnabledState();
892        this.btnLast.setEnabled(value || this.imageLastAction.isEnabled());
893    }
894
895    /**
896     * Enables (or disables) the "Center view" button.
897     * @param value {@code true} to enable the button, {@code false} otherwise
898     * @return the old enabled value. Can be used to restore the original enable state
899     */
900    public static synchronized boolean setCentreEnabled(boolean value) {
901        final ImageViewerDialog instance = getInstance();
902        final boolean wasEnabled = instance.tbCentre.isEnabled();
903        instance.tbCentre.setEnabled(value);
904        instance.tbCentre.getAction().actionPerformed(new ActionEvent(instance.tbCentre, 0, null));
905        return wasEnabled;
906    }
907
908    private transient IImageEntry<? extends IImageEntry<?>> currentEntry;
909
910    /**
911     * Displays a single image for the given layer.
912     * @param ignoredData the image data
913     * @param entry image entry
914     * @see #displayImages
915     */
916    public void displayImage(ImageData ignoredData, ImageEntry entry) {
917        displayImages(Collections.singletonList(entry));
918    }
919
920    /**
921     * Displays a single image for the given layer.
922     * @param entry image entry
923     * @see #displayImages
924     */
925    public void displayImage(IImageEntry<?> entry) {
926        this.displayImages(Collections.singletonList(entry));
927    }
928
929    /**
930     * Displays images for the given layer.
931     * @param entries image entries
932     * @since 18246
933     */
934    public void displayImages(List<? extends IImageEntry<?>> entries) {
935        boolean imageChanged;
936        IImageEntry<?> entry = entries != null && entries.size() == 1 ? entries.get(0) : null;
937
938        synchronized (this) {
939            // TODO: pop up image dialog but don't load image again
940
941            imageChanged = currentEntry != entry;
942
943            if (centerView && imageChanged && entry != null && MainApplication.isDisplayingMapView() && entry.getPos() != null) {
944                MainApplication.getMap().mapView.zoomTo(entry.getPos());
945            }
946
947            currentEntry = entry;
948
949            for (ImageAction action : Arrays.asList(this.imageFirstAction, this.imagePreviousAction,
950                    this.imageNextAction, this.imageLastAction)) {
951                action.updateEnabledState();
952            }
953        }
954
955
956        final boolean updateRequired;
957        final List<IGeoImageLayer> imageLayers = MainApplication.getLayerManager().getLayers().stream()
958                    .filter(IGeoImageLayer.class::isInstance).map(IGeoImageLayer.class::cast).collect(Collectors.toList());
959        if (!Config.getPref().getBoolean("geoimage.viewer.show.tabs", true)) {
960            updateRequired = true;
961            layers.removeAll();
962            // Clear the selected images in other geoimage layers
963            this.getImageTabs().map(m -> m.layer).filter(IGeoImageLayer.class::isInstance).map(IGeoImageLayer.class::cast)
964                    .filter(l -> !Objects.equals(entries, l.getSelection()))
965                    .forEach(IGeoImageLayer::clearSelection);
966        } else {
967            updateRequired = imageLayers.stream().anyMatch(l -> this.getImageTabs().map(m -> m.layer).noneMatch(l::equals));
968        }
969        this.updateLayers(updateRequired);
970        if (entry != null) {
971            this.updateButtonsNonNullEntry(entry, imageChanged);
972        } else if (imageLayers.isEmpty()) {
973            this.updateButtonsNullEntry(entries);
974            return;
975        } else {
976            IGeoImageLayer layer = this.getImageTabs().map(m -> m.layer).filter(l -> l.getSelection().size() == 1).findFirst().orElse(null);
977            if (layer == null) {
978                this.updateButtonsNullEntry(entries);
979            } else {
980                this.displayImages(layer.getSelection());
981            }
982            return;
983        }
984        if (!isDialogShowing()) {
985            setIsDocked(false); // always open a detached window when an image is clicked and dialog is closed
986            unfurlDialog();
987        } else if (isDocked && isCollapsed) {
988            expand();
989            dialogsPanel.reconstruct(DialogsPanel.Action.COLLAPSED_TO_DEFAULT, this);
990        }
991    }
992
993    /**
994     * Update buttons for null entry
995     * @param entries {@code true} if multiple images are selected
996     */
997    private void updateButtonsNullEntry(List<? extends IImageEntry<?>> entries) {
998        boolean hasMultipleImages = entries != null && entries.size() > 1;
999        // if this method is called to reinitialize dialog content with a blank image,
1000        // do not actually show the dialog again with a blank image if currently hidden (fix #10672)
1001        this.updateTitle();
1002        imgDisplay.setImage(null);
1003        imgDisplay.setOsdText("");
1004        setNextEnabled(false);
1005        setPreviousEnabled(false);
1006        btnDelete.setEnabled(hasMultipleImages);
1007        btnDeleteFromDisk.setEnabled(hasMultipleImages);
1008        btnCopyPath.setEnabled(false);
1009        btnOpenExternal.setEnabled(false);
1010        if (hasMultipleImages) {
1011            imgDisplay.setEmptyText(tr("Multiple images selected"));
1012            btnFirst.setEnabled(!isFirstImageSelected(entries));
1013            btnLast.setEnabled(!isLastImageSelected(entries));
1014        }
1015        imgDisplay.setImage(null);
1016        imgDisplay.setOsdText("");
1017    }
1018
1019    /**
1020     * Update the image viewer buttons for the new entry
1021     * @param entry The new entry
1022     * @param imageChanged {@code true} if it is not the same image as the previous image.
1023     */
1024    private void updateButtonsNonNullEntry(IImageEntry<?> entry, boolean imageChanged) {
1025        if (imageChanged) {
1026            cancelLoadingImage();
1027            // don't show unwanted image
1028            imgDisplay.setImage(null);
1029            // Set only if the image is new to preserve zoom and position if the same image is redisplayed
1030            // (e.g. to update the OSD).
1031            imgLoadingFuture = imgDisplay.setImage(entry);
1032        }
1033
1034        // Update buttons after setting the new entry
1035        setNextEnabled(entry.getNextImage() != null);
1036        setPreviousEnabled(entry.getPreviousImage() != null);
1037        btnDelete.setEnabled(entry.isRemoveSupported());
1038        btnDeleteFromDisk.setEnabled(entry.isDeleteSupported() && entry.isRemoveSupported());
1039        btnCopyPath.setEnabled(true);
1040        btnOpenExternal.setEnabled(true);
1041
1042        this.updateTitle();
1043        StringBuilder osd = new StringBuilder(entry.getDisplayName());
1044        if (entry.getElevation() != null) {
1045            osd.append(tr("\nAltitude: {0} m", Math.round(entry.getElevation())));
1046        }
1047        if (entry.getSpeed() != null) {
1048            osd.append(tr("\nSpeed: {0} km/h", Math.round(entry.getSpeed())));
1049        }
1050        DateTimeFormatter dtf = DateUtils.getDateTimeFormatter(FormatStyle.SHORT, FormatStyle.MEDIUM)
1051                    // Set timezone to UTC since UTC is assumed when parsing the EXIF timestamp,
1052                    // see see org.openstreetmap.josm.tools.ExifReader.readTime(com.drew.metadata.Metadata)
1053                    .withZone(ZoneOffset.UTC);
1054        if (entry.hasExifTime()) {
1055            if (Config.getPref().getBoolean("geoimage.viewer.extendedinfo", false)) {
1056                osd.append(tr("\nEXIF DTO time: {0}", dtf.format(entry.getExifInstant())));
1057            } else {
1058                osd.append(tr("\nEXIF time: {0}", dtf.format(entry.getExifInstant())));
1059            }
1060        }
1061
1062        if (Config.getPref().getBoolean("geoimage.viewer.extendedinfo", false)) {
1063            if (entry.getExifGpsInstant() != null) {
1064                osd.append(tr("\nEXIF GPS time: {0}", dtf.format(entry.getExifGpsInstant())));
1065            }
1066            if (entry.hasGpsTime()) {
1067                osd.append(tr("\nCorr GPS time: {0}", dtf.format(entry.getGpsInstant())));
1068            }
1069            if (entry.getExifImgDir() != null) {
1070                osd.append(tr("\nDirection {0}\u00b0", Math.round(entry.getExifImgDir())));
1071            }
1072            if (entry.getExifGpsTrack() != null) {
1073                osd.append(tr("\nGPS direction: {0}\u00b0", Math.round(entry.getExifGpsTrack())));
1074            }
1075            if (entry.getExifHPosErr() != null) {
1076                osd.append(tr("\nHpos errror: {0}m", entry.getExifHPosErr()));
1077            }
1078            if (entry.getGps2d3dMode() != null) {
1079                osd.append(tr("\n2d/3d mode: {0}d", entry.getGps2d3dMode()));
1080            }
1081            if (entry.getGpsDiffMode() != null) {
1082                osd.append(tr("\nDifferential: {0}", entry.getGpsDiffMode()));
1083            }
1084            if (entry.getExifGpsDop() != null) {
1085                osd.append(tr("\nDOP: {0}", entry.getExifGpsDop()));
1086            }
1087            if (entry.getExifGpsDatum() != null) {
1088                osd.append(tr("\nDatum: {0}", entry.getExifGpsDatum()));
1089            }
1090            if (entry.getExifGpsProcMethod() != null) {
1091                osd.append(tr("\nProc. method: {0}", entry.getExifGpsProcMethod()));
1092            }
1093        }
1094        Optional.ofNullable(entry.getIptcCaption()).map(s -> tr("\nCaption: {0}", s)).ifPresent(osd::append);
1095        Optional.ofNullable(entry.getIptcHeadline()).map(s -> tr("\nHeadline: {0}", s)).ifPresent(osd::append);
1096        Optional.ofNullable(entry.getIptcKeywords()).map(s -> tr("\nKeywords: {0}", s)).ifPresent(osd::append);
1097        Optional.ofNullable(entry.getIptcObjectName()).map(s -> tr("\nObject name: {0}", s)).ifPresent(osd::append);
1098
1099        imgDisplay.setOsdText(osd.toString());
1100    }
1101
1102    private void updateTitle() {
1103        final IImageEntry<?> entry;
1104        synchronized (this) {
1105            entry = this.currentEntry;
1106        }
1107        String baseTitle = Optional.ofNullable(this.layers.getSelectedComponent())
1108                .filter(MoveImgDisplayPanel.class::isInstance).map(MoveImgDisplayPanel.class::cast)
1109                .map(m -> m.layer).map(Layer::getLabel).orElse(tr("Geotagged Images"));
1110        if (entry == null) {
1111            this.setTitle(baseTitle);
1112        } else {
1113            this.setTitle(baseTitle + (!entry.getDisplayName().isEmpty() ? " - " + entry.getDisplayName() : ""));
1114        }
1115    }
1116
1117    private static boolean isLastImageSelected(List<? extends IImageEntry<?>> data) {
1118        return data.stream().anyMatch(image -> data.contains(image.getLastImage()));
1119    }
1120
1121    private static boolean isFirstImageSelected(List<? extends IImageEntry<?>> data) {
1122        return data.stream().anyMatch(image -> data.contains(image.getFirstImage()));
1123    }
1124
1125    /**
1126     * When an image is closed, really close it and do not pop
1127     * up the side dialog.
1128     */
1129    @Override
1130    protected boolean dockWhenClosingDetachedDlg() {
1131        if (collapseButtonClicked) {
1132            collapseButtonClicked = false;
1133            return super.dockWhenClosingDetachedDlg();
1134        }
1135        return false;
1136    }
1137
1138    @Override
1139    protected void stateChanged() {
1140        super.stateChanged();
1141        if (btnCollapse != null) {
1142            btnCollapse.setVisible(!isDocked);
1143        }
1144    }
1145
1146    /**
1147     * Returns whether an image is currently displayed
1148     * @return If image is currently displayed
1149     */
1150    public boolean hasImage() {
1151        return currentEntry != null;
1152    }
1153
1154    /**
1155     * Returns the currently displayed image.
1156     * @return Currently displayed image or {@code null}
1157     * @since 18246 (signature)
1158     */
1159    public static IImageEntry<?> getCurrentImage() {
1160        return getInstance().currentEntry;
1161    }
1162
1163    /**
1164     * Returns the rotation of the currently displayed image.
1165     * @param entry The entry to get the rotation for. May be {@code null}.
1166     * @return the rotation of the currently displayed image, or {@code null}
1167     * @since 18263
1168     */
1169    public Vector3D getRotation(IImageEntry<?> entry) {
1170        return imgDisplay.getRotation(entry);
1171    }
1172
1173    /**
1174     * Returns whether the center view is currently active.
1175     * @return {@code true} if the center view is active, {@code false} otherwise
1176     * @since 9416
1177     */
1178    public static boolean isCenterView() {
1179        return getInstance().centerView;
1180    }
1181
1182    @Override
1183    public void layerAdded(LayerAddEvent e) {
1184        registerOnLayer(e.getAddedLayer());
1185        showLayer(e.getAddedLayer());
1186    }
1187
1188    @Override
1189    public void layerRemoving(LayerRemoveEvent e) {
1190        if (e.getRemovedLayer() instanceof IGeoImageLayer && ((IGeoImageLayer) e.getRemovedLayer()).containsImage(this.currentEntry)) {
1191            displayImages(null);
1192        }
1193        this.updateLayers(true);
1194        if (!layers.isVisible()) {
1195            hideNotify();
1196            destroy();
1197        }
1198    }
1199
1200    @Override
1201    public void layerOrderChanged(LayerOrderChangeEvent e) {
1202        this.updateLayers(true);
1203    }
1204
1205    @Override
1206    public void activeOrEditLayerChanged(ActiveLayerChangeEvent e) {
1207        if (!MainApplication.worker.isShutdown()) {
1208            showLayer(e.getSource().getActiveLayer());
1209        }
1210    }
1211
1212    /**
1213     * Reload the image. Call this if you load a low-resolution image first, and then get a high-resolution image, or
1214     * if you know that the image has changed on disk.
1215     * @since 18591
1216     */
1217    public void refresh() {
1218        if (SwingUtilities.isEventDispatchThread()) {
1219            this.updateButtonsNonNullEntry(currentEntry, true);
1220        } else {
1221            GuiHelper.runInEDT(this::refresh);
1222        }
1223    }
1224
1225    /**
1226     * Reload the image or reload only the image info. Call this if want to update the OSD.
1227     * @param imageChanged reload the image if true. Reload only the OSD if false.
1228     * @since 19387
1229     */
1230    public void refresh(boolean imageChanged) {
1231        if (SwingUtilities.isEventDispatchThread()) {
1232            this.updateButtonsNonNullEntry(currentEntry, imageChanged);
1233        } else {
1234            GuiHelper.runInEDT(this::refresh);
1235        }
1236    }
1237
1238    private void registerOnLayer(Layer layer) {
1239        if (layer instanceof IGeoImageLayer) {
1240            layer.addPropertyChangeListener(l -> {
1241                final List<?> currentTabLayers = this.getImageTabs().map(m -> m.layer).collect(Collectors.toList());
1242                if (Layer.NAME_PROP.equals(l.getPropertyName()) && currentTabLayers.contains(layer)) {
1243                    this.updateLayers(true);
1244                        if (((IGeoImageLayer) layer).containsImage(this.currentEntry)) {
1245                            this.updateTitle();
1246                        }
1247                } // Use Layer.VISIBLE_PROP here if we decide to do something when layer visibility changes
1248            });
1249        }
1250    }
1251
1252    private void showLayer(Layer newLayer) {
1253        if (this.currentEntry == null && newLayer instanceof GeoImageLayer) {
1254            ImageData imageData = ((GeoImageLayer) newLayer).getImageData();
1255            imageData.setSelectedImage(imageData.getFirstImage());
1256        }
1257        if (newLayer instanceof IGeoImageLayer) {
1258            this.updateLayers(true);
1259        }
1260    }
1261
1262    private void cancelLoadingImage() {
1263        if (imgLoadingFuture != null) {
1264            imgLoadingFuture.cancel(false);
1265            imgLoadingFuture = null;
1266        }
1267    }
1268}