#include "toonzqt/menubarcommand.h"
//#include "menubarcommandids.h"
#include "toonzqt/dvdialog.h"
#include "toonzqt/gutil.h"
#include "toonz/toonzfolders.h"
#include <assert.h>
#include <QObject>
#include <QAction>
#include <QSettings>
#include <QKeySequence>
#include <QApplication>
#include <sys/types.h>
using namespace DVGui;
//---------------------------------------------------------
namespace {
void updateToolTip(QAction *action) {
QString tooltip = action->text();
QString shortcut = action->shortcut().toString();
if (shortcut != "") tooltip += " (" + shortcut + ")";
action->setToolTip(tooltip);
}
} // namespace
//=========================================================
AuxActionsCreator::AuxActionsCreator() {
AuxActionsCreatorManager::instance()->addAuxActionsCreator(this);
}
//-----------------------------------------------------------------------------
AuxActionsCreatorManager::AuxActionsCreatorManager()
: m_auxActionsCreated(false) {}
AuxActionsCreatorManager *AuxActionsCreatorManager::instance() {
static AuxActionsCreatorManager _instance;
return &_instance;
}
void AuxActionsCreatorManager::addAuxActionsCreator(
AuxActionsCreator *auxActionsCreator) {
m_auxActionsCreators.push_back(auxActionsCreator);
}
void AuxActionsCreatorManager::createAuxActions(QObject *parent) {
if (m_auxActionsCreated) return;
m_auxActionsCreated = true;
for (int i = 0; i < (int)m_auxActionsCreators.size(); i++)
m_auxActionsCreators[i]->createActions(parent);
}
//=========================================================
CommandManager::CommandManager() {}
//---------------------------------------------------------
CommandManager::~CommandManager() {
std::map<std::string, Node *>::iterator it;
for (it = m_idTable.begin(); it != m_idTable.end(); ++it) delete it->second;
}
//---------------------------------------------------------
CommandManager *CommandManager::instance() {
static CommandManager _instance;
return &_instance;
}
//---------------------------------------------------------
//
// command id => command
//
CommandManager::Node *CommandManager::getNode(CommandId id,
bool createIfNeeded) {
AuxActionsCreatorManager::instance()->createAuxActions(qApp);
std::map<std::string, Node *>::iterator it = m_idTable.find(id);
if (it != m_idTable.end()) return it->second;
if (createIfNeeded) {
Node *node = new Node(id);
m_idTable[id] = node;
return node;
} else
return 0;
}
//---------------------------------------------------------
void CommandManager::setShortcut(CommandId id, QAction *action,
std::string shortcutString) {
if (shortcutString != "")
action->setShortcut(QKeySequence(QString::fromStdString(shortcutString)));
else
action->setShortcut(QKeySequence());
TFilePath fp = ToonzFolder::getMyModuleDir() + TFilePath("shortcuts.ini");
QSettings settings(toQString(fp), QSettings::IniFormat);
settings.beginGroup("shortcuts");
settings.setValue(QString(id), QString::fromStdString(shortcutString));
settings.endGroup();
}
//---------------------------------------------------------
void CommandManager::define(CommandId id, CommandType type,
std::string defaultShortcutString,
QAction *qaction) {
assert(type != UndefinedCommandType);
assert(qaction != 0);
assert(m_qactionTable.count(qaction) == 0);
Node *node = getNode(id);
if (node->m_type != UndefinedCommandType) {
assert(!"Duplicate command id");
}
node->m_type = type;
node->m_qaction = qaction;
node->m_qaction->setEnabled(
node->m_enabled &&
(!!node->m_handler || node->m_qaction->actionGroup() != 0) ||
node->m_type == MiscCommandType ||
node->m_type == ToolModifierCommandType);
m_qactionTable[qaction] = node;
qaction->setShortcutContext(Qt::ApplicationShortcut);
TFilePath fp = ToonzFolder::getModuleFile("shortcuts.ini");
QSettings settings(toQString(fp), QSettings::IniFormat);
settings.beginGroup("shortcuts");
QString defaultShortcutQString =
QString::fromStdString(defaultShortcutString);
/*-
Some shortcuts may just removed from the default settings.
So you need to distinguish between "shortcut is not defined by user"
and "shortcut is removed (i.e. defined as "") by user".
-*/
QString shortcutString = settings.value(id, "undefined").toString();
settings.endGroup();
if (shortcutString != "" && shortcutString != "undefined") {
// User-defined shortcuts. It may have been assigned as a shortcut by
// default to some other command
QAction *other = getActionFromShortcut(shortcutString.toStdString());
if (other) other->setShortcut(QKeySequence());
} else if (defaultShortcutQString != "" && shortcutString == "undefined") {
// Shortcut key set by default. Check if the key already been assigned to
// another action
QAction *other =
getActionFromShortcut(defaultShortcutQString.toStdString());
if (!other) shortcutString = defaultShortcutQString;
}
if (shortcutString != "" && shortcutString != "undefined") {
qaction->setShortcut(QKeySequence(shortcutString));
m_shortcutTable[shortcutString.toStdString()] = node;
}
if (type == ToolCommandType) updateToolTip(qaction);
}
//---------------------------------------------------------
//
// set handler (id, handler)
// possibly changes enable/disable qaction state
//
void CommandManager::setHandler(CommandId id,
CommandHandlerInterface *handler) {
Node *node = getNode(id);
if (node->m_handler != handler) {
delete node->m_handler;
node->m_handler = handler;
}
if (node->m_qaction) {
node->m_qaction->setEnabled(
node->m_enabled &&
(!!node->m_handler || node->m_qaction->actionGroup() != 0));
}
}
//---------------------------------------------------------
//
// qaction -> command; execute
//
void CommandManager::execute(QAction *qaction) {
assert(qaction);
std::map<QAction *, Node *>::iterator it = m_qactionTable.find(qaction);
assert(it != m_qactionTable.end());
if (it != m_qactionTable.end() && it->second->m_handler) {
it->second->m_handler->execute();
}
}
//---------------------------------------------------------
void CommandManager::execute(QAction *action, QAction *menuAction) {
std::map<QAction *, Node *>::iterator it = m_qactionTable.find(action);
if (it != m_qactionTable.end())
execute(action);
else
execute(menuAction);
}
//---------------------------------------------------------
void CommandManager::execute(CommandId id) {
Node *node = getNode(id, false);
if (node && node->m_handler) {
QAction *action = node->m_qaction;
if (action && action->isCheckable()) {
// principalmente per i tool
action->setChecked(true);
}
node->m_handler->execute();
}
}
//---------------------------------------------------------
void CommandManager::getActions(CommandType type,
std::vector<QAction *> &actions) {
AuxActionsCreatorManager::instance()->createAuxActions(qApp);
std::map<QAction *, Node *>::iterator it;
for (it = m_qactionTable.begin(); it != m_qactionTable.end(); ++it)
if (it->second->m_type == type) actions.push_back(it->first);
}
//---------------------------------------------------------
QAction *CommandManager::getActionFromShortcut(std::string shortcutString) {
std::map<std::string, Node *>::iterator it =
m_shortcutTable.find(shortcutString);
return it != m_shortcutTable.end() ? it->second->m_qaction : 0;
}
//---------------------------------------------------------
std::string CommandManager::getShortcutFromAction(QAction *action) {
std::map<std::string, Node *>::iterator it = m_shortcutTable.begin();
for (; it != m_shortcutTable.end(); ++it) {
if (it->second->m_qaction == action) return it->first;
}
return "";
}
//---------------------------------------------------------
std::string CommandManager::getShortcutFromId(const char *id) {
QAction *action = getAction(id);
assert(action);
if (!action) return "";
return getShortcutFromAction(action);
}
//---------------------------------------------------------
int CommandManager::getKeyFromShortcut(const std::string &shortcut) {
QString qShortcut = QString::fromStdString(shortcut);
if (qShortcut == "") return 0;
QKeySequence ks(qShortcut);
assert(ks.count() == 1);
return ks[0];
}
//---------------------------------------------------------
int CommandManager::getKeyFromId(const char *id) {
return getKeyFromShortcut(getShortcutFromId(id));
}
//---------------------------------------------------------
void CommandManager::setShortcut(QAction *action, std::string shortcutString,
bool keepDefault) {
QString shortcut = QString::fromStdString(shortcutString);
std::string oldShortcutString = action->shortcut().toString().toStdString();
if (oldShortcutString == shortcutString) return;
// Cerco il nodo corrispondente ad action. Deve esistere
std::map<QAction *, Node *>::iterator it = m_qactionTable.find(action);
Node *node = it != m_qactionTable.end() ? it->second : 0;
assert(node);
assert(node->m_qaction == action);
QKeySequence ks(shortcut);
assert(ks.count() == 1 || ks.count() == 0 && shortcut == "");
if (node->m_type == ZoomCommandType && ks.count() > 1) {
DVGui::warning(
QObject::tr("It is not possible to assign a shortcut with modifiers to "
"the visualization commands."));
return;
}
// lo shortcut e' gia' assegnato?
QString oldActionId;
std::map<std::string, Node *>::iterator sit =
m_shortcutTable.find(shortcutString);
if (sit != m_shortcutTable.end()) {
// la vecchia azione non ha piu' shortcut
oldActionId = QString::fromStdString(sit->second->m_id);
sit->second->m_qaction->setShortcut(QKeySequence());
if (sit->second->m_type == ToolCommandType)
updateToolTip(sit->second->m_qaction);
}
// assegno lo shortcut all'azione
action->setShortcut(
QKeySequence::fromString(QString::fromStdString(shortcutString)));
if (node->m_type == ToolCommandType) updateToolTip(action);
// Aggiorno la tabella shortcut -> azioni
// Cancello il riferimento all'eventuale vecchio shortcut di action
if (oldShortcutString != "") m_shortcutTable.erase(oldShortcutString);
// e aggiungo il nuovo legame
m_shortcutTable[shortcutString] = node;
// registro il tutto
TFilePath fp = ToonzFolder::getMyModuleDir() + TFilePath("shortcuts.ini");
QSettings settings(toQString(fp), QSettings::IniFormat);
settings.beginGroup("shortcuts");
settings.setValue(QString::fromStdString(node->m_id),
QString::fromStdString(shortcutString));
if (keepDefault) {
if (oldActionId != "") settings.remove(oldActionId);
}
settings.endGroup();
}
//---------------------------------------------------------
void CommandManager::enable(CommandId id, bool enabled) {
Node *node = getNode(id, false);
if (!node) return;
if (node->m_enabled == enabled) return;
node->m_enabled = enabled;
if (node->m_qaction)
node->m_qaction->setEnabled(
node->m_enabled &&
(!!node->m_handler || node->m_qaction->actionGroup() != 0));
}
//---------------------------------------------------------
void CommandManager::setChecked(CommandId id, bool checked) {
Node *node = getNode(id, false);
if (!node) return;
if (node->m_qaction) {
node->m_qaction->setChecked(checked);
if (node->m_handler) node->m_handler->execute();
}
}
//---------------------------------------------------------
QAction *CommandManager::getAction(CommandId id, bool createIfNeeded) {
Node *node = getNode(id, createIfNeeded);
if (node) {
return node->m_qaction;
} else {
return 0;
}
}
//---------------------------------------------------------
QAction *CommandManager::createAction(CommandId id, QObject *parent,
bool state) {
Node *node = getNode(id, false);
if (!node) return 0;
QAction *refAction = node->m_qaction;
if (!refAction) return 0;
QString text = refAction->text();
if (node->m_onText != "" && node->m_offText != "")
text = state ? node->m_onText : node->m_offText;
QAction *action = new QAction(text, parent);
action->setShortcut(refAction->shortcut());
return action;
}
//---------------------------------------------------------
void CommandManager::setToggleTexts(CommandId id, const QString &onText,
const QString &offText) {
Node *node = getNode(id, false);
if (node) {
node->m_onText = onText;
node->m_offText = offText;
}
}
//---------------------------------------------------------
std::string CommandManager::getIdFromAction(QAction *action) {
std::map<QAction *, Node *>::iterator it = m_qactionTable.find(action);
if (it != m_qactionTable.end())
return it->second->m_id;
else
return "";
}
/*
//---------------------------------------------------------
QString CommandManager::getFullText(CommandId id, bool state)
{
std::map<std::string, Node*>::iterator it;
it = m_idTable.find(id);
if(it == m_idTable.end()) return "";
Node *node = it->second;
QAction *action = it->second->m_qaction;
QString text = action->text();
if(node->m_onText != "" && node->m_offText != "")
text = state ? node->m_onText : node->m_offText;
QString shortcut = QString::fromStdString(getShortcutFromAction(action));
if(shortcut != "") text += " " + shortcut;
return text;
}
*/
//---------------------------------------------------------
MenuItemHandler::MenuItemHandler(const char *cmdId) {
CommandManager::instance()->setHandler(
cmdId, new CommandHandlerHelper<MenuItemHandler>(
this, &MenuItemHandler::execute));
}
//=============================================================================
// DVAction
//-----------------------------------------------------------------------------
DVAction::DVAction(const QString &text, QObject *parent)
: QAction(text, parent) {
connect(this, SIGNAL(triggered()), this, SLOT(onTriggered()));
}
//-----------------------------------------------------------------------------
DVAction::DVAction(const QIcon &icon, const QString &text, QObject *parent)
: QAction(icon, text, parent) {
connect(this, SIGNAL(triggered()), this, SLOT(onTriggered()));
}
//-----------------------------------------------------------------------------
void DVAction::onTriggered() { CommandManager::instance()->execute(this); }
//=============================================================================
// DVMenuAction
//-----------------------------------------------------------------------------
/*! It is a menu' with action defined in \b actions.
Actions can contain CommandId or simple action name.
In first case action triggered is connected with action command
execute directly.
In second case action triggered is connected with menu action
command execute;
is helpful to use \b m_triggeredActionIndex to distingue action.
*/
DVMenuAction::DVMenuAction(const QString &text, QWidget *parent,
QList<QString> actions)
: QMenu(text, parent), m_triggeredActionIndex(-1) {
int i;
for (i = 0; i < actions.size(); i++) addAction(actions.at(i));
connect(this, SIGNAL(triggered(QAction *)), this,
SLOT(onTriggered(QAction *)));
}
//-----------------------------------------------------------------------------
/*! Set a new list of action to menu'.
NB. If action list is composed by action menaged and action to
create pay
attention to inserted order.*/
void DVMenuAction::setActions(QList<QString> actions) {
if (m_triggeredActionIndex != -1) // Sta facendo l'onTriggered
return;
clear();
int i;
for (i = 0; i < actions.size(); i++) {
QString actionId = actions.at(i);
// Se l'azione e' definita da un CommandId la aggiungo.
QAction *action =
CommandManager::instance()->getAction(actionId.toStdString().c_str());
if (action) {
addAction(action);
continue;
}
// Altrimenti creo una nuova azione e la aggiungo.
action = addAction(actionId);
action->setData(QVariant(i));
}
}
//-----------------------------------------------------------------------------
namespace {
QString changeStringNumber(QString str, int index) {
QString newStr = str;
int n = 3;
if (index >= 10) n = 4;
QString number;
newStr.replace(0, n, number.number(index + 1) + QString(". "));
return newStr;
}
}
//-----------------------------------------------------------------------------
void DVMenuAction::onTriggered(QAction *action) {
QVariant data = action->data();
if (data.isValid()) m_triggeredActionIndex = data.toInt();
CommandManager::instance()->execute(action, menuAction());
int oldIndex = m_triggeredActionIndex;
if (m_triggeredActionIndex != -1) m_triggeredActionIndex = -1;
QString str = data.toString();
QAction *tableAction =
CommandManager::instance()->getAction(str.toStdString().c_str());
if (tableAction || oldIndex == 0) return;
QList<QAction *> acts = actions();
removeAction(action);
insertAction(acts[0], action);
acts = actions();
int i;
for (i = 0; i <= oldIndex; i++) {
QAction *a = acts.at(i);
QString newTxt = changeStringNumber(a->text(), i);
a->setText(newTxt);
a->setData(QVariant(i));
}
m_triggeredActionIndex = -1;
}
//-----------------------------------------------------------------------------