rapid-photo-downloader 0.9.9-1 / usr / lib / python3 / dist-packages / raphodo / nameeditor.py

#!/usr/bin/env python3
# Copyright (C) 2016-2018 Damon Lynch <damonlynch@gmail.com>

# This file is part of Rapid Photo Downloader.
#
# Rapid Photo Downloader is free software: you can redistribute it and/or
# modify it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Rapid Photo Downloader is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Rapid Photo Downloader.  If not,
# see <http://www.gnu.org/licenses/>.

"""
Dialog for editing download subfolder structure and file renaming
"""

__author__ = 'Damon Lynch'
__copyright__ = "Copyright 2016-2018, Damon Lynch"

from typing import Dict, Optional, List, Union, Tuple, Sequence
import webbrowser
import datetime
import copy
import logging

from gettext import gettext as _

from PyQt5.QtWidgets import (
    QTextEdit, QApplication, QComboBox, QPushButton, QLabel, QDialog, QDialogButtonBox,
    QVBoxLayout, QFormLayout, QGridLayout, QGroupBox, QScrollArea, QWidget, QFrame, QStyle,
    QSizePolicy, QLineEdit, QMessageBox
)
from PyQt5.QtGui import (
    QTextCharFormat, QFont, QTextCursor, QMouseEvent, QSyntaxHighlighter, QTextDocument, QBrush,
    QColor, QFontMetrics, QKeyEvent, QResizeEvent, QStandardItem, QWheelEvent
)
from PyQt5.QtCore import (Qt, pyqtSlot, QSignalMapper, QSize, pyqtSignal)

from sortedcontainers import SortedList

from raphodo.generatenameconfig import *
import raphodo.generatename as gn
from raphodo.constants import (
    CustomColors, PrefPosition, NameGenerationType, PresetPrefType, PresetClass
)
from raphodo.rpdfile import SamplePhoto, SampleVideo, RPDFile, Photo, Video, FileType
from raphodo.preferences import DownloadsTodayTracker, Preferences, match_pref_list
import raphodo.exiftool as exiftool
from raphodo.utilities import remove_last_char_from_list_str
from raphodo.messagewidget import MessageWidget
from raphodo.viewutils import translateButtons
import raphodo.qrc_resources


class PrefEditor(QTextEdit):
    """
    File renaming and subfolder generation preference editor
    """

    prefListGenerated = pyqtSignal()

    def __init__(self, subfolder: bool, parent=None) -> None:
        """
        :param subfolder: if True, the editor is for editing subfolder generation
        """

        super().__init__(parent)
        self.subfolder = subfolder

        self.user_pref_list = []  # type: List[str]
        self.user_pref_colors = []  # type: List[str]

        self.heightMin = 0
        self.heightMax = 65000
        # Start out with about 4 lines in height:
        self.setMinimumHeight(QFontMetrics(self.font()).lineSpacing() * 5)
        self.document().documentLayout().documentSizeChanged.connect(self.wrapHeightToContents)

    def wrapHeightToContents(self) -> None:
        """
        Adjust the text area size to show contents without vertical scrollbar

        Derived from:
        http://stackoverflow.com/questions/11851020/a-qwidget-like-qtextedit-that-wraps-its-height-
        automatically-to-its-contents/11858803#11858803
        """

        docHeight = self.document().size().height() + 5
        if self.heightMin <= docHeight <= self.heightMax and docHeight > self.minimumHeight():
            self.setMinimumHeight(docHeight)

    def mousePressEvent(self, event: QMouseEvent) -> None:
        """
        Automatically select a pref value if it was clicked in
        :param event:  the mouse event
        """

        super().mousePressEvent(event)
        if event.button() == Qt.LeftButton:
            position = self.textCursor().position()
            pref_pos, start, end, left_start, left_end = self.locatePrefValue(position)

            if pref_pos == PrefPosition.on_left:
                start = left_start
                end = left_end
            if pref_pos != PrefPosition.not_here:
                cursor = self.textCursor()
                cursor.setPosition(start)
                cursor.setPosition(end + 1, QTextCursor.KeepAnchor)
                self.setTextCursor(cursor)

    def keyPressEvent(self, event: QKeyEvent) -> None:
        """
        Automatically select pref values when navigating through the document.

        Suppress the return / enter key.

        :param event: the key press event
        """

        key = event.key()
        if key in (Qt.Key_Enter, Qt.Key_Return, Qt.Key_Tab):
            return

        cursor = self.textCursor()  # type: QTextCursor

        if cursor.hasSelection() and key in (Qt.Key_Left, Qt.Key_Right):
            # Pass the key press on and let the selection deselect
            pass
        elif key in (Qt.Key_Left, Qt.Key_Right, Qt.Key_Home, Qt.Key_End, Qt.Key_PageUp,
                   Qt.Key_PageDown, Qt.Key_Up, Qt.Key_Down):
            # Navigation key was pressed

            # Was ctrl key pressed too?
            ctrl_key = event.modifiers() & Qt.ControlModifier

            selection_start = selection_end = -1

            # This event is called before the cursor is moved, so
            # move the cursor as if it would be moved
            if key == Qt.Key_Right and not cursor.atEnd():
                if ctrl_key:
                    cursor.movePosition(QTextCursor.WordRight)
                else:
                    cursor.movePosition(QTextCursor.Right)
            elif key == Qt.Key_Left and not cursor.atStart():
                if ctrl_key:
                    cursor.movePosition(QTextCursor.WordLeft)
                else:
                    cursor.movePosition(QTextCursor.Left)
            elif key == Qt.Key_Up:
                cursor.movePosition(QTextCursor.Up)
            elif key == Qt.Key_Down:
                cursor.movePosition(QTextCursor.Down)
            elif key in (Qt.Key_Home, Qt.Key_PageUp):
                if ctrl_key or key == Qt.Key_PageUp:
                    cursor.movePosition(QTextCursor.StartOfBlock)
                else:
                    cursor.movePosition(QTextCursor.StartOfLine)
            elif key in (Qt.Key_End, Qt.Key_PageDown):
                if ctrl_key or key == Qt.Key_PageDown:
                    cursor.movePosition(QTextCursor.EndOfBlock)
                else:
                    cursor.movePosition(QTextCursor.EndOfLine)

            # Get position of where the cursor would move to
            position = cursor.position()

            # Determine if there is a pref value to the left or at that position
            pref_pos, start, end, left_start, left_end = self.locatePrefValue(position)
            if pref_pos == PrefPosition.on_left:
                selection_start = left_start
                selection_end = left_end + 1
            elif pref_pos == PrefPosition.at:
                selection_start = end + 1
                selection_end = start
            elif pref_pos == PrefPosition.positioned_in:
                if key == Qt.Key_Left or key == Qt.Key_Home:
                    # because moving left, position the cursor on the left
                    selection_start = end + 1
                    selection_end = start
                else:
                    # because moving right, position the cursor on the right
                    selection_start = start
                    selection_end = end + 1

            if selection_end >= 0 and selection_start >= 0:
                cursor.setPosition(selection_start)
                cursor.setPosition(selection_end, QTextCursor.KeepAnchor)
                self.setTextCursor(cursor)
                return

        super().keyPressEvent(event)

    def locatePrefValue(self, position: int) -> Tuple[PrefPosition, int, int, int, int]:
        """
        Determine where pref values are relative to the position passed.

        :param position: some position in text, e.g. cursor position
        :return: enum indicating where prefs are found and their start and end
         positions. Return positions are -1 if not found.
        """

        start = end = -1
        left_start = left_end = -1
        pref_position = PrefPosition.not_here
        b = self.highlighter.boundaries
        if not(len(b)):
            return (pref_position, start, end, left_start, left_end)

        index = b.bisect_left((position, 0))
        # Special cases
        if index == 0:
            # At or to the left of the first pref value
            if b[0][0] == position:
                pref_position = PrefPosition.at
                start, end = b[0]
        elif index == len(b):
            # To the right of or in the last pref value
            if position <= b[-1][1]:
                start, end = b[-1]
                pref_position = PrefPosition.positioned_in
            elif b[-1][1] == position - 1:
                left_start, left_end = b[-1]
                pref_position = PrefPosition.on_left
        else:
            left = b[index -1]
            right = b[index]

            at = right[0] == position
            to_left = left[1] == position -1
            if at and to_left:
                pref_position = PrefPosition.on_left_and_at
                start, end = right
                left_start, left_end = left
            elif at:
                pref_position = PrefPosition.at
                start, end = right
            elif to_left:
                pref_position = PrefPosition.on_left
                left_start, left_end = left
            elif position <= left[1]:
                pref_position = PrefPosition.positioned_in
                start, end = b[index - 1]

        return (pref_position, start, end, left_start, left_end)

    def displayPrefList(self, pref_list: Sequence[str]) -> None:
        p = pref_list
        values = []
        for i in range(0, len(pref_list), 3):
            try:
                value = '<{}>'.format(self.pref_mapper[(p[i], p[i+1], p[i+2])])
            except KeyError:
                if p[i] == SEPARATOR:
                    value = SEPARATOR
                else:
                    assert p[i] == TEXT
                    value = p[i+1]
            values.append(value)

        self.document().clear()
        cursor = self.textCursor()  # type: QTextCursor
        cursor.insertText(''.join(values))

    def insertPrefValue(self, pref_value: str) -> None:
        cursor = self.textCursor()  # type: QTextCursor
        cursor.insertText('<{}>'.format(pref_value))

    def _setHighlighter(self) -> None:
        self.highlighter = PrefHighlighter(
            list(self.string_to_pref_mapper.keys()), self.pref_color, self.document()
        )

        # when color coding of text in the editor is complete,
        # generate the preference list
        self.highlighter.blockHighlighted.connect(self.generatePrefList)

    def setPrefMapper(self, pref_mapper: Dict[Tuple[str, str, str], str],
                      pref_color: Dict[str, str]) -> None:
        self.pref_mapper = pref_mapper
        self.string_to_pref_mapper = {value: key for key, value in pref_mapper.items()}

        self.pref_color = pref_color
        self._setHighlighter()

    def _parseTextFragment(self, text_fragment) -> None:
        if self.subfolder:
            text_fragments = text_fragment.split(os.sep)
            for index, text_fragment in enumerate(text_fragments):
                if text_fragment:
                    self.user_pref_list.extend([TEXT, text_fragment, ''])
                    self.user_pref_colors.append('')
                if index < len(text_fragments) - 1:
                    self.user_pref_list.extend([SEPARATOR, '', ''])
                    self.user_pref_colors.append('')
        else:
            self.user_pref_list.extend([TEXT, text_fragment, ''])
            self.user_pref_colors.append('')

    def _addColor(self, pref_defn: str) -> None:
        self.user_pref_colors.append(self.pref_color[pref_defn])

    @pyqtSlot()
    def generatePrefList(self) -> None:
        """
        After syntax highlighting has completed, use its findings
        to generate the user's pref list
        """

        text = self.document().toPlainText()
        b = self.highlighter.boundaries

        self.user_pref_list = pl = []  # type: List[str]
        self.user_pref_colors = []  # type: List[str]

        # Handle any text at the very beginning
        if b and b[0][0] > 0:
            text_fragment = text[:b[0][0]]
            self._parseTextFragment(text_fragment)

        if len(b) > 1:
            for index, item in enumerate(b[1:]):
                start, end = b[index]
                # Add + 1 to start to remove the opening <
                pl.extend(self.string_to_pref_mapper[text[start + 1: end]])
                # Add + 1 to start to include the closing >
                self._addColor(text[start: end + 1])

                text_fragment = text[b[index][1] + 1:item[0]]
                self._parseTextFragment(text_fragment)

        # Handle the final pref value
        if b:
            start, end = b[-1]
            # Add + 1 to start to remove the opening <
            pl.extend(self.string_to_pref_mapper[text[start + 1: end]])
            # Add + 1 to start to include the closing >
            self._addColor(text[start: end + 1])
            final = end + 1
        else:
            final = 0

        # Handle any remaining text at the very end (or the complete string if there are
        # no pref definition values)
        if final < len(text):
            text_fragment = text[final:]
            self._parseTextFragment(text_fragment)

        assert len(self.user_pref_colors) == len(self.user_pref_list) / 3
        self.prefListGenerated.emit()


class PrefHighlighter(QSyntaxHighlighter):
    """
    Highlight non-text preference values in the editor
    """

    blockHighlighted = pyqtSignal()

    def __init__(self, pref_defn_strings: List[str],
                 pref_color: Dict[str, str],
                 document: QTextDocument) -> None:
        super().__init__(document)

        # Where detected preference values start and end:
        # [(start, end), (start, end), ...]
        self.boundaries = SortedList()

        pref_defns = ('<{}>'.format(pref) for pref in pref_defn_strings)
        self.highlightingRules = []
        for pref in pref_defns:
            format = QTextCharFormat()
            format.setForeground(QBrush(QColor(pref_color[pref])))
            self.highlightingRules.append((pref, format))

    def find_all(self, text: str, pref_defn: str):
        """
        Find all occurrences of a preference definition in the text
        :param text: text to search
        :param pref_defn: the preference definition
        :return: yield the position in the document's text
        """
        if not len(pref_defn):
            raise StopIteration
        start = 0
        while True:
            start = text.find(pref_defn, start)
            if start == -1:
                raise StopIteration
            yield start
            start += len(pref_defn)

    def highlightBlock(self, text: str) -> None:

        # Recreate the preference value from scratch
        self.boundaries = SortedList()

        for expression, format in self.highlightingRules:
            for index in self.find_all(text, expression):
                length = len(expression)
                self.setFormat(index, length, format)
                self.boundaries.add((index, index + length - 1))

        self.blockHighlighted.emit()


def make_subfolder_menu_entry(prefs: Tuple[str]) -> str:
    """
    Create the text for a menu / combobox item

    :param prefs: single pref item, with title and elements
    :return: item text
    """

    desc = prefs[0]
    elements = prefs[1:]
    return _("%(description)s - %(elements)s") % dict(
        description=desc, elements=os.sep.join(elements)
    )


def make_rename_menu_entry(prefs: Tuple[str]) -> str:
    """
    Create the text for a menu / combobox item

    :param prefs: single pref item, with title and elements
    :return: item text
    """

    desc = prefs[0]
    elements = prefs[1]
    return _("%(description)s - %(elements)s") % dict(description=desc, elements=elements)


class PresetComboBox(QComboBox):
    """
    Combox box displaying built-in presets, custom presets,
    and some commands relating to preset management.

    Used in in dialog window used to edit name generation and
    also in the rename files panel.
    """

    def __init__(self, prefs: Preferences,
                 preset_names: List[str],
                 preset_type: PresetPrefType,
                 edit_mode: bool,
                 parent=None) -> None:
        """
        :param prefs: program preferences
        :param preset_names: list of custom preset names
        :param preset_type: one of photo rename, video rename,
         photo subfolder, or video subfolder
        :param edit_mode: if True, the combo box is being displayed
         in an edit dialog window, else it's being displayed in the
         file rename panel
        :param parent: parent widget
        """

        super().__init__(parent)
        self.edit_mode = edit_mode
        self.prefs = prefs

        self.preset_edited = False
        self.new_preset = False

        self.preset_type = preset_type

        if preset_type == PresetPrefType.preset_photo_subfolder:
            self.builtin_presets = PHOTO_SUBFOLDER_MENU_DEFAULTS
        elif preset_type == PresetPrefType.preset_video_subfolder:
            self.builtin_presets = VIDEO_SUBFOLDER_MENU_DEFAULTS
        elif preset_type == PresetPrefType.preset_photo_rename:
            self.builtin_presets = PHOTO_RENAME_MENU_DEFAULTS
        else:
            assert preset_type == PresetPrefType.preset_video_rename
            self.builtin_presets = VIDEO_RENAME_MENU_DEFAULTS

        self._setup_entries(preset_names)

    def _setup_entries(self, preset_names: List[str]) -> None:

        idx = 0

        if self.edit_mode:
            for pref in self.builtin_presets:
                self.addItem(make_subfolder_menu_entry(pref), PresetClass.builtin)
                idx += 1
        else:
            for pref in self.builtin_presets:
                self.addItem(pref[0], PresetClass.builtin)
                idx += 1

        if not len(preset_names):
            # preset_separator bool is used to indicate the existence of
            # a separator in the combo box that is used to distinguish
            # custom from built-in prests
            self.preset_separator = False
        else:
            self.preset_separator = True

            self.insertSeparator(idx)
            idx += 1

            for name in preset_names:
                self.addItem(name, PresetClass.custom)
                idx += 1

        self.insertSeparator(idx)

        if self.edit_mode:
            self.addItem(_('Save New Custom Preset...'), PresetClass.new_preset)
            self.addItem(_('Remove All Custom Presets...'), PresetClass.remove_all)
            self.setRemoveAllCustomEnabled(bool(len(preset_names)))
        else:
            self.addItem(_('Custom...'), PresetClass.start_editor)

    def resetEntries(self, preset_names: List[str]) -> None:
        assert not self.edit_mode
        self.clear()
        self._setup_entries(preset_names)

    def addCustomPreset(self, text: str) -> None:
        """
        Adds a new custom preset name to the comboxbox and sets the
        combobox to display it.

        :param text: the custom preset name
        """

        assert self.edit_mode
        if self.new_preset or self.preset_edited:
            self.resetPresetList()
        if not self.preset_separator:
            self.insertSeparator(len(self.builtin_presets))
            self.preset_separator = True
        idx = len(self.builtin_presets) + 1
        self.insertItem(idx, text, PresetClass.custom)
        self.setCurrentIndex(idx)

    def removeAllCustomPresets(self, no_presets: int) -> None:
        assert self.edit_mode
        assert self.preset_separator
        start = len(self.builtin_presets)
        if self.new_preset:
            start += 2
        elif self.preset_edited:
            self.resetPresetList()
        end = start + no_presets
        for row in range(end, start -1, -1):
            self.removeItem(row)
        self.preset_separator = False

    def setPresetNew(self) -> None:
        assert self.edit_mode
        assert not self.preset_edited
        if self.new_preset:
            return
        item_text = _('(New Custom Preset)')
        self.new_preset = True
        self.insertItem(0, item_text, PresetClass.edited)
        self.insertSeparator(1)
        self.setCurrentIndex(0)

    def setPresetEdited(self, text: str) -> None:
        """
        Adds a new entry at the top of the combobox indicating that the current
        preset has been edited.

        :param text: the preset name to use
        """

        assert self.edit_mode
        assert not self.new_preset
        assert not self.preset_edited
        item_text = _('%s (edited)') % text
        self.insertItem(0, item_text, PresetClass.edited)
        self.insertSeparator(1)
        self.addItem(_('Update Custom Preset "%s"') % text, PresetClass.update_preset)
        self.preset_edited = True
        self.setCurrentIndex(0)

    def resetPresetList(self) -> None:
        """
        Removes the combo box first line 'Preset name (edited)' or '(New Custom Preset)',
        and its separator
        """

        assert self.edit_mode
        assert self.new_preset or self.preset_edited
        # remove combo box first line 'Preset name (edited)' or '(New Custom Preset)'
        self.removeItem(0)
        # remove separator
        self.removeItem(0)
        # remove Update Preset
        if self.preset_edited:
            index = self.count() - 1
            self.removeItem(index)
        self.preset_edited = self.new_preset = False

    def _setRowEnabled(self, enabled: bool, offset: int) -> None:
        assert self.edit_mode
        # Our big assumption here is that the model is a QStandardItemModel
        model = self.model()
        count = self.count()
        if self.preset_edited:
            row = count - offset - 1
        else:
            row = count - offset
        item = model.item(row, 0)  # type: QStandardItem
        if not enabled:
            item.setFlags(Qt.NoItemFlags)
        else:
            item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)

    def setRemoveAllCustomEnabled(self, enabled: bool) -> None:
        self._setRowEnabled(enabled=enabled, offset=1)

    def setSaveNewCustomPresetEnabled(self, enabled: bool) -> None:
        self._setRowEnabled(enabled=enabled, offset=2)

    def getComboBoxIndex(self, preset_index: int) -> int:
        """
        Calculate the index into the combo box list allowing for the separator
        and other elements in the list of entries the user sees

        :param preset_index: the preset index (built-in & custom)
        :return: the index into the actual combobox entries including
         any separators etc.
        """

        if self.edit_mode and (self.new_preset or self.preset_edited):
            preset_index += 2
        if preset_index < len(self.builtin_presets):
            return preset_index
        else:
            assert self.preset_separator
            return preset_index + 1

    def getPresetIndex(self, combobox_index: int) -> int:
        """
        Opposite of getComboBoxIndex: calculates the preset index based on the
        given combo box index (which includes separators etc.)
        :param combobox_index: the index into the combobox entries the user sees
        :return: the index into the presets (built-in & custom)
        """

        if self.edit_mode and (self.new_preset or self.preset_edited):
            combobox_index -= 2
        if combobox_index < len(self.builtin_presets):
            return combobox_index
        else:
            assert self.preset_separator
            return combobox_index - 1


class CreatePreset(QDialog):
    """
    Very simple dialog window that allows user entry of new preset name.

    Save button is disabled when the current name entered equals an existing
    preset name or is empty.
    """

    def __init__(self, existing_custom_names: List[str], parent=None) -> None:
        super().__init__(parent)

        self.existing_custom_names = existing_custom_names

        self.setModal(True)

        title = _("Save New Custom Preset - Rapid Photo Downloader")
        self.setWindowTitle(title)

        self.name = QLineEdit()
        metrics = QFontMetrics(QFont())
        self.name.setMinimumWidth(metrics.width(title))
        self.name.textEdited.connect(self.nameEdited)
        flayout = QFormLayout()
        flayout.addRow(_('Preset Name:'), self.name)

        buttonBox = QDialogButtonBox()
        buttonBox.addButton(QDialogButtonBox.Cancel)  # type: QPushButton
        self.saveButton = buttonBox.addButton(QDialogButtonBox.Save)  # type: QPushButton
        self.saveButton.setEnabled(False)
        translateButtons(buttonBox)
        buttonBox.rejected.connect(self.reject)
        buttonBox.accepted.connect(self.accept)

        layout = QVBoxLayout()
        layout.addLayout(flayout)
        layout.addWidget(buttonBox)

        self.setLayout(layout)

    @pyqtSlot(str)
    def nameEdited(self, name: str):
        enabled = False
        if len(name) > 0:
            enabled = name not in self.existing_custom_names
        self.saveButton.setEnabled(enabled)

    def presetName(self) -> str:
        """
        :return: the name of the name the user wants to save the preset as
        """

        return self.name.text()


def make_sample_rpd_file(sample_job_code: str,
                         prefs: Preferences,
                         generation_type: NameGenerationType,
                         sample_rpd_file: Optional[Union[Photo, Video]]=None) -> Union[
                                                                                 Photo, Video]:
    """
    Create a sample_rpd_file used for displaying to the user an example of their
    file renaming preference in action on a sample file.

    :param sample_job_code: sample of a Job Code
    :param prefs: user preferences
    :param generation_type: one of photo/video filenames/subfolders
    :param sample_rpd_file: sample RPDFile that will possibly be overwritten
     with new values
    :return: sample RPDFile
    """

    downloads_today_tracker = DownloadsTodayTracker(
        day_start=prefs.day_start,
        downloads_today=prefs.downloads_today
    )
    sequences = gn.Sequences(downloads_today_tracker, prefs.stored_sequence_no)
    if sample_rpd_file is not None:
        if sample_rpd_file.metadata is None:
            logging.debug('Sample file is missing its metadata')
            sample_rpd_file = None
        else:
            sample_rpd_file.sequences = sequences
            sample_rpd_file.download_start_time = datetime.datetime.now()

    else:
        # sample_rpd_file is None
        if generation_type in (NameGenerationType.photo_name,
                               NameGenerationType.photo_subfolder):
            sample_rpd_file = SamplePhoto(sequences=sequences)
        else:
            sample_rpd_file = SampleVideo(sequences=sequences)

    sample_rpd_file.job_code = sample_job_code
    sample_rpd_file.strip_characters = prefs.strip_characters
    if sample_rpd_file.file_type == FileType.photo:
        sample_rpd_file.generate_extension_case = prefs.photo_extension
    else:
        sample_rpd_file.generate_extension_case = prefs.video_extension

    return sample_rpd_file


class EditorCombobox(QComboBox):
    """
    Regular combobox, but ignores the mouse wheel
    """

    def wheelEvent(self, event: QWheelEvent) -> None:
        event.ignore()


class PrefDialog(QDialog):
    """
    Dialog window to allow editing of file renaming and subfolder generation
    """

    def __init__(self, pref_defn: OrderedDict,
                 user_pref_list: List[str],
                 generation_type: NameGenerationType,
                 prefs: Preferences,
                 sample_rpd_file: Optional[Union[Photo, Video]]=None,
                 max_entries=0,
                 parent=None) -> None:
        """
        Set up dialog to display all its controls based on the preference
        definition being used.

        :param pref_defn: definition of possible preference choices, i.e.
         one of DICT_VIDEO_SUBFOLDER_L0, DICT_SUBFOLDER_L0, DICT_VIDEO_RENAME_L0
         or DICT_IMAGE_RENAME_L0
        :param user_pref_list: the user's actual rename / subfolder generation
         preferences
        :param generation_type: enum specifying what kind of name is being edited
         (one of photo filename, video filename, photo subfolder, video subfolder)
        :param prefs: program preferences
        :param exiftool_process: daemon exiftool process
        :param sample_rpd_file: a sample photo or video, whose contents will be
         modified (i.e. don't pass a live RPDFile)
        :param max_entries: maximum number of entries that will be displayed
         to the user (in a menu, for example)
        """

        super().__init__(parent)

        self.setModal(True)

        self.generation_type = generation_type
        if generation_type == NameGenerationType.photo_subfolder:
            self.setWindowTitle(_('Photo Subfolder Generation Editor'))
            self.preset_type = PresetPrefType.preset_photo_subfolder
            self.builtin_pref_lists = PHOTO_SUBFOLDER_MENU_DEFAULTS_CONV
            self.builtin_pref_names = [make_subfolder_menu_entry(pref)
                                       for pref in PHOTO_SUBFOLDER_MENU_DEFAULTS]
        elif generation_type == NameGenerationType.video_subfolder:
            self.setWindowTitle(_('Video Subfolder Generation Editor'))
            self.preset_type = PresetPrefType.preset_video_subfolder
            self.builtin_pref_lists = VIDEO_SUBFOLDER_MENU_DEFAULTS_CONV
            self.builtin_pref_names = [make_subfolder_menu_entry(pref)
                                       for pref in VIDEO_SUBFOLDER_MENU_DEFAULTS]
        elif generation_type == NameGenerationType.photo_name:
            self.setWindowTitle(_('Photo Renaming Editor'))
            self.preset_type = PresetPrefType.preset_photo_rename
            self.builtin_pref_lists = PHOTO_RENAME_MENU_DEFAULTS_CONV
            self.builtin_pref_names = [make_rename_menu_entry(pref)
                                       for pref in PHOTO_RENAME_MENU_DEFAULTS]
        else:
            self.setWindowTitle(_('Video Renaming Editor'))
            self.preset_type = PresetPrefType.preset_video_rename
            self.builtin_pref_lists = VIDEO_RENAME_MENU_DEFAULTS_CONV
            self.builtin_pref_names = [make_rename_menu_entry(pref)
                                       for pref in VIDEO_RENAME_MENU_DEFAULTS]

        self.prefs = prefs
        self.max_entries = max_entries

        # Cache custom preset name and pref lists
        self.updateCachedPrefLists()

        self.current_custom_name = None

        # Setup values needed for name generation

        self.sample_rpd_file = make_sample_rpd_file(sample_rpd_file=sample_rpd_file,
                    sample_job_code=self.prefs.most_recent_job_code(missing=_('Job Code')),
                    prefs=self.prefs,
                    generation_type=generation_type)

        # Setup widgets and helper values

        # Translators: please do not modify or leave out html formatting tags like <i> and
        # <b>. These are used to format the text the users sees
        warning_msg = _(
            '<b><font color="red">Warning:</font></b> <i>There is insufficient data to fully '
            'generate the name. Please use other renaming options.</i>'
        )

        self.is_subfolder = generation_type in (
            NameGenerationType.photo_subfolder, NameGenerationType.video_subfolder
        )

        if self.is_subfolder:
            # Translators: please do not modify, change the order of or leave out html formatting
            # tags like <i> and <b>. These are used to format the text the users sees.
            # In this case, the </i> really is supposed to come before the <i>.
            subfolder_msg = _(
                "The character</i> %(separator)s <i>creates a new subfolder level."
            ) % dict(separator=os.sep)
            # Translators: please do not modify, change the order of or leave out html formatting
            # tags like <i> and <b>. These are used to format the text the users sees
            # In this case, the </i> really is supposed to come before the <i>.
            subfolder_first_char_msg = _(
                "There is no need start or end with the folder separator </i> %(separator)s<i>, "
                "because it is added automatically."
            ) % dict(separator=os.sep)
            messages = (warning_msg, subfolder_msg, subfolder_first_char_msg)
        else:
            # Translators: please do not modify or leave out html formatting tags like <i> and
            # <b>. These are used to format the text the users sees
            unique_msg = _(
                '<b><font color="red">Warning:</font></b> <i>Unique filenames may not be '
                'generated. Make filenames unique by using Sequence values.</i>'
            )
            messages = (warning_msg, unique_msg)

        self.messageWidget = MessageWidget(messages=messages)

        self.editor = PrefEditor(subfolder=self.is_subfolder)
        sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
        sizePolicy.setVerticalStretch(1)
        self.editor.setSizePolicy(sizePolicy)

        self.editor.prefListGenerated.connect(self.updateExampleFilename)

        # Generated subfolder / file name example
        self.example = QLabel()

        # Combobox with built-in and user defined presets
        self.preset = PresetComboBox(prefs=prefs, preset_names=self.preset_names,
                                     preset_type=self.preset_type, edit_mode=True)
        self.preset.activated.connect(self.presetComboItemActivated)

        flayout = QFormLayout()
        flayout.addRow(_('Preset:'), self.preset)
        flayout.addRow(_('Example:'), self.example)

        layout = QVBoxLayout()
        self.setLayout(layout)

        layout.addLayout(flayout)
        layout.addSpacing(int(QFontMetrics(QFont()).height() / 2))
        layout.addWidget(self.editor)
        layout.addWidget(self.messageWidget)

        self.area = QScrollArea()
        sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Expanding)
        sizePolicy.setVerticalStretch(10)
        self.area.setSizePolicy(sizePolicy)
        self.area.setFrameShape(QFrame.NoFrame)
        layout.addWidget(self.area)

        gbSizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)

        areaWidget = QWidget()
        areaLayout = QVBoxLayout()
        areaWidget.setLayout(areaLayout)
        areaWidget.setSizePolicy(gbSizePolicy)

        self.area.setWidget(areaWidget)
        self.area.setWidgetResizable(True)

        areaLayout.setContentsMargins(0, 0, 0, 0)

        self.pushButtonSizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)

        self.mapper = QSignalMapper(self)
        self.widget_mapper = dict()  # type: Dict[str, Union[QComboBox, QLabel]]
        self.pref_mapper = dict()  # type: Dict[Tuple[str, str, str], str]
        self.pref_color = dict()  # type: Dict[str, str]

        titles = [title for title in pref_defn if title not in (TEXT, SEPARATOR)]
        pref_colors = {title: color.value for title, color in zip(titles, CustomColors)}
        self.filename_pref_color = pref_colors[FILENAME]

        for title in titles:
            title_i18n = _(title)
            color = pref_colors[title]
            level1 = pref_defn[title]
            gb = QGroupBox(title_i18n)
            gb.setSizePolicy(gbSizePolicy)
            gb.setFlat(True)
            areaLayout.addWidget(gb)
            gLayout = QGridLayout()
            gb.setLayout(gLayout)
            if level1 is None:
                assert title == JOB_CODE
                widget1 = QLabel(' ' + title_i18n)
                widget2 = self.makeInsertButton()
                self.widget_mapper[title] = widget1
                self.mapper.setMapping(widget2, title)
                self.pref_mapper[(title, '', '')] = title_i18n
                self.pref_color['<{}>'.format(title_i18n)] = color
                gLayout.addWidget(self.makeColorCodeLabel(color), 0, 0)
                gLayout.addWidget(widget1, 0, 1)
                gLayout.addWidget(widget2, 0, 2)
            elif title == METADATA:
                elements = []
                data = []
                for element in level1:
                    element_i18n = _(element)
                    level2 = level1[element]
                    if level2 is None:
                        elements.append(element_i18n)
                        data.append([METADATA, element, ''])
                        self.pref_mapper[(METADATA, element, '')] = element_i18n
                        self.pref_color['<{}>'.format(element_i18n)] = color
                    else:
                        for e in level2:
                            e_i18n = _(e)
                            # Translators: appears in a combobox, e.g. Image Date (YYYY)
                            item = _('{choice} ({variant})').format(choice=element_i18n,
                                                                    variant=e_i18n)
                            elements.append(item)
                            data.append([METADATA, element, e])
                            self.pref_mapper[(METADATA, element, e)] = item
                            self.pref_color['<{}>'.format(item)] = color
                widget1 = EditorCombobox()
                for element, data_item in zip(elements, data):
                    widget1.addItem(element, data_item)
                widget2 = self.makeInsertButton()
                widget1.currentTextChanged.connect(self.mapper.map)
                self.mapper.setMapping(widget2, title)
                self.mapper.setMapping(widget1, title)
                self.widget_mapper[title] = widget1
                gLayout.addWidget(self.makeColorCodeLabel(color), 0, 0)
                gLayout.addWidget(widget1, 0, 1)
                gLayout.addWidget(widget2, 0, 2)
            else:
                for row, level1 in enumerate(pref_defn[title]):
                    widget1 = EditorCombobox()
                    level1_i18n = _(level1)
                    items = (_('{choice} ({variant})').format(
                             choice=level1_i18n, variant=_(element))
                             for element in pref_defn[title][level1])
                    data = ([title, level1, element] for element in pref_defn[title][level1])
                    for item, data_item in zip(items, data):
                        widget1.addItem(item, data_item)
                        self.pref_mapper[tuple(data_item)] = item
                        self.pref_color['<{}>'.format(item)] = color
                    widget2 =  self.makeInsertButton()
                    widget1.currentTextChanged.connect(self.mapper.map)

                    self.mapper.setMapping(widget2, level1)
                    self.mapper.setMapping(widget1, level1)
                    self.widget_mapper[level1] = widget1
                    gLayout.addWidget(self.makeColorCodeLabel(color), row, 0)
                    gLayout.addWidget(widget1, row, 1)
                    gLayout.addWidget(widget2, row, 2)

        self.mapper.mapped[str].connect(self.choiceMade)

        buttonBox = QDialogButtonBox(
            QDialogButtonBox.Cancel | QDialogButtonBox.Ok | QDialogButtonBox.Help
        )
        self.helpButton = buttonBox.button(QDialogButtonBox.Help)  # type: QPushButton
        self.helpButton.clicked.connect(self.helpButtonClicked)
        self.helpButton.setToolTip(_('Get help online...'))
        translateButtons(buttonBox)

        buttonBox.rejected.connect(self.reject)
        buttonBox.accepted.connect(self.accept)

        layout.addWidget(buttonBox)

        self.editor.setPrefMapper(self.pref_mapper, self.pref_color)
        self.editor.displayPrefList(user_pref_list)

        self.show()
        self.setWidgetSizes()

    def helpButtonClicked(self) -> None:
        if self.generation_type in (NameGenerationType.photo_name, NameGenerationType.video_name):
            location = '#rename'
        else:
            location = '#subfoldergeneration'
        webbrowser.open_new_tab("http://www.damonlynch.net/rapid/documentation/{}".format(location))

    def makeInsertButton(self) -> QPushButton:
        w = QPushButton(_('Insert'))
        w.clicked.connect(self.mapper.map)
        w.setSizePolicy(self.pushButtonSizePolicy)
        return w

    def setWidgetSizes(self) -> None:
        """
        Resize widgets for enhanced visual layout
        """

        # Set the widths of the comboboxes and labels to the width of the
        # longest control
        width = max(widget.width() for widget in self.widget_mapper.values())
        for widget in self.widget_mapper.values():
            widget.setMinimumWidth(width)

        # Set the scroll area to be big enough to eliminate the horizontal scrollbar
        scrollbar_width = self.style().pixelMetric(QStyle.PM_ScrollBarExtent)
        self.area.setMinimumWidth(self.area.widget().width() + scrollbar_width)

    @pyqtSlot(str)
    def choiceMade(self, widget: str) -> None:
        """
        User has pushed one of the "Insert" buttons or selected a new value in one
        of the combo boxes.

        :param widget: widget's name, which uniquely identifies it
        """

        if widget == JOB_CODE:
            pref_value = _(JOB_CODE)
        else:
            combobox = self.widget_mapper[widget]  # type: QComboBox
            pref_value = combobox.currentText()

        self.editor.insertPrefValue(pref_value)

        # Set focus not on the control that was just used, but the editor
        self.editor.setFocus(Qt.OtherFocusReason)

    def makeColorCodeLabel(self, color: str) -> QLabel:
        """
        Generate a colored square to show beside the combo boxes / label
        :param color: color to use, e.g. #7a9c38
        :return: the square in form of a label
        """

        colorLabel = QLabel(' ')
        colorLabel.setStyleSheet('QLabel {background-color: %s;}' % color)
        size = QFontMetrics(QFont()).height()
        colorLabel.setFixedSize(QSize(size, size))
        return colorLabel

    def updateExampleFilename(self) -> None:

        user_pref_list = self.editor.user_pref_list
        self.user_pref_colors = self.editor.user_pref_colors

        if not self.is_subfolder:
            self.user_pref_colors.append(self.filename_pref_color)

        self.messageWidget.setCurrentIndex(0)

        if self.is_subfolder:
            if user_pref_list:
                try:
                    user_pref_list.index(SEPARATOR)
                except ValueError:
                    # Inform the user that a subfolder separator (os.sep) is used to create
                    # subfolder levels
                    self.messageWidget.setCurrentIndex(2)
                else:
                    if user_pref_list[0] == SEPARATOR or user_pref_list[-3] == SEPARATOR:
                        # inform the user that there is no need to start or finish with a
                        # subfolder separator (os.sep)
                        self.messageWidget.setCurrentIndex(3)
            else:
                # Inform the user that a subfolder separator (os.sep) is used to create
                # subfolder levels
                self.messageWidget.setCurrentIndex(2)

            changed, user_pref_list, self.user_pref_colors = filter_subfolder_prefs(
                user_pref_list, self.user_pref_colors)
        else:
            try:
                user_pref_list.index(SEQUENCES)
            except ValueError:
                # Inform the user that sequences can be used to make filenames unique
                self.messageWidget.setCurrentIndex(2)

        if self.generation_type == NameGenerationType.photo_name:
            self.name_generator = gn.PhotoName(user_pref_list)
        elif self.generation_type == NameGenerationType.video_name:
            self.name_generator = gn.VideoName(user_pref_list)
        elif self.generation_type == NameGenerationType.photo_subfolder:
            self.name_generator = gn.PhotoSubfolder(user_pref_list)
        else:
            assert self.generation_type == NameGenerationType.video_subfolder
            self.name_generator = gn.VideoSubfolder(user_pref_list)

        self.name_parts = self.name_generator.generate_name(self.sample_rpd_file, parts=True)
        self.showExample()
        self.updateComboBoxCurrentIndex()

    def updateComboBoxCurrentIndex(self) -> None:
        """
        Sets the combo value to match the current preference value
        """

        combobox_index, pref_list_index = self.getPresetMatch()
        if pref_list_index >= 0:
            # the editor contains an existing preset
            self.preset.setCurrentIndex(combobox_index)
            if self.preset.preset_edited or self.preset.new_preset:
                self.preset.resetPresetList()
                self.preset.setSaveNewCustomPresetEnabled(enabled=False)
            if pref_list_index >= len(self.builtin_pref_names):
                self.current_custom_name = self.preset.currentText()
            else:
                self.current_custom_name = None
        elif not (self.preset.new_preset or self.preset.preset_edited):
            if self.current_custom_name is None:
                self.preset.setPresetNew()
            else:
                self.preset.setPresetEdited(self.current_custom_name)
            self.preset.setSaveNewCustomPresetEnabled(enabled=True)
        else:
            self.preset.setCurrentIndex(0)

    def showExample(self) -> None:
        """
        Insert text into example widget, eliding it if necessary
        """

        user_pref_colors = self.user_pref_colors

        parts = copy.copy(self.name_parts)
        metrics = QFontMetrics(self.example.font())
        width = self.example.width() - metrics.width('…')

        # Cannot elide rich text using Qt code. Thus, elide the plain text.
        plain_text_name = ''.join(parts)

        if self.is_subfolder:
            plain_text_name = self.name_generator.filter_subfolder_characters(plain_text_name)
        elided_text = metrics.elidedText(plain_text_name, Qt.ElideRight, width)
        elided = False

        while plain_text_name != elided_text:
            elided = True
            parts = remove_last_char_from_list_str(parts)
            plain_text_name = ''.join(parts)
            if self.is_subfolder:
                plain_text_name = self.name_generator.filter_subfolder_characters(plain_text_name)
            elided_text = metrics.elidedText(plain_text_name, Qt.ElideRight, width)

        colored_parts = ['<span style="color: {};">{}</span>'.format(color, part) if color else part
                         for part, color in zip(parts, user_pref_colors)]

        name = ''.join(colored_parts)
        if elided:
            name = '{}&hellip;'.format(name)

        if self.is_subfolder:
            name = self.name_generator.filter_subfolder_characters(name)

        if self.sample_rpd_file.name_generation_problem:
            self.messageWidget.setCurrentIndex(1)

        self.example.setTextFormat(Qt.RichText)
        self.example.setText(name)

    def resizeEvent(self, event: QResizeEvent) -> None:
        if self.example.text():
            self.showExample()
        super().resizeEvent(event)

    def getPrefList(self) -> List[str]:
        """
        :return: the pref list the user has specified
        """

        return self.editor.user_pref_list

    @pyqtSlot(int)
    def presetComboItemActivated(self, index: int) -> None:
        """
        Respond to user activating the Preset combo box.

        :param index: index of the item activated
        """

        preset_class =  self.preset.currentData()
        if preset_class == PresetClass.new_preset:
            createPreset = CreatePreset(existing_custom_names=self.preset_names)
            if createPreset.exec():
                # User has created a new preset
                preset_name = createPreset.presetName()
                assert preset_name not in self.preset_names
                self.current_custom_name = preset_name
                self.preset.addCustomPreset(preset_name)
                self.saveNewPreset(preset_name=preset_name)
                if len(self.preset_names) == 1:
                    self.preset.setRemoveAllCustomEnabled(True)
                self.preset.setSaveNewCustomPresetEnabled(enabled=False)
            else:
                # User cancelled creating a new preset
                self.updateComboBoxCurrentIndex()
        elif preset_class in (PresetClass.builtin, PresetClass.custom):
            index = self.combined_pref_names.index(self.preset.currentText())
            pref_list = self.combined_pref_lists[index]
            self.editor.displayPrefList(pref_list=pref_list)
            if index >= len(self.builtin_pref_names):
                self.movePresetToFront(index=len(self.builtin_pref_names) - index)
        elif preset_class == PresetClass.remove_all:
            self.preset.removeAllCustomPresets(no_presets=len(self.preset_names))
            self.clearCustomPresets()
            self.preset.setRemoveAllCustomEnabled(False)
            self.updateComboBoxCurrentIndex()
        elif preset_class == PresetClass.update_preset:
            self.updateExistingPreset()
            self.updateComboBoxCurrentIndex()

    def updateExistingPreset(self) -> None:
        """
        Updates (saves) an existing preset (assumed to be self.current_custom_name)
        with the new user_pref_list found in the editor.

        Assumes cached self.preset_names and self.preset_pref_lists represent
        current save preferences. Will update these and overwrite the relevant
        preset preference.
        """

        preset_name = self.current_custom_name
        user_pref_list = self.editor.user_pref_list
        index = self.preset_names.index(preset_name)
        self.preset_pref_lists[index] = user_pref_list
        if index > 0:
            self.movePresetToFront(index=index)
        else:
            self._updateCombinedPrefs()
            self.prefs.set_preset(
                preset_type=self.preset_type, preset_names=self.preset_names,
                preset_pref_lists=self.preset_pref_lists
            )

    def movePresetToFront(self, index: int) -> None:
        """
        Extracts the preset from the current list of presets and moves it
        to the front if not already there.

        Assumes cached self.preset_names and self.preset_pref_lists represent
        current save preferences. Will update these and overwrite the relevant
        preset preference.

        :param index: index into self.preset_pref_lists / self.preset_names of
         the item to move
        """

        if index == 0:
            return
        preset_name = self.preset_names.pop(index)
        pref_list = self.preset_pref_lists.pop(index)
        self.preset_names.insert(0, preset_name)
        self.preset_pref_lists.insert(0, pref_list)
        self._updateCombinedPrefs()
        self.prefs.set_preset(
            preset_type=self.preset_type, preset_names=self.preset_names,
            preset_pref_lists=self.preset_pref_lists
        )

    def saveNewPreset(self, preset_name: str) -> None:
        """
        Saves the current user_pref_list (retrieved from the editor) and
        saves it in the program preferences.

        Assumes cached self.preset_names and self.preset_pref_lists represent
        current save preferences. Will update these and overwrite the relevant
        preset preference.

        :param preset_name: name for the new preset
        """

        user_pref_list = self.editor.user_pref_list
        self.preset_names.insert(0, preset_name)
        self.preset_pref_lists.insert(0, user_pref_list)
        self._updateCombinedPrefs()
        self.prefs.set_preset(
            preset_type=self.preset_type, preset_names=self.preset_names,
            preset_pref_lists=self.preset_pref_lists
        )

    def clearCustomPresets(self) -> None:
        """
        Deletes all of the custom presets.

        Assumes cached self.preset_names and self.preset_pref_lists represent
        current save preferences. Will update these and overwrite the relevant
        preset preference.
        """
        self.preset_names = []
        self.preset_pref_lists = []
        self.current_custom_name = None
        self._updateCombinedPrefs()
        self.prefs.set_preset(
            preset_type=self.preset_type, preset_names=self.preset_names,
            preset_pref_lists=self.preset_pref_lists
        )

    def updateCachedPrefLists(self) -> None:
        self.preset_names, self.preset_pref_lists = self.prefs.get_preset(
            preset_type=self.preset_type)
        self._updateCombinedPrefs()

    def _updateCombinedPrefs(self):
        self.combined_pref_names = self.builtin_pref_names + self.preset_names
        self.combined_pref_lists = self.builtin_pref_lists + tuple(self.preset_pref_lists)

    def getPresetMatch(self) -> Tuple[int, int]:
        """
        :return: Tuple of the Preset combobox index and the combined pref/name list index,
        if the current user pref list matches an entry in it. Else Tuple of (-1, -1).
        """

        index = match_pref_list(
            pref_lists=self.combined_pref_lists, user_pref_list=self.editor.user_pref_list
        )
        if index >= 0:
            combobox_name = self.combined_pref_names[index]
            return self.preset.findText(combobox_name), index
        return -1, -1

    @pyqtSlot()
    def accept(self) -> None:
        """
        Slot called when the okay button is clicked.

        If there are unsaved changes, query the user if they want their changes
        saved as a new preset or if the existing preset should be updated
        """

        if self.preset.preset_edited or self.preset.new_preset:
            msgBox = QMessageBox()
            title = _("Save Preset - Rapid Photo Downloader")
            msgBox.setTextFormat(Qt.RichText)
            msgBox.setIcon(QMessageBox.Question)
            msgBox.setWindowTitle(title)
            if self.preset.new_preset:
                message = _(
                    "<b>Do you want to save the changes in a new custom preset?</b><br><br>"
                    "Creating a custom preset is not required, but can help you keep "
                    "organized.<br><br>"
                    "The changes to the preferences will still be applied regardless of "
                    "whether you create a new custom preset or not."
                )
                msgBox.setStandardButtons(QMessageBox.Yes|QMessageBox.No)
                updateButton = newButton = None
            else:
                assert self.preset.preset_edited
                message = _(
                    "<b>Do you want to save the changes in a custom preset?</b><br><br>"
                    "If you like, you can create a new custom preset or update the "
                    "existing custom preset.<br><br>"
                    "The changes to the preferences will still be applied regardless of "
                    "whether you save a custom preset or not."
                )
                updateButton = msgBox.addButton(
                    _('Update Custom Preset "%s"') % self.current_custom_name, QMessageBox.YesRole
                )
                newButton = msgBox.addButton(_('Save New Custom Preset'), QMessageBox.YesRole)
                msgBox.addButton(QMessageBox.No)

            msgBox.setText(message)
            choice = msgBox.exec()
            save_new = update = False
            if self.preset.new_preset:
                save_new = choice == QMessageBox.Yes
            else:
                if msgBox.clickedButton() == updateButton:
                    update = True
                elif msgBox.clickedButton() == newButton:
                    save_new = True

            if save_new:
                createPreset = CreatePreset(existing_custom_names=self.preset_names)
                if createPreset.exec():
                    # User has created a new preset
                    preset_name = createPreset.presetName()
                    assert preset_name not in self.preset_names
                    self.saveNewPreset(preset_name=preset_name)
            elif update:
                self.updateExistingPreset()

        # Check to make sure that in menus (which have a limited number of menu items)
        # that our chosen entry is displayed
        if self.max_entries:
            combobox_index, pref_list_index = self.getPresetMatch()
            if pref_list_index >= self.max_entries:
                self.updateExistingPreset()

        # Regardless of any user actions, close the dialog box
        super().accept()


if __name__ == '__main__':

    # Application development test code:

    app = QApplication([])

    app.setOrganizationName("Rapid Photo Downloader")
    app.setOrganizationDomain("damonlynch.net")
    app.setApplicationName("Rapid Photo Downloader")

    prefs = Preferences()

    # prefDialog = PrefDialog(DICT_IMAGE_RENAME_L0, PHOTO_RENAME_MENU_DEFAULTS_CONV[1],
    #                         NameGenerationType.photo_name, prefs)
    # prefDialog = PrefDialog(DICT_VIDEO_RENAME_L0, VIDEO_RENAME_MENU_DEFAULTS_CONV[1],
    #                         NameGenerationType.video_name, prefs)
    prefDialog = PrefDialog(
        DICT_SUBFOLDER_L0, PHOTO_SUBFOLDER_MENU_DEFAULTS_CONV[2],
        NameGenerationType.photo_subfolder, prefs, max_entries=10
    )
    # prefDialog = PrefDialog(
    #     DICT_VIDEO_SUBFOLDER_L0, VIDEO_SUBFOLDER_MENU_DEFAULTS_CONV[2],
    #     NameGenerationType.video_subfolder, prefs, max_entries=10
    # )
    prefDialog.show()
    app.exec_()