shinestacker 1.9.0__tar.gz → 1.9.1__tar.gz

{shinestacker-1.9.0 → shinestacker-1.9.1}/CHANGELOG.md

@@ -2,9 +2,26 @@
 
 This page reports the main releases only and the main changes therein.
 
+## [v1.9.1] - 2025-10-23
+** Improved EXIF data handling GUI refinements **
+
+### Added
+- missing actions "Show EXIF Data" and "Delete EXIF Data"
+
+### Fixed
+- if saving EXIF data fails, a warning is issued instead of stopping the run
+- exif data correctly loaded when opening image file in retouch mode
+- removed duplicated parameter from config dialog (FocusStackBunch)
+- fixed thread warning when the application quits
+- more robust EXIF data code for JPG format prevents possible errors
+
+### Changed
+- improved EXIF GUI: more data displayed and improved selection logic
+
+-----
 
 ## [v1.9.0] - 2025-10-19
-** Added PNG format support and EXIF failure fix**
+** Added PNG format support and fixed EXIF failure **
 
 ### Added
 - support of images in PNG format, both in 8 bit and 16 bit depth. Note: EXIF data are not supported for 16 bit PNG because of limitations in the PIL and Open CV python libraries.

{shinestacker-1.9.0/src/shinestacker.egg-info → shinestacker-1.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shinestacker
-Version: 1.9.0
+Version: 1.9.1
 Summary: ShineStacker
 Author-email: Luca Lista <luka.lista@gmail.com>
 License-Expression: LGPL-3.0

{shinestacker-1.9.0 → shinestacker-1.9.1}/pyproject.toml

@@ -64,6 +64,8 @@ packages = [
     "shinestacker.algorithms",
     "shinestacker.gui",
     "shinestacker.gui.img",
+    "shinestacker.gui.img.dark",
+    "shinestacker.gui.img.light",
     "shinestacker.retouch"
 ]
 include-package-data = true

shinestacker-1.9.1/src/shinestacker/_version.py

@@ -0,0 +1 @@
+__version__ = '1.9.1'

{shinestacker-1.9.0 → shinestacker-1.9.1}/src/shinestacker/algorithms/exif.py

@@ -1,7 +1,5 @@
 # pylint: disable=C0114, C0116, W0718, R0911, R0912, E1101, R0915, R1702, R0914, R0917, R0913
 import os
-import re
-import io
 import logging
 import traceback
 import cv2
@@ -37,14 +35,17 @@ NO_COPY_TIFF_TAGS = ["Compression", "StripOffsets", "RowsPerStrip", "StripByteCo
 
 
 def extract_enclosed_data_for_jpg(data, head, foot):
-    size = len(foot.decode('ascii'))
-    xmp_start, xmp_end = data.find(head), data.find(foot)
-    if xmp_start != -1 and xmp_end != -1:
-        return re.sub(
-            b'[^\x20-\x7E]', b'',
-            data[xmp_start:xmp_end + size]
-        ).decode().replace('\x00', '').encode()
-    return None
+    try:
+        xmp_start = data.find(head)
+        if xmp_start == -1:
+            return None
+        xmp_end = data.find(foot, xmp_start)
+        if xmp_end == -1:
+            return None
+        xmp_end += len(foot)
+        return data[xmp_start:xmp_end]
+    except Exception:
+        return None
 
 
 def get_exif(exif_filename):
@@ -87,6 +88,21 @@ def get_exif_from_png(image):
     return exif_data
 
 
+def safe_decode_bytes(data, encoding='utf-8'):
+    if not isinstance(data, bytes):
+        return data
+    encodings = [encoding, 'latin-1', 'cp1252', 'utf-16', 'ascii']
+    for enc in encodings:
+        try:
+            return data.decode(enc, errors='strict')
+        except UnicodeDecodeError:
+            continue
+    try:
+        return data.decode('utf-8', errors='replace')
+    except Exception:
+        return "<<< decode error >>>"
+
+
 def exif_extra_tags_for_tif(exif):
     logger = logging.getLogger(__name__)
     res_x, res_y = exif.get(RESOLUTIONX), exif.get(RESOLUTIONY)
@@ -107,8 +123,13 @@ def exif_extra_tags_for_tif(exif):
             try:
                 if tag_id not in (IMAGERESOURCES, INTERCOLORPROFILE):
                     if tag_id == XMLPACKET:
-                        data = re.sub(b'[^\x20-\x7E]', b'', data)
-                    data = data.decode()
+                        try:
+                            decoded = data.decode('utf-8')
+                            data = decoded.encode('utf-8')
+                        except UnicodeDecodeError:
+                            logger.debug("XMLPACKET contains non-UTF8 data, preserving as bytes")
+                    else:
+                        data = safe_decode_bytes(data)
             except Exception:
                 logger.warning(msg=f"Copy: can't decode EXIF tag {tag:25} [#{tag_id}]")
                 data = '<<< decode error >>>'
@@ -151,32 +172,71 @@ def get_tiff_dtype_count(value):
     return 2, len(str(value)) + 1  # Default for othre cases (ASCII string)
 
 
-def add_exif_data_to_jpg_file(exif, in_filenama, out_filename, verbose=False):
+def add_exif_data_to_jpg_file(exif, in_filename, out_filename, verbose=False):
     logger = logging.getLogger(__name__)
     if exif is None:
         raise RuntimeError('No exif data provided.')
     if verbose:
         print_exif(exif)
-    xmp_data = extract_enclosed_data_for_jpg(exif[XMLPACKET], b'<x:xmpmeta', b'</x:xmpmeta>')
-    with Image.open(in_filenama) as image:
-        with io.BytesIO() as buffer:
-            image.save(buffer, format="JPEG", exif=exif.tobytes(), quality=100)
-            jpeg_data = buffer.getvalue()
-            if xmp_data is not None:
-                app1_marker_pos = jpeg_data.find(b'\xFF\xE1')
-                if app1_marker_pos == -1:
-                    app1_marker_pos = len(jpeg_data) - 2
-                updated_data = (
-                    jpeg_data[:app1_marker_pos] +
-                    b'\xFF\xE1' + len(xmp_data).to_bytes(2, 'big') +
-                    xmp_data + jpeg_data[app1_marker_pos:]
-                )
-            else:
-                logger.warning("Copy: can't find XMLPacket in JPG EXIF data")
-                updated_data = jpeg_data
-            with open(out_filename, 'wb') as f:
-                f.write(updated_data)
-    return exif
+    xmp_data = None
+    if XMLPACKET in exif:
+        xmp_data = exif[XMLPACKET]
+        if isinstance(xmp_data, bytes):
+            xmp_start = xmp_data.find(b'<x:xmpmeta')
+            xmp_end = xmp_data.find(b'</x:xmpmeta>')
+            if xmp_start != -1 and xmp_end != -1:
+                xmp_end += len(b'</x:xmpmeta>')
+                xmp_data = xmp_data[xmp_start:xmp_end]
+    with Image.open(in_filename) as image:
+        if hasattr(exif, 'tobytes'):
+            exif_bytes = exif.tobytes()
+        else:
+            exif_bytes = exif
+        image.save(out_filename, "JPEG", exif=exif_bytes, quality=100)
+        if xmp_data and isinstance(xmp_data, bytes):
+            try:
+                _insert_xmp_into_jpeg(out_filename, xmp_data, verbose)
+            except Exception as e:
+                if verbose:
+                    logger.warning(msg=f"Failed to insert XMP data: {e}")
+
+
+def _insert_xmp_into_jpeg(jpeg_path, xmp_data, verbose=False):
+    logger = logging.getLogger(__name__)
+    with open(jpeg_path, 'rb') as f:
+        jpeg_data = f.read()
+    soi_pos = jpeg_data.find(b'\xFF\xD8')
+    if soi_pos == -1:
+        if verbose:
+            logger.warning("No SOI marker found, cannot insert XMP")
+        return
+    insert_pos = soi_pos + 2
+    current_pos = insert_pos
+    while current_pos < len(jpeg_data) - 4:
+        if jpeg_data[current_pos] != 0xFF:
+            break
+        marker = jpeg_data[current_pos + 1]
+        if marker == 0xDA:
+            break
+        segment_length = int.from_bytes(jpeg_data[current_pos + 2:current_pos + 4], 'big')
+        if marker == 0xE1:
+            insert_pos = current_pos + 2 + segment_length
+            current_pos = insert_pos
+            continue
+        current_pos += 2 + segment_length
+    xmp_identifier = b'http://ns.adobe.com/xap/1.0/\x00'
+    xmp_payload = xmp_identifier + xmp_data
+    segment_length = len(xmp_payload) + 2
+    xmp_segment = b'\xFF\xE1' + segment_length.to_bytes(2, 'big') + xmp_payload
+    updated_data = (
+        jpeg_data[:insert_pos] +
+        xmp_segment +
+        jpeg_data[insert_pos:]
+    )
+    with open(jpeg_path, 'wb') as f:
+        f.write(updated_data)
+    if verbose:
+        logger.info("Successfully inserted XMP data into JPEG")
 
 
 def create_xmp_from_exif(exif_data):
@@ -263,7 +323,23 @@ def write_image_with_exif_data_png(exif, image, out_filename, verbose=False, col
         return
     pil_image = _convert_to_pil_image(image, color_order, verbose, logger)
     pnginfo, icc_profile = _prepare_png_metadata(exif, verbose, logger)
-    _save_png_with_metadata(pil_image, out_filename, pnginfo, icc_profile, verbose, logger)
+    try:
+        save_args = {'format': 'PNG', 'pnginfo': pnginfo}
+        if icc_profile:
+            save_args['icc_profile'] = icc_profile
+            if verbose:
+                logger.info(msg="Saved PNG with ICC profile and metadata")
+        else:
+            if verbose:
+                logger.info(msg="Saved PNG without ICC profile but with metadata")
+        pil_image.save(out_filename, **save_args)
+        if verbose:
+            logger.info(msg=f"Successfully wrote PNG with metadata: {out_filename}")
+    except Exception as e:
+        if verbose:
+            logger.error(msg=f"Failed to write PNG with metadata: {e}")
+            logger.error(traceback.format_exc())
+        pil_image.save(out_filename, format='PNG')
 
 
 def _convert_to_pil_image(image, color_order, verbose, logger):
@@ -374,24 +450,17 @@ def _extract_icc_profile(exif, verbose, logger):
     return None
 
 
-def _save_png_with_metadata(pil_image, out_filename, pnginfo, icc_profile, verbose, logger):
-    try:
-        save_args = {'format': 'PNG', 'pnginfo': pnginfo}
-        if icc_profile:
-            save_args['icc_profile'] = icc_profile
-            if verbose:
-                logger.info(msg="Saved PNG with ICC profile and metadata")
-        else:
-            if verbose:
-                logger.info(msg="Saved PNG without ICC profile but with metadata")
-        pil_image.save(out_filename, **save_args)
-        if verbose:
-            logger.info(msg=f"Successfully wrote PNG with metadata: {out_filename}")
-    except Exception as e:
-        if verbose:
-            logger.error(msg=f"Failed to write PNG with metadata: {e}")
-            logger.error(traceback.format_exc())
-        pil_image.save(out_filename, format='PNG')
+def write_image_with_exif_data_jpg(exif, image, out_filename, verbose):
+    cv2.imwrite(out_filename, image, [int(cv2.IMWRITE_JPEG_QUALITY), 100])
+    add_exif_data_to_jpg_file(exif, out_filename, out_filename, verbose)
+
+
+def write_image_with_exif_data_tif(exif, image, out_filename):
+    metadata = {"description": f"image generated with {constants.APP_STRING} package"}
+    extra_tags, exif_tags = exif_extra_tags_for_tif(exif)
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    tifffile.imwrite(out_filename, image, metadata=metadata, compression='adobe_deflate',
+                     extratags=extra_tags, **exif_tags)
 
 
 def write_image_with_exif_data(exif, image, out_filename, verbose=False, color_order='auto'):
@@ -401,13 +470,9 @@ def write_image_with_exif_data(exif, image, out_filename, verbose=False, color_o
     if verbose:
         print_exif(exif)
     if extension_jpg(out_filename):
-        cv2.imwrite(out_filename, image, [int(cv2.IMWRITE_JPEG_QUALITY), 100])
-        add_exif_data_to_jpg_file(exif, out_filename, out_filename, verbose)
+        write_image_with_exif_data_jpg(exif, image, out_filename, verbose)
     elif extension_tif(out_filename):
-        metadata = {"description": f"image generated with {constants.APP_STRING} package"}
-        extra_tags, exif_tags = exif_extra_tags_for_tif(exif)
-        tifffile.imwrite(out_filename, image, metadata=metadata, compression='adobe_deflate',
-                         extratags=extra_tags, **exif_tags)
+        write_image_with_exif_data_tif(exif, image, out_filename)
     elif extension_png(out_filename):
         write_image_with_exif_data_png(exif, image, out_filename, verbose, color_order=color_order)
     return exif
@@ -447,22 +512,13 @@ def copy_exif_from_file_to_file(exif_filename, in_filename, out_filename=None, v
     return save_exif_data(exif, in_filename, out_filename, verbose)
 
 
-def exif_dict(exif, hide_xml=True):
+def exif_dict(exif):
     if exif is None:
         return None
     exif_data = {}
     for tag_id in exif:
         tag = TAGS.get(tag_id, tag_id)
-        if tag_id == XMLPACKET and hide_xml:
-            data = "<<< XML data >>>"
-        elif tag_id in (IMAGERESOURCES, INTERCOLORPROFILE):
-            data = "<<< Photoshop data >>>"
-        elif tag_id == STRIPOFFSETS:
-            data = "<<< Strip offsets >>>"
-        elif tag_id == STRIPBYTECOUNTS:
-            data = "<<< Strip byte counts >>>"
-        else:
-            data = exif.get(tag_id) if hasattr(exif, 'get') else exif[tag_id]
+        data = exif.get(tag_id) if hasattr(exif, 'get') else exif[tag_id]
         if isinstance(data, bytes):
             try:
                 data = data.decode()
@@ -472,15 +528,19 @@ def exif_dict(exif, hide_xml=True):
     return exif_data
 
 
-def print_exif(exif, hide_xml=True):
-    exif_data = exif_dict(exif, hide_xml)
+def print_exif(exif):
+    exif_data = exif_dict(exif)
     if exif_data is None:
         raise RuntimeError('Image has no exif data.')
     logger = logging.getLogger(__name__)
     for tag, (tag_id, data) in exif_data.items():
         if isinstance(data, IFDRational):
             data = f"{data.numerator}/{data.denominator}"
+        data_str = f"{data}"
+        if len(data_str) > 40:
+            data_str = f"{data_str[:40]}..."
         if isinstance(tag_id, int):
-            logger.info(msg=f"{tag:25} [#{tag_id:5d}]: {data}")
+            tag_id_str = f"[#{tag_id:5d}]"
         else:
-            logger.info(msg=f"{tag:25} [ {tag_id:20} ]: {str(data)[:100]}...")
+            tag_id_str = f"[ {tag_id:20} ]"
+        logger.info(msg=f"{tag:25} {tag_id_str}: {data_str}")

{shinestacker-1.9.0 → shinestacker-1.9.1}/src/shinestacker/algorithms/stack.py

@@ -1,4 +1,4 @@
-# pylint: disable=C0114, C0115, C0116, R0913, R0917
+# pylint: disable=C0114, C0115, C0116, R0913, R0917, W0718
 import os
 import traceback
 import logging

{shinestacker-1.9.0 → shinestacker-1.9.1}/src/shinestacker/app/main.py

@@ -199,7 +199,7 @@ class MainApp(QMainWindow):
 class Application(QApplication):
     def event(self, event):
         if event.type() == QEvent.Quit and event.spontaneous():
-            if not self.quit():
+            if not self.main_app.quit():
                 return True
         return super().event(event)
 

{shinestacker-1.9.0 → shinestacker-1.9.1}/src/shinestacker/gui/action_config_dialog.py

@@ -372,10 +372,6 @@ class FocusStackBunchConfigurator(FocusStackBaseConfigurator):
         self.add_field_to_layout(
             self.general_tab_layout, 'overlap', FIELD_INT, 'Overlapping frames', required=False,
             default=constants.DEFAULT_OVERLAP, min_val=0, max_val=100)
-        self.add_field_to_layout(
-            self.general_tab_layout, 'scratch_output_dir', FIELD_BOOL,
-            'Scratch output folder before run',
-            required=False, default=True)
         self.add_field_to_layout(
             self.general_tab_layout, 'delete_output_at_end', FIELD_BOOL,
             'Delete output at end of job',

{shinestacker-1.9.0 → shinestacker-1.9.1}/src/shinestacker/gui/config_dialog.py

@@ -12,6 +12,7 @@ class ConfigDialog(QDialog):
         self.form_layout = create_form_layout(self)
         scroll_area = QScrollArea()
         scroll_area.setWidgetResizable(True)
+        scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
         container_widget = QWidget()
         self.container_layout = QFormLayout(container_widget)
         self.container_layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
@@ -19,19 +20,19 @@ class ConfigDialog(QDialog):
         self.container_layout.setFormAlignment(Qt.AlignLeft | Qt.AlignTop)
         self.container_layout.setLabelAlignment(Qt.AlignLeft)
         scroll_area.setWidget(container_widget)
-        button_box = QHBoxLayout()
+        self.button_box = QHBoxLayout()
         self.ok_button = QPushButton("OK")
         self.ok_button.setFocus()
         self.cancel_button = QPushButton("Cancel")
         self.reset_button = QPushButton("Reset")
-        button_box.addWidget(self.ok_button)
-        button_box.addWidget(self.cancel_button)
-        button_box.addWidget(self.reset_button)
+        self.button_box.addWidget(self.ok_button)
+        self.button_box.addWidget(self.cancel_button)
+        self.button_box.addWidget(self.reset_button)
         self.reset_button.clicked.connect(self.reset_to_defaults)
         self.ok_button.clicked.connect(self.accept)
         self.cancel_button.clicked.connect(self.reject)
         self.form_layout.addRow(scroll_area)
-        self.form_layout.addRow(button_box)
+        self.form_layout.addRow(self.button_box)
         QTimer.singleShot(0, self.adjust_dialog_size)
         self.create_form_content()
 

shinestacker-1.9.1/src/shinestacker/retouch/exif_data.py

@@ -0,0 +1,75 @@
+# pylint: disable=C0114, C0115, C0116, E0611, W0718
+from xml.dom import minidom
+from PIL.TiffImagePlugin import IFDRational
+from PySide6.QtWidgets import QLabel, QTextEdit
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QFontDatabase
+from .. algorithms.exif import exif_dict
+from .. gui.config_dialog import ConfigDialog
+
+
+class ExifData(ConfigDialog):
+    def __init__(self, exif, title="EXIF Data", parent=None, show_buttons=True):
+        self.exif = exif
+        super().__init__(title, parent)
+        self.reset_button.setVisible(False)
+        self.cancel_button.setVisible(show_buttons)
+        if not show_buttons:
+            self.ok_button.setFixedWidth(100)
+            self.button_box.setAlignment(Qt.AlignCenter)
+
+    def is_likely_xml(self, text):
+        if not isinstance(text, str):
+            return False
+        text = text.strip()
+        return (text.startswith('<?xml') or
+                text.startswith('<x:xmpmeta') or
+                text.startswith('<rdf:RDF') or
+                text.startswith('<?xpacket') or
+                (text.startswith('<') and text.endswith('>') and
+                 any(tag in text for tag in ['<rdf:', '<xmp:', '<dc:', '<tiff:'])))
+
+    def prettify_xml(self, xml_string):
+        try:
+            parsed = minidom.parseString(xml_string)
+            pretty_xml = parsed.toprettyxml(indent="  ")
+            lines = [line for line in pretty_xml.split('\n') if line.strip()]
+            if lines and lines[0].startswith('<?xml version="1.0" ?>'):
+                lines = lines[1:]
+            return '\n'.join(lines)
+        except Exception:
+            return xml_string
+
+    def create_form_content(self):
+        if self.exif is None:
+            data = {}
+        else:
+            data = exif_dict(self.exif)
+        if len(data) > 0:
+            for k, (_, d) in data.items():
+                if isinstance(d, IFDRational):
+                    d = f"{d.numerator}/{d.denominator}"
+                d_str = str(d)
+                if "<<<" not in d_str and k != 'IPTCNAA':
+                    if len(d_str) <= 40:
+                        self.container_layout.addRow(f"<b>{k}:</b>", QLabel(d_str))
+                    else:
+                        if self.is_likely_xml(d_str):
+                            d_str = self.prettify_xml(d_str)
+                        text_edit = QTextEdit()
+                        text_edit.setPlainText(d_str)
+                        text_edit.setReadOnly(True)
+                        text_edit.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+                        text_edit.setLineWrapMode(QTextEdit.WidgetWidth)
+                        text_edit.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+                        text_edit.setFixedWidth(400)
+                        font = QFontDatabase.systemFont(QFontDatabase.FixedFont)
+                        font.setPointSize(10)
+                        text_edit.setFont(font)
+                        font.setPointSize(11)
+                        text_edit.setFont(font)
+                        text_edit.setFixedHeight(200)
+                        text_edit.setFixedHeight(100)
+                        self.container_layout.addRow(f"<b>{k}:</b>", text_edit)
+        else:
+            self.container_layout.addRow("No EXIF Data", QLabel(''))

{shinestacker-1.9.0 → shinestacker-1.9.1}/src/shinestacker/retouch/image_editor_ui.py

@@ -1,7 +1,8 @@
 # pylint: disable=C0114, C0115, C0116, E0611, R0902, R0914, R0915, R0904, W0108
 from functools import partial
 from PySide6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QFrame, QLabel, QMenu,
-                               QListWidget, QSlider, QMainWindow, QMessageBox)
+                               QFileDialog, QListWidget, QSlider, QMainWindow, QMessageBox,
+                               QDialog)
 from PySide6.QtGui import QShortcut, QKeySequence, QAction, QActionGroup
 from PySide6.QtCore import Qt
 from PySide6.QtGui import QGuiApplication
@@ -9,6 +10,7 @@ from .. config.constants import constants
 from .. config.app_config import AppConfig
 from .. config.gui_constants import gui_constants
 from .. gui.recent_file_manager import RecentFileManager
+from .. algorithms.exif import get_exif
 from .image_viewer import ImageViewer
 from .shortcuts_help import ShortcutsHelp
 from .brush import Brush
@@ -26,6 +28,7 @@ from .white_balance_filter import WhiteBalanceFilter
 from .vignetting_filter import VignettingFilter
 from .adjustments import LumiContrastFilter, SaturationVibranceFilter
 from .transformation_manager import TransfromationManager
+from .exif_data import ExifData
 
 
 class ImageEditorUI(QMainWindow, LayerCollectionHandler):
@@ -183,6 +186,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.thumbnail_list.setFixedWidth(gui_constants.THUMB_WIDTH)
         self.thumbnail_list.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
         self.thumbnail_list.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+        self.exif_dialog = None
 
         def change_layer_item(item):
             layer_idx = self.thumbnail_list.row(item)
@@ -266,8 +270,17 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
 
         file_menu.addAction("&Close", self.close_file, "Ctrl+W")
         file_menu.addSeparator()
+        show_exif_action = QAction("Show EXIF Data", self)
+        show_exif_action.triggered.connect(self.show_exif_data)
+        show_exif_action.setProperty("requires_file", True)
+        file_menu.addAction(show_exif_action)
+        delete_exif_action = QAction("Delete EXIF Data", self)
+        delete_exif_action.triggered.connect(self.delete_exif_data)
+        delete_exif_action.setProperty("requires_file", True)
+        file_menu.addAction(delete_exif_action)
+        file_menu.addSeparator()
         file_menu.addAction("&Import Frames", self.io_gui_handler.import_frames)
-        file_menu.addAction("Import &EXIF Data", self.io_gui_handler.select_exif_path)
+        file_menu.addAction("Import &EXIF Data", self.select_exif_path)
 
         edit_menu = menubar.addMenu("&Edit")
         self.undo_action = QAction("Undo", self)
@@ -676,6 +689,36 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
                 self.redo_action.setText("Redo")
                 self.redo_action.setEnabled(False)
 
+    def select_exif_path(self):
+        path, _ = QFileDialog.getOpenFileName(None, "Select file with exif data")
+        if path:
+            temp_exif_data = get_exif(path)
+            self.exif_dialog = ExifData(temp_exif_data, "Import Selected EXIF Data",
+                                        self.parent(), show_buttons=True)
+            result = self.exif_dialog.exec()
+            if result == QDialog.Accepted:
+                self.io_gui_handler.set_exif_data(temp_exif_data, path)
+                self.show_status_message(f"EXIF data loaded from {path}.")
+            else:
+                self.show_status_message("EXIF data loading cancelled.")
+
+    def show_exif_data(self):
+        self.exif_dialog = ExifData(self.io_gui_handler.exif_data, "EXIF Data",
+                                    self.parent(), show_buttons=False)
+        self.exif_dialog.exec()
+
+    def delete_exif_data(self):
+        reply = QMessageBox.question(
+            self,
+            "Confirm Delete",
+            "Warning: the current EXIF data will be erased.\n\nDo you want to continue?",
+            QMessageBox.Yes | QMessageBox.No,
+            QMessageBox.No
+        )
+        if reply == QMessageBox.Yes:
+            self.io_gui_handler.exif_data = None
+            self.io_gui_handler.exif_path = ''
+
     def luminosity_filter(self):
         self.filter_manager.apply("Luminosity, Contrast")
 

{shinestacker-1.9.0 → shinestacker-1.9.1}/src/shinestacker/retouch/io_gui_handler.py

@@ -10,7 +10,6 @@ from PySide6.QtCore import Qt, QObject, QTimer, Signal
 from .. algorithms.utils import EXTENSIONS_GUI_STR, EXTENSIONS_GUI_SAVE_STR
 from .. algorithms.exif import get_exif, write_image_with_exif_data
 from .file_loader import FileLoader
-from .exif_data import ExifData
 from .io_threads import FileMultilayerSaver, FrameImporter
 from .layer_collection import LayerCollectionHandler
 
@@ -33,7 +32,6 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
         self.image_viewer = None
         self.loading_dialog = None
         self.loading_timer = None
-        self.exif_dialog = None
         self.saver_thread = None
         self.saving_dialog = None
         self.saving_timer = None
@@ -47,6 +45,10 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
         self.exif_data = None
         self.exif_path = ''
 
+    def set_exif_data(self, data, path):
+        self.exif_data = data
+        self.exif_path = path
+
     def current_file_path(self):
         return self.current_file_path_master if self.save_master_only.isChecked() \
             else self.current_file_path_multi
@@ -164,6 +166,8 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
         self.loader_thread.finished.connect(self.on_file_loaded)
         self.loader_thread.error.connect(self.on_file_error)
         self.loader_thread.start()
+        self.exif_path = self.current_file_path_master
+        self.exif_data = get_exif(self.exif_path)
 
     def import_frames(self):
         file_paths, _ = QFileDialog.getOpenFileNames(
@@ -196,6 +200,9 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
         self.frame_importer_thread.error.connect(self.on_frames_import_error)
         self.frame_importer_thread.progress.connect(self.update_import_progress)
         self.frame_importer_thread.start()
+        if self.exif_data is None:
+            self.exif_path = file_paths[0]
+            self.exif_data = get_exif(self.exif_path)
 
     def update_import_progress(self, percent, filename):
         if hasattr(self, 'progress_bar'):
@@ -304,15 +311,6 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
             traceback.print_tb(e.__traceback__)
             QMessageBox.critical(self.parent(), "Save Error", f"Could not save file: {str(e)}")
 
-    def select_exif_path(self):
-        path, _ = QFileDialog.getOpenFileName(None, "Select file with exif data")
-        if path:
-            self.exif_path = path
-            self.exif_data = get_exif(path)
-            self.status_message_requested.emit(f"EXIF data extracted from {path}.")
-        self.exif_dialog = ExifData(self.exif_data, self.parent())
-        self.exif_dialog.exec()
-
     def close_file(self):
         self.mark_as_modified_requested.emit(False)
         self.layer_collection.reset()

{shinestacker-1.9.0 → shinestacker-1.9.1/src/shinestacker.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shinestacker
-Version: 1.9.0
+Version: 1.9.1
 Summary: ShineStacker
 Author-email: Luca Lista <luka.lista@gmail.com>
 License-Expression: LGPL-3.0

shinestacker-1.9.0/src/shinestacker/_version.py

@@ -1 +0,0 @@
-__version__ = '1.9.0'