reimplemented goto prev/next cut, about dialog, and action search dialog

app/dialog/CMakeLists.txt

@@ -14,6 +14,8 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+add_subdirectory(about)
+add_subdirectory(actionsearch)
 add_subdirectory(sequence)
 
 set(OLIVE_SOURCES

app/dialog/about/CMakeLists.txt

@@ -0,0 +1,22 @@
+# Olive - Non-Linear Video Editor
+# Copyright (C) 2019 Olive Team
+#
+# This program 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.
+#
+# This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+
+set(OLIVE_SOURCES
+  ${OLIVE_SOURCES}
+  dialog/about/about.h
+  dialog/about/about.cpp
+  PARENT_SCOPE
+)

app/dialog/about/about.cpp

@@ -0,0 +1,65 @@
+/***
+
+  Olive - Non-Linear Video Editor
+  Copyright (C) 2019 Olive Team
+
+  This program 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.
+
+  This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+
+***/
+
+#include "about.h"
+
+#include <QApplication>
+#include <QLabel>
+#include <QDialogButtonBox>
+#include <QVBoxLayout>
+
+AboutDialog::AboutDialog(QWidget *parent) :
+  QDialog(parent)
+{
+  setWindowTitle(tr("About %1").arg(QApplication::applicationName()));
+
+  QVBoxLayout* layout = new QVBoxLayout(this);
+  //layout->setSpacing(20);
+
+  // Construct About text
+  QLabel* label =
+      new QLabel(QString("<html><head/><body>"
+                         "<p><img src=\":/icons/olive-splash.png\"/></p>"
+                         "<p><a href=\"https://www.olivevideoeditor.org/\">"
+                         "<span style=\" text-decoration: underline; color:#007af4;\">"
+                         "https://www.olivevideoeditor.org/"
+                         "</span></a></p>"
+                         "<p><b>%1</b></p>" // AppName (version identifier)
+                         "<p>%2</p>" // First statement
+                         "<p>%3</p>" // Second statement
+                         "</body></html>").arg(QApplication::applicationName(),
+                                               tr("Olive is a non-linear video editor. This software is free and "
+                                                  "protected by the GNU GPL."),
+                                               tr("Olive Team is obliged to inform users that Olive source code is "
+                                                  "available for download from its website.")),this);
+
+  // Set text formatting
+  label->setAlignment(Qt::AlignCenter);
+  label->setTextInteractionFlags(Qt::TextSelectableByMouse);
+  label->setCursor(Qt::IBeamCursor);
+  label->setWordWrap(true);
+  layout->addWidget(label);
+
+  QDialogButtonBox* buttons = new QDialogButtonBox(QDialogButtonBox::Ok, this);
+  buttons->setCenterButtons(true);
+  layout->addWidget(buttons);
+
+  connect(buttons, SIGNAL(accepted()), this, SLOT(accept()));
+}

app/dialog/about/about.h

@@ -0,0 +1,48 @@
+/***
+
+  Olive - Non-Linear Video Editor
+  Copyright (C) 2019 Olive Team
+
+  This program 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.
+
+  This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+
+***/
+
+#ifndef ABOUTDIALOG_H
+#define ABOUTDIALOG_H
+
+#include <QDialog>
+
+/**
+ * @brief The AboutDialog class
+ *
+ * The About dialog (accessible through Help > About). Contains license and version information. This can be run from
+ * anywhere
+ */
+class AboutDialog : public QDialog
+{
+  Q_OBJECT
+public:
+  /**
+   * @brief AboutDialog Constructor
+   *
+   * Creates About dialog.
+   *
+   * @param parent
+   *
+   * QWidget parent object. Usually this will be MainWindow.
+   */
+  explicit AboutDialog(QWidget *parent = nullptr);
+};
+
+#endif // ABOUTDIALOG_H

app/dialog/actionsearch/CMakeLists.txt

@@ -0,0 +1,22 @@
+# Olive - Non-Linear Video Editor
+# Copyright (C) 2019 Olive Team
+#
+# This program 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.
+#
+# This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+
+set(OLIVE_SOURCES
+  ${OLIVE_SOURCES}
+  dialog/actionsearch/actionsearch.h
+  dialog/actionsearch/actionsearch.cpp
+  PARENT_SCOPE
+)

app/dialog/actionsearch/actionsearch.cpp

@@ -0,0 +1,253 @@
+/***
+
+  Olive - Non-Linear Video Editor
+  Copyright (C) 2019  Olive Team
+
+  This program 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.
+
+  This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+
+***/
+
+#include "actionsearch.h"
+
+#include <QVBoxLayout>
+#include <QKeyEvent>
+#include <QMenuBar>
+#include <QLabel>
+
+ActionSearch::ActionSearch(QWidget *parent) :
+  QDialog(parent),
+  menu_bar_(nullptr)
+{
+  // ActionSearch requires a parent widget
+  Q_ASSERT(parent != nullptr);
+
+  // Set styling (object name is required for CSS specific to this object)
+  setObjectName("ASDiag");
+  setStyleSheet("#ASDiag{border: 2px solid #808080;}");
+
+  // Size proportionally to the parent (usually MainWindow).
+  resize(parent->width()/3, parent->height()/3);
+
+  // Show dialog as a "popup", which will make the dialog close if the user clicks out of it.
+  setWindowFlags(Qt::Popup);
+
+  QVBoxLayout* layout = new QVBoxLayout(this);
+
+  // Construct the main entry text field.
+  ActionSearchEntry* entry_field = new ActionSearchEntry(this);
+
+  // Set the main entry field font size to 1.2x its standard font size.
+  QFont entry_field_font = entry_field->font();
+  entry_field_font.setPointSize(qRound(entry_field_font.pointSize()*1.2));
+  entry_field->setFont(entry_field_font);
+
+  // Set placeholder text for the main entry field
+  entry_field->setPlaceholderText(tr("Search for action..."));
+
+  // Connect signals/slots
+  connect(entry_field, SIGNAL(textChanged(const QString&)), this, SLOT(search_update(const QString &)));
+  connect(entry_field, SIGNAL(returnPressed()), this, SLOT(perform_action()));
+
+  // moveSelectionUp() and moveSelectionDown() are emitted when the user pressed up or down on the text field.
+  // We override it here to select the upper or lower item in the list.
+  connect(entry_field, SIGNAL(moveSelectionUp()), this, SLOT(move_selection_up()));
+  connect(entry_field, SIGNAL(moveSelectionDown()), this, SLOT(move_selection_down()));
+  layout->addWidget(entry_field);
+
+  // Construct list of actions
+  list_widget = new ActionSearchList(this);
+
+  // Set list's font to 1.2x its standard font size
+  QFont list_widget_font = list_widget->font();
+  list_widget_font.setPointSize(qRound(list_widget_font.pointSize()*1.2));
+  list_widget->setFont(list_widget_font);
+
+  layout->addWidget(list_widget);
+
+  connect(list_widget, SIGNAL(dbl_click()), this, SLOT(perform_action()));
+
+  // Instantly focus on the entry field to allow for fully keyboard operation (if this popup was initiated by keyboard
+  // shortcut for example).
+  entry_field->setFocus();
+}
+
+void ActionSearch::SetMenuBar(QMenuBar *menu_bar)
+{
+  menu_bar_ = menu_bar;
+}
+
+void ActionSearch::search_update(const QString &s, const QString &p, QMenu *parent)
+{
+  // Do nothing if there's no menu bar to work with
+  if (menu_bar_ == nullptr) {
+    return;
+  }
+
+  // This function is recursive, using the `parent` parameter to loop through a menu's items. It functions in two
+  // modes - the parent being NULL, meaning it'll get MainWindow's menubar and loop over its menus, and the parent
+  // referring to a menu at which point it'll loop over its actions (and call itself recursively if it finds any
+  // submenus).
+
+  if (parent == nullptr) {
+
+    // If parent is NULL, we'll pull from the MainWindow's menubar and call this recursively on all of its submenus
+    // (and their submenus).
+
+    // We'll clear all the current items in the list since if we're here, we're just starting.
+    list_widget->clear();
+
+    QList<QAction*> menus = menu_bar_->actions();
+
+    // Loop through all menus from the menubar and run this function on each one.
+    for (int i=0;i<menus.size();i++) {
+      QMenu* menu = menus.at(i)->menu();
+
+      search_update(s, p, menu);
+    }
+
+    // Once we're here, all the recursion/item retrieval is complete. We auto-select the first item for better
+    // keyboard-exclusive functionality.
+    if (list_widget->count() > 0) {
+      list_widget->item(0)->setSelected(true);
+    }
+
+  } else {
+
+    // Parent was not NULL, so we loop over the actions in the menu we were given in `parent`.
+
+    // The list shows a '>' delimited hierarchy of the menus in which this action came from. We construct it here by
+    // adding the current menu's text to the existing hierarchy (passed in `p`).
+    QString menu_text;
+    if (!p.isEmpty()) menu_text += p + " > ";
+    menu_text += parent->title().replace("&", ""); // Strip out any &s used in menu action names
+
+    // Loop over the menu's actions
+    QList<QAction*> actions = parent->actions();
+    for (int i=0;i<actions.size();i++) {
+
+      QAction* a = actions.at(i);
+
+      // Ignore separator actions
+      if (!a->isSeparator()) {
+
+        if (a->menu() != nullptr) {
+
+          // If the action is a menu, run this function recursively on it
+          search_update(s, menu_text, a->menu());
+
+        } else {
+
+          // This is a valid non-separator non-menu action, so check it against the currently entered string.
+
+          // Strip out all &s from the action's name
+          QString comp = a->text().replace("&", "");
+
+          // See if the action's name contains any of the currently entered string
+          if (comp.contains(s, Qt::CaseInsensitive)) {
+
+            // If so, we add it to the list widget.
+            QListWidgetItem* item = new QListWidgetItem(QString("%1\n(%2)").arg(comp, menu_text), list_widget);
+
+            // Add a pointer to the original QAction in the item's data
+            item->setData(Qt::UserRole+1, reinterpret_cast<quintptr>(a));
+
+            list_widget->addItem(item);
+
+          }
+
+        }
+      }
+    }
+  }
+}
+
+void ActionSearch::perform_action() {
+
+  // Loop over all the items in the list and if we find one that's selected, we trigger it.
+  QList<QListWidgetItem*> selected_items = list_widget->selectedItems();
+  if (list_widget->count() > 0 && selected_items.size() > 0) {
+
+    QListWidgetItem* item = selected_items.at(0);
+
+    // Get QAction pointer from item's data
+    QAction* a = reinterpret_cast<QAction*>(item->data(Qt::UserRole+1).value<quintptr>());
+
+    a->trigger();
+
+  }
+
+  // Close this popup
+  accept();
+
+}
+
+void ActionSearch::move_selection_up() {
+
+  // Here we loop over all the items to find the currently selected one, and then select the one above it. We start
+  // iterating at 1 (instead of 0) to efficiently ignore the first item (since the selection can't go below the very
+  // bottom item).
+
+  int lim = list_widget->count();
+  for (int i=1;i<lim;i++) {
+    if (list_widget->item(i)->isSelected()) {
+      list_widget->item(i-1)->setSelected(true);
+      list_widget->scrollToItem(list_widget->item(i-1));
+      break;
+    }
+  }
+}
+
+void ActionSearch::move_selection_down() {
+
+  // Here we loop over all the items to find the currently selected one, and then select the one below it. We limit it
+  // one entry before count() to efficiently ignore the item at the end (since the selection can't go below the very
+  // bottom item).
+
+  int lim = list_widget->count()-1;
+  for (int i=0;i<lim;i++) {
+    if (list_widget->item(i)->isSelected()) {
+      list_widget->item(i+1)->setSelected(true);
+      list_widget->scrollToItem(list_widget->item(i+1));
+      break;
+    }
+  }
+}
+
+ActionSearchEntry::ActionSearchEntry(QWidget *parent) : QLineEdit(parent) {}
+
+void ActionSearchEntry::keyPressEvent(QKeyEvent * event) {
+
+  // Listen for up/down, otherwise pass the key event to the base class.
+
+  switch (event->key()) {
+  case Qt::Key_Up:
+    emit moveSelectionUp();
+    break;
+  case Qt::Key_Down:
+    emit moveSelectionDown();
+    break;
+  default:
+    QLineEdit::keyPressEvent(event);
+  }
+
+}
+
+ActionSearchList::ActionSearchList(QWidget *parent) : QListWidget(parent) {}
+
+void ActionSearchList::mouseDoubleClickEvent(QMouseEvent *) {
+
+  // Indiscriminately emit a signal on any double click
+  emit dbl_click();
+
+}

app/dialog/actionsearch/actionsearch.h

@@ -0,0 +1,181 @@
+/***
+
+  Olive - Non-Linear Video Editor
+  Copyright (C) 2019  Olive Team
+
+  This program 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.
+
+  This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+
+***/
+
+#ifndef ACTIONSEARCH_H
+#define ACTIONSEARCH_H
+
+#include <QDialog>
+#include <QLineEdit>
+#include <QListWidget>
+#include <QMenu>
+#include <QMenuBar>
+
+class ActionSearchList;
+
+/**
+ * @brief The ActionSearch class
+ *
+ * A popup window (accessible through Help > Action Search) that allows users to search for a menu command by typing
+ * rather than browsing through the menu bar. This can be created from anywhere provided olive::MainWindow is valid.
+ */
+class ActionSearch : public QDialog
+{
+  Q_OBJECT
+public:
+  /**
+   * @brief ActionSearch Constructor
+   *
+   * Create ActionSearch popup.
+   *
+   * @param parent
+   *
+   * QWidget parent. Usually MainWindow.
+   */
+  ActionSearch(QWidget* parent);
+
+  /**
+   * @brief Set the menu bar to use in this action search
+   */
+  void SetMenuBar(QMenuBar* menu_bar);
+private slots:
+  /**
+   * @brief Update the list of actions according to a search query
+   *
+   * This function adds/removes actions in the action list according to a given search query entered by the user.
+   *
+   * To loop over the menubar and all of its menus and submenus, this function will call itself recursively. As such
+   * some of its parameters do not need to be set externally, as these will be set by the function itself as it calls
+   * itself.
+   *
+   * @param s
+   *
+   * The search text. This is the only parameter that should be set externally.
+   *
+   * @param p
+   *
+   * The current parent hierarchy. In most cases, this should be left as nullptr when called externally.
+   * search_update() will fill this automatically as it needs while calling itself recursively.
+   *
+   * @param parent
+   *
+   * The current menu to loop over. In most cases, this should be left as nullptr when called externally.
+   * search_update() will fill this automatically as it needs while calling itself recursively.
+   */
+  void search_update(const QString& s, const QString &p = nullptr, QMenu *parent = nullptr);
+
+  /**
+   * @brief Perform the currently selected action
+   *
+   * Usually triggered by pressing Enter on the ActionSearchEntry field, this will trigger whatever action is currently
+   * highlighted and then close this popup. If no entries are highlighted (i.e. the list is empty), no action is
+   * triggered and the popup closes anyway.
+   */
+  void perform_action();
+
+  /**
+   * @brief Move selection up
+   *
+   * A slot for pressing up on the ActionSearchEntry field. Moves the selection in the list up once. If the
+   * selection is already at the top of the list, this is a no-op.
+   */
+  void move_selection_up();
+
+  /**
+   * @brief Move selection down
+   *
+   * A slot for pressing down on the ActionSearchEntry field. Moves the selection in the list down once. If the
+   * selection is already at the bottom of the list, this is a no-op.
+   */
+  void move_selection_down();
+private:
+  /**
+   * @brief Main widget that shows the list of commands
+   */
+  ActionSearchList* list_widget;
+
+  /**
+   * @brief Attached menu bar object
+   */
+  QMenuBar* menu_bar_;
+};
+
+/**
+ * @brief The ActionSearchList class
+ *
+ * Simple wrapper around QListWidget that emits a signal when an item is double clicked that ActionSearch connects
+ * to a slot that triggers the currently selected action.
+ */
+class ActionSearchList : public QListWidget {
+  Q_OBJECT
+public:
+  /**
+   * @brief ActionSearchList Constructor
+   * @param parent
+   *
+   * Usually ActionSearch.
+   */
+  ActionSearchList(QWidget* parent);
+protected:
+  /**
+   * @brief Override of QListWidget's double click event that emits a signal.
+   */
+  void mouseDoubleClickEvent(QMouseEvent *);
+signals:
+  /**
+   * @brief Signal emitted when a QListWidget item is double clicked.
+   */
+  void dbl_click();
+};
+
+/**
+ * @brief The ActionSearchEntry class
+ *
+ * Simple wrapper around QLineEdit that emits signals when the up or down arrow keys are pressed so that ActionSearch
+ * can connect them to moving the current selection up or down.
+ */
+class ActionSearchEntry : public QLineEdit {
+  Q_OBJECT
+public:
+  /**
+   * @brief ActionSearchEntry
+   * @param parent
+   *
+   * Usually ActionSearch.
+   */
+  ActionSearchEntry(QWidget* parent);
+protected:
+  /**
+   * @brief Override of QLineEdit's key press event that listens for up/down key presses.
+   * @param event
+   */
+  void keyPressEvent(QKeyEvent * event);
+signals:
+  /**
+   * @brief Emitted when the user presses the up arrow key.
+   */
+  void moveSelectionUp();
+
+  /**
+   * @brief Emitted when the user presses the down arrow key.
+   */
+  void moveSelectionDown();
+};
+
+#endif // ACTIONSEARCH_H

app/dialog/preferences/preferences.h

@@ -0,0 +1,432 @@
+/***
+
+  Olive - Non-Linear Video Editor
+  Copyright (C) 2019  Olive Team
+
+  This program 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.
+
+  This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+
+***/
+
+#ifndef PREFERENCESDIALOG_H
+#define PREFERENCESDIALOG_H
+
+#include <QDialog>
+#include <QKeySequenceEdit>
+#include <QMenuBar>
+#include <QLineEdit>
+#include <QComboBox>
+#include <QRadioButton>
+#include <QTreeWidget>
+#include <QTreeWidgetItem>
+#include <QMenu>
+#include <QCheckBox>
+#include <QDoubleSpinBox>
+#include <QSpinBox>
+#include <OpenColorIO/OpenColorIO.h>
+namespace OCIO = OCIO_NAMESPACE::v1;
+
+#include "timeline/sequence.h"
+
+class KeySequenceEditor;
+
+/**
+ * @brief The PreferencesDialog class
+ *
+ * A dialog for the global application settings. Mostly an interface for Config. Can be loaded from any part of the
+ * application.
+ */
+class PreferencesDialog : public QDialog
+{
+  Q_OBJECT
+
+public:
+  /**
+   * @brief PreferencesDialog Constructor
+   *
+   * @param parent
+   *
+   * QWidget parent. Usually MainWindow.
+   */
+  explicit PreferencesDialog(QWidget *parent = nullptr);
+
+private slots:
+  /**
+   * @brief Override of accept to save preferences to Config.
+   */
+  virtual void accept() override;
+
+  /**
+   * @brief Reset all selected shortcuts in keyboard_tree to their defaults
+   */
+  void reset_default_shortcut();
+
+  /**
+   * @brief Reset all shortcuts indiscriminately to their defaults
+   *
+   * This is safe to call directly as it'll ask the user if they wish to do so before it resets.
+   */
+  void reset_all_shortcuts();
+
+  /**
+   * @brief Shows/hides shortcut entries according to a shortcut query.
+   *
+   * This function can be directly connected to QLineEdit::textChanged() for simplicity.
+   *
+   * @param s
+   *
+   * The search query to compare shortcut names to.
+   *
+   * @param parent
+   *
+   * This is used as the function calls itself recursively to traverse the menu item hierarchy. This should be left as
+   * nullptr when called externally.
+   *
+   * @return
+   *
+   * Value used as function calls itself recursively to determine if a menu parent has any children that are not hidden.
+   * If so, TRUE is returned so the parent is shown too (even if it doesn't match the search query). If not, FALSE is
+   * returned so the parent is hidden.
+   */
+  bool refine_shortcut_list(const QString &s, QTreeWidgetItem* parent = nullptr);
+
+  /**
+   * @brief Show a file dialog to load an external shortcut preset from file
+   */
+  void load_shortcut_file();
+
+  /**
+   * @brief Show a file dialog to save an external shortcut preset from file
+   */
+  void save_shortcut_file();
+
+  /**
+   * @brief Delete all previews (waveform and thumbnail cache)
+   */
+  void delete_all_previews();
+
+  // Browse for file functionns
+  /**
+   * @brief Show a file dialog to browse for an external CSS file to load for styling the application.
+   */
+  void browse_css_file();
+  void browse_ocio_config();
+
+  // OCIO function
+  void update_ocio_view_menu();
+  void update_ocio_view_menu(OCIO::ConstConfigRcPtr config);
+  void update_ocio_config(const QString&);
+
+  /**
+   * @brief Shows a NewSequenceDialog attached to default_sequence
+   */
+  void edit_default_sequence_settings();
+
+private:
+
+  /**
+   * @brief Create and arrange all UI widgets
+   */
+  void setup_ui();
+
+  /**
+   * @brief Populate keyboard shortcut panel with keyboard shortcuts from the menu bar
+   *
+   * @param menu
+   *
+   * A reference to the main application's menu bar. Usually MainWindow::menuBar().
+   */
+  void setup_kbd_shortcuts(QMenuBar* menu);
+
+  /**
+   * @brief Internal function called by setup_kbd_shortcuts() to traverse down the menu bar's hierarchy and populate the
+   * shortcut panel.
+   *
+   * This function will call itself recursively as it finds submenus belong to the menu provided. It will also create
+   * QTreeWidgetItems as children of the parent item provided, either using them as parents themselves for submenus
+   * or attaching a KeySequenceEditor to them for shortcut editing.
+   *
+   * @param menu
+   *
+   * The current menu to traverse down.
+   *
+   * @param parent
+   *
+   * The parent item to add QTreeWidgetItems to.
+   */
+  void setup_kbd_shortcut_worker(QMenu* menu, QTreeWidgetItem* parent);
+
+  enum PreviewDeleteTypes {
+    DELETE_NONE,
+    DELETE_THUMBNAILS,
+    DELETE_WAVEFORMS,
+    DELETE_BOTH
+  };
+
+  // used to delete previews
+  // type can be: 't' for thumbnails, 'w' for waveforms, or 1 for all
+  /**
+   * @brief Delete disk cached preview files (thumbnails, waveforms, etc.)
+   *
+   * @param type
+   *
+   * The types of previews to delete.
+   */
+  void delete_previews(PreviewDeleteTypes type);
+
+  void populate_ocio_menus(OCIO::ConstConfigRcPtr config);
+
+  /**
+   * @brief UI widget for editing the CSS filename
+   */
+  QLineEdit* custom_css_fn;
+
+  /**
+   * @brief UI widget for editing the list of extensions to detect image sequences from
+   */
+  QLineEdit* imgSeqFormatEdit;
+
+  /**
+   * @brief UI widget for editing the recording channels
+   */
+  QComboBox* recordingComboBox;
+
+
+  /**
+   * @brief UI widget for editing keyboard shortcuts
+   */
+  QTreeWidget* keyboard_tree;
+
+  /**
+   * @brief UI widget for editing the upcoming queue size
+   */
+  QDoubleSpinBox* upcoming_queue_spinbox;
+
+  /**
+   * @brief UI widget for editing the upcoming queue type
+   */
+  QComboBox* upcoming_queue_type;
+
+  /**
+   * @brief UI widget for editing the previous queue size
+   */
+  QDoubleSpinBox* previous_queue_spinbox;
+
+  /**
+   * @brief UI widget for editing the previous queue type
+   */
+  QComboBox* previous_queue_type;
+
+  /**
+   * @brief UI widget for editing the size of textboxes in the EffectControls panel
+   */
+  QSpinBox* effect_textbox_lines_field;
+
+  /**
+   * @brief UI widget for selecting the output audio device
+   */
+  QComboBox* audio_output_devices;
+
+  /**
+   * @brief UI widget for selecting the input audio device
+   */
+  QComboBox* audio_input_devices;
+
+  /**
+   * @brief UI widget for selecting the audio sampling rates
+   */
+  QComboBox* audio_sample_rate;
+
+  /**
+   * @brief UI widget for selecting the UI language
+   */
+  QComboBox* language_combobox;
+
+  /**
+   * @brief UI widget for selecting the resolution of the thumbnails to generate
+   */
+  QSpinBox* thumbnail_res_spinbox;
+
+  /**
+   * @brief UI widget for selecting the resolution of the waveforms to generate
+   */
+  QSpinBox* waveform_res_spinbox;
+
+  QCheckBox* enable_color_management;
+  QLineEdit* ocio_config_file;
+  QComboBox* ocio_default_input;
+  QComboBox* ocio_display;
+  QComboBox* ocio_view;
+  QComboBox* ocio_look;
+  QComboBox* playback_bit_depth;
+  QComboBox* export_bit_depth;
+
+  /**
+   * @brief UI widget for selecting the current UI style
+   */
+  QComboBox* ui_style;
+
+  /**
+   * @brief Stored default Sequence object
+   *
+   * Default Sequence settings are loaded into an actual Sequence object that can be loaded into NewSequenceDialog
+   * for the sake of familiarity with the user.
+   */
+  Sequence default_sequence;
+
+  /**
+   * @brief List of keyboard shortcut actions that can be triggered (links with key_shortcut_items and
+   * key_shortcut_fields)
+   */
+  QVector<QAction*> key_shortcut_actions;
+
+  /**
+   * @brief List of keyboard shortcut items in keyboard_tree corresponding to existing actions (links with
+   * key_shortcut_actions and key_shortcut_fields)
+   */
+  QVector<QTreeWidgetItem*> key_shortcut_items;
+
+  /**
+   * @brief List of keyboard shortcut editing fields in keyboard_tree corresponding to existing actions (links with
+   * key_shortcut_actions and key_shortcut_fields)
+   */
+  QVector<KeySequenceEditor*> key_shortcut_fields;
+
+  /**
+   * @brief Tests an OpenColorIO configuration file to determine whether it's valid and throws a messagebox if not
+   *
+   * @param url
+   *
+   * URL to the OpenColorIO configuration file.
+   *
+   * @return
+   *
+   * A OCIO::ConstConfigRcPtr config pointer if the configuration file is valid, nullptr if not.
+   */
+  OCIO::ConstConfigRcPtr TestOCIOConfig(const QString& url);
+
+  /**
+   * @brief Add an automated QCheckBox+boolean value pair
+   *
+   * Many preferences are simple true/false (or on/off) options. Rather than adding a QCheckBox for each one and
+   * manually setting its checked value to the configuration setting (and vice versa when saving), this convenience
+   * function will add it to an automated set of checkboxes, automatically setting the checked state to the current
+   * setting, and then saving the new checked state back to the setting when the user accepts the changes (clicks OK).
+   *
+   * @param ui
+   *
+   * A valid QCheckBox item. This function does not take ownership of the QWidget or place it in a layout anywhere.
+   *
+   * @param value
+   *
+   * A pointer to the Boolean value this QCheckBox should be shared with. The QCheckBox widget's checked state will be
+   * set to the value of this pointer.
+   *
+   * @param restart_required
+   *
+   * Defaults to FALSE, set this to TRUE if changing this setting should prompt the user for a restart of Olive before
+   * the setting change takes effect.
+   */
+  void AddBoolPair(QCheckBox* ui, bool* value, bool restart_required = false);
+
+  /**
+   * @brief Internal array managed by AddBoolPair(). Do not access this directly.
+   */
+  QVector<QCheckBox*> bool_ui;
+
+  /**
+   * @brief Internal array managed by AddBoolPair(). Do not access this directly.
+   */
+  QVector<bool*> bool_value;
+
+  /**
+   * @brief Internal array managed by AddBoolPair(). Do not access this directly.
+   */
+  QVector<bool> bool_restart_required;
+};
+
+/**
+ * @brief The KeySequenceEditor class
+ *
+ * Simple derived class of QKeySequenceEdit that attaches to a QAction and provides functions for transferring
+ * keyboard shortcuts to and from it.
+ */
+class KeySequenceEditor : public QKeySequenceEdit {
+  Q_OBJECT
+public:
+  /**
+   * @brief KeySequenceEditor Constructor
+   *
+   * @param parent
+   *
+   * QWidget parent.
+   *
+   * @param a
+   *
+   * The QAction to link to. This cannot be changed throughout the lifetime of a KeySequenceEditor.
+   */
+  KeySequenceEditor(QWidget *parent, QAction* a);
+
+  /**
+   * @brief Sets the attached QAction's shortcut to the shortcut entered in this field.
+   *
+   * This is not done automatically in case the user cancels out of the Preferences dialog, in which case the
+   * expectation is that the changes made will not be saved. Therefore, this needs to be triggered manually when
+   * PreferencesDialog saves.
+   */
+  void set_action_shortcut();
+
+  /**
+   * @brief Set this shortcut back to the QAction's default shortcut
+   *
+   * Each QAction contains the default shortcut in its `property("default")` and can be used to restore the default
+   * "hard-coded" shortcut with this function.
+   *
+   * This function does not save the default shortcut back into the QAction, it simply loads the default shortcut from
+   * the QAction into this edit field. To save it into the QAction, it's necessary to call set_action_shortcut() after
+   * calling this function.
+   */
+  void reset_to_default();
+
+  /**
+   * @brief Return attached QAction's unique ID
+   *
+   * Each of Olive's menu actions has a unique string ID (that, unlike the text, is not translated) for matching with
+   * an external shortcut configuration file. The ID is stored in the QAction's `property("id")`. This function returns
+   * that ID.
+   *
+   * @return
+   *
+   * The QAction's unique ID.
+   */
+  QString action_name();
+
+  /**
+   * @brief Serialize this shortcut entry into a string that can be saved to a file
+   *
+   * @return
+   *
+   * A string serialization of this shortcut. The format is "[ID]\t[SEQUENCE]" where [ID] is the attached QAction's
+   * unique identifier and [SEQUENCE] is the current keyboard shortcut in the field (NOT necessarily the shortcut in
+   * the QAction). If the entered shortcut is the same as the QAction's default shortcut, the return value is empty
+   * because a default shortcut does not need to be saved to a file.
+   */
+  QString export_shortcut();
+private:
+  /**
+   * @brief Internal reference to the linked QAction
+   */
+  QAction* action;
+};
+
+#endif // PREFERENCESDIALOG_H