oak-editor/app/widget/menu/menu.h

/***

  Olive - Non-Linear Video Editor
  Copyright (C) 2022 Olive Team
  Modifications Copyright (C) 2025 mikesolar

  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 OAK_WIDGETMENU_H
#define OAK_WIDGETMENU_H

#include <QMenuBar>
#include <QMenu>
#include <QMetaMethod>

#include "oakutil/define.h"

namespace olive
{

/**
 * @brief A menu widget for context menus and menu bars
 *
 * A QMenu subclass with functions for creating menus and menu items that conform to Olive's menu and keyboard shortcut
 * system.
 *
 * In Olive, menu items in the menu bar are also responsible for keyboard shortcuts throughout the application. To allow
 * these to be configurable and these configurations saveable, every item needs a unique ID. This ID gets linked to the
 * keyboard shortcuts in config files. The ID doesn't get translated so it can also persist through language changes.
 *
 * The ID gets stored in the QAction's "id" property. If a keyboard shortcut is provided, it gets stored in the
 * QAction's "keydefault" property.
 *
 * It is always recommended to use this over QMenu in any situation.
 */
class Menu : public QMenu {
public:
	Menu(QMenuBar *bar);

	template <typename Func>
	/**
   * @brief Construct a Menu and add it to a QMenuBar
   *
   * This Menu can be connected to a slot that's triggered when the Menu is "about to show". Use `receiver` and
   * `member` to connect this (same syntax as QObject::connect) or leave as nullptr to not.
   */
	Menu(QMenuBar *bar,
		 const typename QtPrivate::FunctionPointer<Func>::Object *receiver,
		 Func member)
	{
		bar->addMenu(this);

		init();
		connect_about_to_show(receiver, member);
	}

	Menu(Menu *menu);

	template <typename Func>
	/**
   * @brief Construct a Menu and add it as a submenu to another Menu
   *
   * This Menu can be connected to a slot that's triggered when the Menu is "about to show". Use `receiver` and
   * `member` to connect this (same syntax as QObject::connect) or leave as nullptr to not.
   */
	Menu(Menu *menu,
		 const typename QtPrivate::FunctionPointer<Func>::Object *receiver,
		 Func member)
	{
		menu->addMenu(this);

		init();
		ConnectAboutToShow(receiver, member);
	}

	/**
   * @brief Construct a popup menu
   */
	Menu(QWidget *parent = nullptr);

	/**
   * @brief Construct a popup menu
   */
	Menu(const QString &s, QWidget *parent = nullptr);

	template <typename Func>
	/**
   * @brief Create a menu item and add it to this menu
   *
   * @param id
   *
   * The action's unique ID
   *
   * @param receiver
   *
   * The QObject to receive the signal when this item is triggered
   *
   * @param member
   *
   * The QObject slot to connect this action's triggered signal to
   *
   * @param key
   *
   * Default keyboard sequence
   *
   * @return
   *
   * The QAction that was created and added to this Menu
   */
	QAction *
	add_item(const QString &id,
			const typename QtPrivate::FunctionPointer<Func>::Object *receiver,
			Func member, const QKeySequence &key = QKeySequence())
	{
		QAction *a = create_item(this, id, receiver, member, key);

		addAction(a);

		return a;
	}

	QAction *add_action_with_data(const QString &text, const QVariant &d,
							   const QVariant &compare);

	QAction *insert_alphabetically(const QString &s);
	void insert_alphabetically(QAction *entry);
	void insert_alphabetically(Menu *menu);

	template <typename Func>
	/**
   * @brief Create a menu item
   *
   * @param parent
   *
   * The QAction's parent
   *
   * @param id
   *
   * The action's unique ID
   *
   * @param receiver
   *
   * The QObject to receive the signal when this item is triggered
   *
   * @param member
   *
   * The QObject slot to connect this action's triggered signal to
   *
   * @param key
   *
   * Default keyboard sequence
   *
   * @return
   *
   * The QAction that was created and added to this Menu
   */
	static QAction *create_item(
		QObject *parent, const QString &id,
		const typename QtPrivate::FunctionPointer<Func>::Object *receiver,
		Func member, const QKeySequence &key = QKeySequence())
	{
		QAction *a = new QAction(parent);

		conform_item(a, id, receiver, member, key);

		return a;
	}

	template <typename Func>
	/**
   * @brief Conform a QAction to Olive's ID/keydefault system
   *
   * If a QAction was created elsewhere (e.g. through QUndoStack::createUndoAction()), this function will give it
   * properties conforming it to Olive's menu item system
   *
   * @param a
   *
   * The QAction's to conform
   *
   * @param id
   *
   * The action's unique ID
   *
   * @param receiver
   *
   * The QObject to receive the signal when this item is triggered
   *
   * @param member
   *
   * The QObject slot to connect this action's triggered signal to
   *
   * @param key
   *
   * Default keyboard sequence
   */
	static void conform_item(
		QAction *a, const QString &id,
		const typename QtPrivate::FunctionPointer<Func>::Object *receiver,
		Func member, const QKeySequence &key = QKeySequence())
	{
		conform_item(a, id, key);

		connect(a, &QAction::triggered, receiver, member);
	}

	static void conform_item(QAction *a, const QString &id,
							const QKeySequence &key = QKeySequence());

private:
	void init();

	template <typename Func>
	void connect_about_to_show(
		const typename QtPrivate::FunctionPointer<Func>::Object *receiver,
		Func member)
	{
		connect(this, &Menu::aboutToShow, receiver, member);
	}
};

}

#endif // OAK_WIDGETMENU_H