VCButton::VCButton(QWidget* parent) : VCWidget(parent, "Button")
{
/* Just a pointer to the function selection dialog. This is used
only when the menu item for selecting a function is clicked */
m_functionManager = NULL;
/* No function is initially attached to the button */
m_function = KNoID;
QToolTip::add(this, "No function");
/* Set the frame line width a bit thicker to make this look more
like a button than a frame (which it actually is) */
setLineWidth(2);
setCaption("");
setOn(false);
setExclusive(false);
m_stopFunctions = false;
/* Initial size */
setMinimumSize(20, 20);
resize(QPoint(30, 30));
/* Keybinding */
m_keyBind = new KeyBind();
connect(m_keyBind, SIGNAL(pressed()), this, SLOT(pressFunction()));
connect(m_keyBind, SIGNAL(released()), this, SLOT(releaseFunction()));
}
QAction* CodeNavigator::configMenu(QWidget *parent)
{
static QAction *configAction = nullptr;
if (!configAction) {
configAction = new QAction(QIcon::fromTheme(QStringLiteral("applications-development")), QObject::tr("Code Navigation"), parent);
auto menu = new QMenu(parent);
auto group = new QActionGroup(parent);
group->setExclusive(true);
QSettings settings;
settings.beginGroup(QStringLiteral("CodeNavigator"));
const auto currentIdx = settings.value(QStringLiteral("IDE"), -1).toInt();
for (int i = 0; i < ide_settings_size; ++i) {
auto action = new QAction(menu);
action->setText(QObject::tr(ide_settings[i].name));
if (ide_settings[i].icon)
action->setIcon(QIcon::fromTheme(ide_settings[i].icon));
action->setCheckable(true);
action->setChecked(currentIdx == i);
action->setData(i);
action->setEnabled(!QStandardPaths::findExecutable(ide_settings[i].app).isEmpty());
group->addAction(action);
menu->addAction(action);
}
menu->addSeparator();
auto action = new QAction(menu);
action->setText(QObject::tr("Custom..."));
action->setCheckable(true);
action->setChecked(currentIdx == -1);
group->addAction(action);
menu->addAction(action);
QObject::connect(group, &QActionGroup::triggered, [parent](QAction *action) {
QSettings settings;
settings.beginGroup(QStringLiteral("CodeNavigator"));
if (!action->data().isValid()) {
const auto customCmd = QInputDialog::getText(
parent, QObject::tr("Custom Code Navigation"),
QObject::tr("Specify command to use for code navigation, '%f' will be replaced by the file name, '%l' by the line number."),
QLineEdit::Normal, settings.value(QStringLiteral("CustomCommand")).toString()
);
if (!customCmd.isEmpty()) {
settings.setValue(QStringLiteral("CustomCommand"), customCmd);
settings.setValue(QStringLiteral("IDE"), -1);
}
return;
}
const auto defaultIdx = action->data().toInt();
settings.setValue(QStringLiteral("IDE"), defaultIdx);
});
configAction->setMenu(menu);
}
return configAction;
}
eRCDeviceInputDev::eRCDeviceInputDev(eRCInputEventDriver *driver)
:eRCDevice(driver->getDeviceName(), driver), iskeyboard(false)
{
if (strcasestr(id.c_str(), "keyboard") != NULL)
iskeyboard = true;
setExclusive(true);
eDebug("Input device \"%s\" is %sa keyboard.", id.c_str(), iskeyboard ? "" : "not ");
}
eRCDeviceInputDev::eRCDeviceInputDev(eRCInputEventDriver *driver, int consolefd)
: eRCDevice(driver->getDeviceName(), driver), iskeyboard(driver->isKeyboard()),
ismouse(driver->isPointerDevice()),
consoleFd(consolefd), shiftState(false), capsState(false)
{
setExclusive(true);
eDebug("Input device \"%s\" is a %s", id.c_str(), iskeyboard ? "keyboard" : (ismouse ? "mouse" : "remotecontrol"));
}
bool LibPartedDevice::openExclusive()
{
bool rval = open() && ped_device_open(pedDevice());
if (rval)
setExclusive(true);
return rval;
}
bool LibPartedDevice::close()
{
Q_ASSERT(pedDevice());
if (pedDevice() && isExclusive()) {
ped_device_close(pedDevice());
setExclusive(false);
}
m_PedDevice = nullptr;
return true;
}
int Q3ActionGroup::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = Q3Action::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: selected((*reinterpret_cast< Q3Action*(*)>(_a[1]))); break;
case 1: activated((*reinterpret_cast< Q3Action*(*)>(_a[1]))); break;
case 2: childToggled((*reinterpret_cast< bool(*)>(_a[1]))); break;
case 3: childActivated(); break;
case 4: childDestroyed(); break;
case 5: internalComboBoxActivated((*reinterpret_cast< int(*)>(_a[1]))); break;
case 6: internalComboBoxHighlighted((*reinterpret_cast< int(*)>(_a[1]))); break;
case 7: internalToggle((*reinterpret_cast< Q3Action*(*)>(_a[1]))); break;
case 8: objectDestroyed(); break;
}
_id -= 9;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< bool*>(_v) = isExclusive(); break;
case 1: *reinterpret_cast< bool*>(_v) = usesDropDown(); break;
}
_id -= 2;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: setExclusive(*reinterpret_cast< bool*>(_v)); break;
case 1: setUsesDropDown(*reinterpret_cast< bool*>(_v)); break;
}
_id -= 2;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 2;
}
#endif // QT_NO_PROPERTIES
return _id;
}
PreviewActionGroup::PreviewActionGroup(QDesignerFormEditorInterface *core, QObject *parent) :
QActionGroup(parent),
m_core(core)
{
/* Create a list of up to MaxDeviceActions invisible actions to be
* populated with device profiles (actiondata: index) followed by the
* standard style actions (actiondata: style name). */
connect(this, SIGNAL(triggered(QAction*)), this, SLOT(slotTriggered(QAction*)));
setExclusive(true);
const QString objNamePostfix = QStringLiteral("_action");
// Create invisible actions for devices. Set index as action data.
QString objNamePrefix = QStringLiteral("__qt_designer_device_");
for (int i = 0; i < MaxDeviceActions; i++) {
QAction *a = new QAction(this);
QString objName = objNamePrefix;
objName += QString::number(i);
objName += objNamePostfix;
a->setObjectName(objName);
a->setVisible(false);
a->setData(i);
addAction(a);
}
// Create separator at index MaxDeviceActions
QAction *sep = new QAction(this);
sep->setObjectName(QStringLiteral("__qt_designer_deviceseparator"));
sep->setSeparator(true);
sep->setVisible(false);
addAction(sep);
// Populate devices
updateDeviceProfiles();
// Add style actions
const QStringList styles = QStyleFactory::keys();
const QStringList::const_iterator cend = styles.constEnd();
// Make sure ObjectName is unique in case toolbar solution is used.
objNamePrefix = QStringLiteral("__qt_designer_style_");
// Create styles. Set style name string as action data.
for (QStringList::const_iterator it = styles.constBegin(); it != cend ;++it) {
QAction *a = new QAction(tr("%1 Style").arg(*it), this);
QString objName = objNamePrefix;
objName += *it;
objName += objNamePostfix;
a->setObjectName(objName);
a->setData(*it);
addAction(a);
}
}
bool QActionGroup::qt_property( int id, int f, QVariant* v)
{
switch ( id - staticMetaObject()->propertyOffset() ) {
case 0: switch( f ) {
case 0: setExclusive(v->asBool()); break;
case 1: *v = QVariant( this->isExclusive(), 0 ); break;
case 3: case 4: case 5: break;
default: return FALSE;
} break;
case 1: switch( f ) {
case 0: setUsesDropDown(v->asBool()); break;
case 1: *v = QVariant( this->usesDropDown(), 0 ); break;
case 3: case 4: case 5: break;
default: return FALSE;
} break;
default:
return QAction::qt_property( id, f, v );
}
return TRUE;
}
QActionGroup* ActionManager::addActionGroup(const QString &id,
bool enabled,
bool visible,
bool exclusive)
{
if (hasActionGroup(id))
return nullptr;
const auto inserted = m_actionGroups.insert(
std::make_pair(id, std14_stl::make_unique<QActionGroup>(m_pMainWindow)));
if (inserted.second) {
auto pActionGroup = inserted.first->second.get();
pActionGroup->setEnabled(enabled);
pActionGroup->setVisible(visible);
pActionGroup->setExclusive(exclusive);
return pActionGroup;
}
return nullptr;
}
CheckBoxGroup::CheckBoxGroup(QWidget *parent) :
QButtonGroup(parent)
{
setExclusive(false);
connect(this, SIGNAL(buttonClicked(QAbstractButton*)), this, SLOT(buttonClick(QAbstractButton*)));
}
void ActionManager::initEditMenuActions()
{
static const auto DEFAULT_SHORTCUT_EDIT_MENU_UNDO = QKeySequence{QKeySequence::Undo};
static const auto DEFAULT_SHORTCUT_EDIT_MENU_REDO = QKeySequence{QKeySequence::Redo};
static const auto DEFAULT_SHORTCUT_EDIT_MENU_CUT = QKeySequence{QKeySequence::Cut};
static const auto DEFAULT_SHORTCUT_EDIT_MENU_COPY = QKeySequence{QKeySequence::Copy};
static const auto DEFAULT_SHORTCUT_EDIT_MENU_PASTE = QKeySequence{QKeySequence::Paste};
static const auto DEFAULT_SHORTCUT_EDIT_MENU_SETTINGS = QKeySequence{QKeySequence::Preferences};
// ActionGroup Undo/Redo
auto ptrGroupEditMenuUndoRedo = std14_stl::make_unique<QActionGroup>(m_pMainWindow);
ptrGroupEditMenuUndoRedo->setExclusive(false);
// Action Undo
auto ptrActionEditMenuUndo = std14_stl::make_unique<QAction>(QObject::tr("Undo"),
m_pMainWindow);
ptrActionEditMenuUndo->setActionGroup(ptrGroupEditMenuUndoRedo.get());
const auto shortcutEditMenuUndo = hasShortcutForID(actions::MENU_EDIT_UNDO)
? m_savedShortcuts.value(actions::MENU_EDIT_UNDO)
: DEFAULT_SHORTCUT_EDIT_MENU_UNDO;
ptrActionEditMenuUndo->setShortcut(shortcutEditMenuUndo);
saveShortcut(actions::MENU_EDIT_UNDO, shortcutEditMenuUndo);
ptrActionEditMenuUndo->setIcon(QIcon{":/icons/main/undo"});
m_actions.insert(std::make_pair(actions::MENU_EDIT_UNDO,
std::move(ptrActionEditMenuUndo)));
// Action Redo
auto ptrActionEditMenuRedo = std14_stl::make_unique<QAction>(QObject::tr("Redo"),
m_pMainWindow);
ptrActionEditMenuRedo->setActionGroup(ptrGroupEditMenuUndoRedo.get());
const auto shortcutEditMenuRedo = hasShortcutForID(actions::MENU_EDIT_REDO)
? m_savedShortcuts.value(actions::MENU_EDIT_REDO)
: DEFAULT_SHORTCUT_EDIT_MENU_REDO;
ptrActionEditMenuRedo->setShortcut(shortcutEditMenuRedo);
saveShortcut(actions::MENU_EDIT_REDO, shortcutEditMenuRedo);
ptrActionEditMenuRedo->setIcon(QIcon{":/icons/main/redo"});
m_actions.insert(std::make_pair(actions::MENU_EDIT_REDO,
std::move(ptrActionEditMenuRedo)));
m_actionGroups.insert(std::make_pair(actions::groups::MENU_EDIT_UNDO_REDO,
std::move(ptrGroupEditMenuUndoRedo)));
// -----------------------------------------------------------
// ActionGroup Editing
auto ptrGroupEditMenuEditing = std14_stl::make_unique<QActionGroup>(m_pMainWindow);
ptrGroupEditMenuEditing->setExclusive(false);
// Action Cut
auto ptrActionEditMenuCut = std14_stl::make_unique<QAction>(QObject::tr("Cut"),
m_pMainWindow);
ptrActionEditMenuCut->setActionGroup(ptrGroupEditMenuEditing.get());
const auto shortcutEditMenuCut = hasShortcutForID(actions::MENU_EDIT_CUT)
? m_savedShortcuts.value(actions::MENU_EDIT_CUT)
: DEFAULT_SHORTCUT_EDIT_MENU_CUT;
ptrActionEditMenuCut->setShortcut(shortcutEditMenuCut);
saveShortcut(actions::MENU_EDIT_CUT, shortcutEditMenuCut);
ptrActionEditMenuCut->setIcon(QIcon{":/icons/main/cut"});
m_actions.insert(std::make_pair(actions::MENU_EDIT_CUT,
std::move(ptrActionEditMenuCut)));
// Action Copy
auto ptrActionEditMenuCopy = std14_stl::make_unique<QAction>(QObject::tr("Copy"),
m_pMainWindow);
ptrActionEditMenuCopy->setActionGroup(ptrGroupEditMenuEditing.get());
const auto shortcutEditMenuCopy = hasShortcutForID(actions::MENU_EDIT_COPY)
? m_savedShortcuts.value(actions::MENU_EDIT_COPY)
: DEFAULT_SHORTCUT_EDIT_MENU_COPY;
ptrActionEditMenuCopy->setShortcut(shortcutEditMenuCopy);
saveShortcut(actions::MENU_EDIT_COPY, shortcutEditMenuCopy);
ptrActionEditMenuCopy->setIcon(QIcon{":/icons/main/copy"});
m_actions.insert(std::make_pair(actions::MENU_EDIT_COPY,
std::move(ptrActionEditMenuCopy)));
// Action Paste
auto ptrActionEditMenuPaste = std14_stl::make_unique<QAction>(QObject::tr("Paste"),
m_pMainWindow);
ptrActionEditMenuPaste->setActionGroup(ptrGroupEditMenuEditing.get());
const auto shortcutEditMenuPaste = hasShortcutForID(actions::MENU_EDIT_PASTE)
? m_savedShortcuts.value(actions::MENU_EDIT_PASTE)
: DEFAULT_SHORTCUT_EDIT_MENU_PASTE;
ptrActionEditMenuPaste->setShortcut(shortcutEditMenuPaste);
saveShortcut(actions::MENU_EDIT_PASTE, shortcutEditMenuPaste);
ptrActionEditMenuPaste->setIcon(QIcon{":/icons/main/paste"});
m_actions.insert(std::make_pair(actions::MENU_EDIT_PASTE,
std::move(ptrActionEditMenuPaste)));
m_actionGroups.insert(std::make_pair(actions::groups::MENU_EDIT_EDITING,
std::move(ptrGroupEditMenuEditing)));
// -----------------------------------------------------------
auto ptrActionEditMenuSettings = std14_stl::make_unique<QAction>(QObject::tr("Settings..."),
m_pMainWindow);
// Action Settings
const auto shortcutEditMenuSettings = hasShortcutForID(actions::MENU_EDIT_SETTINGS)
? m_savedShortcuts.value(actions::MENU_EDIT_SETTINGS)
: DEFAULT_SHORTCUT_EDIT_MENU_SETTINGS;
ptrActionEditMenuSettings->setShortcut(shortcutEditMenuSettings);
saveShortcut(actions::MENU_EDIT_SETTINGS, shortcutEditMenuSettings);
ptrActionEditMenuSettings->setIcon(QIcon{":/icons/main/settings"});
m_actions.insert(std::make_pair(actions::MENU_EDIT_SETTINGS,
std::move(ptrActionEditMenuSettings)));
}
KSimIoJoinBoolIn::KSimIoJoinBoolIn(KSimIoComponent * comp, const KSimIoJoinInfo * info)
: KSimIoJoin(comp, info)
{
setExclusive(true);
}
void ActionManager::initSnippetsMenuActions()
{
static const auto DEFAULT_SHORTCUT_SNIPPETS_MENU_CLOSE = QKeySequence{QKeySequence::Close};
static const auto DEFAULT_SHORTCUT_SNIPPETS_MENU_CLOSE_ALL = QKeySequence{Qt::CTRL + Qt::SHIFT + Qt::Key_W};
static const auto DEFAULT_SHORTCUT_SNIPPETS_MENU_PREV = QKeySequence{QKeySequence::Back};
static const auto DEFAULT_SHORTCUT_SNIPPETS_MENU_NEXT = QKeySequence{QKeySequence::Forward};
// ActionGroup Closing
auto ptrGroupSnippetsMenuClosing = std14_stl::make_unique<QActionGroup>(m_pMainWindow);
ptrGroupSnippetsMenuClosing->setExclusive(false);
// Action Close
auto ptrActionSnippetsMenuClose = std14_stl::make_unique<QAction>(QObject::tr("Close"),
m_pMainWindow);
ptrActionSnippetsMenuClose->setActionGroup(ptrGroupSnippetsMenuClosing.get());
const auto shortcutSnippetsMenuClose = hasShortcutForID(actions::MENU_SNIPPETS_CLOSE)
? m_savedShortcuts.value(actions::MENU_SNIPPETS_CLOSE)
: DEFAULT_SHORTCUT_SNIPPETS_MENU_CLOSE;
ptrActionSnippetsMenuClose->setShortcut(shortcutSnippetsMenuClose);
saveShortcut(actions::MENU_SNIPPETS_CLOSE, shortcutSnippetsMenuClose);
ptrActionSnippetsMenuClose->setIcon(QIcon{":/icons/main/close"});
m_actions.insert(std::make_pair(actions::MENU_SNIPPETS_CLOSE,
std::move(ptrActionSnippetsMenuClose)));
// Action Close All
auto ptrActionSnippetsMenuCloseAll = std14_stl::make_unique<QAction>(QObject::tr("Close All"),
m_pMainWindow);
ptrActionSnippetsMenuCloseAll->setActionGroup(ptrGroupSnippetsMenuClosing.get());
const auto shortcutSnippetsMenuCloseAll = hasShortcutForID(actions::MENU_SNIPPETS_CLOSE_ALL)
? m_savedShortcuts.value(actions::MENU_SNIPPETS_CLOSE_ALL)
: DEFAULT_SHORTCUT_SNIPPETS_MENU_CLOSE_ALL;
ptrActionSnippetsMenuCloseAll->setShortcut(shortcutSnippetsMenuCloseAll);
saveShortcut(actions::MENU_SNIPPETS_CLOSE_ALL, shortcutSnippetsMenuCloseAll);
m_actions.insert(std::make_pair(actions::MENU_SNIPPETS_CLOSE_ALL,
std::move(ptrActionSnippetsMenuCloseAll)));
m_actionGroups.insert(std::make_pair(actions::groups::MENU_SNIPPETS_CLOSING,
std::move(ptrGroupSnippetsMenuClosing)));
// -----------------------------------------------------------
// ActionGroup Navigation
auto ptrGroupSnippetsMenuNav = std14_stl::make_unique<QActionGroup>(m_pMainWindow);
ptrGroupSnippetsMenuNav->setExclusive(false);
// Action Previous
auto ptrActionSnippetsMenuPrev = std14_stl::make_unique<QAction>(QObject::tr("Previous"),
m_pMainWindow);
ptrActionSnippetsMenuPrev->setActionGroup(ptrGroupSnippetsMenuNav.get());
const auto shortcutSnippetsMenuPrev = hasShortcutForID(actions::MENU_SNIPPETS_PREV)
? m_savedShortcuts.value(actions::MENU_SNIPPETS_PREV)
: DEFAULT_SHORTCUT_SNIPPETS_MENU_PREV;
ptrActionSnippetsMenuPrev->setShortcut(shortcutSnippetsMenuPrev);
saveShortcut(actions::MENU_SNIPPETS_PREV, shortcutSnippetsMenuPrev);
ptrActionSnippetsMenuPrev->setIcon(QIcon{":/icons/main/prev"});
m_actions.insert(std::make_pair(actions::MENU_SNIPPETS_PREV,
std::move(ptrActionSnippetsMenuPrev)));
// Action Next
auto ptrActionSnippetsMenuNext = std14_stl::make_unique<QAction>(QObject::tr("Next"),
m_pMainWindow);
ptrActionSnippetsMenuNext->setActionGroup(ptrGroupSnippetsMenuNav.get());
const auto shortcutSnippetsMenuNext = hasShortcutForID(actions::MENU_SNIPPETS_NEXT)
? m_savedShortcuts.value(actions::MENU_SNIPPETS_NEXT)
: DEFAULT_SHORTCUT_SNIPPETS_MENU_NEXT;
ptrActionSnippetsMenuNext->setShortcut(shortcutSnippetsMenuNext);
saveShortcut(actions::MENU_SNIPPETS_NEXT, shortcutSnippetsMenuNext);
ptrActionSnippetsMenuNext->setIcon(QIcon{":/icons/main/next"});
m_actions.insert(std::make_pair(actions::MENU_SNIPPETS_NEXT,
std::move(ptrActionSnippetsMenuNext)));
m_actionGroups.insert(std::make_pair(actions::groups::MENU_SNIPPETS_NAVIGATING,
std::move(ptrGroupSnippetsMenuNav)));
}
QButtonGroup* UiGenerator::createButtonGroup(scheme::Para ¶, QWidget* parent, bool isExclusive) {
auto buttonGroupPtr = new QButtonGroup(parent);
buttonGroupPtr->setExclusive(isExclusive);
mButtonGroupMap.insert(¶, buttonGroupPtr);
return buttonGroupPtr;
}
LocalLibraryView::LocalLibraryView(QWidget * parent)
: QWidget(parent)
{
auto mainVLayout = new QVBoxLayout();
mainVLayout->setSpacing(0);
mainVLayout->setContentsMargins(0,0,0,0);
setLayout(mainVLayout);
auto buttonGroup = new QButtonGroup();
buttonGroup->setExclusive(true);
mainViewSwitcher = new OSViewSwitcher();
mainVLayout->addWidget(mainViewSwitcher);
QString style;
style.append("QWidget#Footer {");
style.append("border-top: 1px solid black; ");
style.append("background-color: qlineargradient(x1:0,y1:0,x2:0,y2:1,stop: 0 #B6B5B6, stop: 1 #737172); ");
style.append("}");
auto footer = new QWidget();
footer->setObjectName("Footer");
footer->setStyleSheet(style);
//footer->setFixedHeight(40);
mainVLayout->addWidget(footer);
auto footerVLayout = new QVBoxLayout();
footerVLayout->setContentsMargins(5,5,5,5);
footerVLayout->setSpacing(5);
footer->setLayout(footerVLayout);
auto footerHLayout = new QHBoxLayout();
footerHLayout->setContentsMargins(0,0,0,0);
footerHLayout->setSpacing(5);
footerVLayout->addLayout(footerHLayout);
duplicateMeasureButton = new DuplicateButton();
duplicateMeasureButton->setToolTip("Copy Selected Measure and Add to My Measures");
footerHLayout->addWidget(duplicateMeasureButton);
duplicateMeasureButton->setDisabled(true);
addMeasureButton = new AddScriptButton();
addMeasureButton->setToolTip("Create a Measure from Template and add to My Measures");
footerHLayout->addWidget(addMeasureButton);
footerHLayout->addStretch();
myMeasuresFolderButton = new MyMeasuresFolderButton();
myMeasuresFolderButton->setToolTip("Open the My Measures Directory");
footerHLayout->addWidget(myMeasuresFolderButton);
auto footerHLayout2 = new QHBoxLayout();
footerHLayout2->setContentsMargins(10,0,10,0);
footerHLayout2->setSpacing(5);
footerVLayout->addLayout(footerHLayout2);
addBCLMeasureButton = new BlueButton();
addBCLMeasureButton->setText("Find Measures on BCL");
addBCLMeasureButton->setToolTip("Connect to Online BCL to Download New Measures and Update Existing Measures to Library");
footerHLayout2->addWidget(addBCLMeasureButton);
}
void ActionManager::initFileMenuActions()
{
static const auto DEFAULT_SHORTCUT_FILE_MENU_NEW_AUTHOR = QKeySequence{Qt::CTRL + Qt::Key_N, Qt::Key_A};
static const auto DEFAULT_SHORTCUT_FILE_MENU_NEW_CATEGORY = QKeySequence{Qt::CTRL + Qt::Key_N, Qt::Key_C};
static const auto DEFAULT_SHORTCUT_FILE_MENU_NEW_PROJECT = QKeySequence{Qt::CTRL + Qt::Key_N, Qt::Key_P};
static const auto DEFAULT_SHORTCUT_FILE_MENU_NEW_SNIPPET = QKeySequence{QKeySequence::New};
static const auto DEFAULT_SHORTCUT_FILE_MENU_SAVE = QKeySequence{QKeySequence::Save};
static const auto DEFAULT_SHORTCUT_FILE_MENU_SAVE_AS = QKeySequence{QKeySequence::SaveAs};
static const auto DEFAULT_SHORTCUT_FILE_MENU_IMPORT = QKeySequence{Qt::CTRL + Qt::SHIFT + Qt::Key_I};
static const auto DEFAULT_SHORTCUT_FILE_MENU_EXPORT = QKeySequence{Qt::CTRL + Qt::SHIFT + Qt::Key_E};
static const auto DEFAULT_SHORTCUT_FILE_MENU_PRINT_PREVIEW = QKeySequence{Qt::CTRL + Qt::ALT + Qt::Key_P};
static const auto DEFAULT_SHORTCUT_FILE_MENU_PRINT = QKeySequence{QKeySequence::Print};
static const auto DEFAULT_SHORTCUT_FILE_MENU_QUIT = QKeySequence{QKeySequence::Quit};
// ActionGroup Create
auto ptrGroupFileMenuCreate = std14_stl::make_unique<QActionGroup>(m_pMainWindow);
ptrGroupFileMenuCreate->setExclusive(false);
// Action New Author
auto ptrActionFileMenuNewAuthor = std14_stl::make_unique<QAction>(QObject::tr("Author..."),
m_pMainWindow);
ptrActionFileMenuNewAuthor->setActionGroup(ptrGroupFileMenuCreate.get());
const auto shortcutFileMenuNewAuthor = hasShortcutForID(actions::MENU_FILE_NEW_AUTHOR)
? m_savedShortcuts.value(actions::MENU_FILE_NEW_AUTHOR)
: DEFAULT_SHORTCUT_FILE_MENU_NEW_AUTHOR;
ptrActionFileMenuNewAuthor->setShortcut(shortcutFileMenuNewAuthor);
saveShortcut(actions::MENU_FILE_NEW_AUTHOR, shortcutFileMenuNewAuthor);
m_actions.insert(std::make_pair(actions::MENU_FILE_NEW_AUTHOR,
std::move(ptrActionFileMenuNewAuthor)));
// Action New Category
auto ptrActionFileMenuNewCategory = std14_stl::make_unique<QAction>(QObject::tr("Category..."),
m_pMainWindow);
ptrActionFileMenuNewCategory->setActionGroup(ptrGroupFileMenuCreate.get());
const auto shortcutFileMenuNewCategory = hasShortcutForID(actions::MENU_FILE_NEW_CATEGORY)
? m_savedShortcuts.value(actions::MENU_FILE_NEW_CATEGORY)
: DEFAULT_SHORTCUT_FILE_MENU_NEW_CATEGORY;
ptrActionFileMenuNewCategory->setShortcut(shortcutFileMenuNewCategory);
saveShortcut(actions::MENU_FILE_NEW_CATEGORY, shortcutFileMenuNewCategory);
m_actions.insert(std::make_pair(actions::MENU_FILE_NEW_CATEGORY,
std::move(ptrActionFileMenuNewCategory)));
// Action New Project
auto ptrActionFileMenuNewProject = std14_stl::make_unique<QAction>(QObject::tr("Project..."),
m_pMainWindow);
ptrActionFileMenuNewProject->setActionGroup(ptrGroupFileMenuCreate.get());
const auto shortcutFileMenuNewProject = hasShortcutForID(actions::MENU_FILE_NEW_PROJECT)
? m_savedShortcuts.value(actions::MENU_FILE_NEW_PROJECT)
: DEFAULT_SHORTCUT_FILE_MENU_NEW_PROJECT;
ptrActionFileMenuNewProject->setShortcut(shortcutFileMenuNewProject);
saveShortcut(actions::MENU_FILE_NEW_PROJECT, shortcutFileMenuNewProject);
m_actions.insert(std::make_pair(actions::MENU_FILE_NEW_PROJECT,
std::move(ptrActionFileMenuNewProject)));
// Action New Snippet
auto ptrActionFileMenuNewSnippet = std14_stl::make_unique<QAction>(QObject::tr("Snippet..."),
m_pMainWindow);
ptrActionFileMenuNewSnippet->setActionGroup(ptrGroupFileMenuCreate.get());
const auto shortcutFileMenuNewSnippet = hasShortcutForID(actions::MENU_FILE_NEW_SNIPPET)
? m_savedShortcuts.value(actions::MENU_FILE_NEW_SNIPPET)
: DEFAULT_SHORTCUT_FILE_MENU_NEW_SNIPPET;
ptrActionFileMenuNewSnippet->setShortcut(shortcutFileMenuNewSnippet);
saveShortcut(actions::MENU_FILE_NEW_SNIPPET, shortcutFileMenuNewSnippet);
m_actions.insert(std::make_pair(actions::MENU_FILE_NEW_SNIPPET,
std::move(ptrActionFileMenuNewSnippet)));
m_actionGroups.insert(std::make_pair(actions::groups::MENU_FILE_CREATE,
std::move(ptrGroupFileMenuCreate)));
// -----------------------------------------------------------
// ActionGroup Saving
auto ptrGroupFileMenuSaving = std14_stl::make_unique<QActionGroup>(m_pMainWindow);
ptrGroupFileMenuSaving->setExclusive(false);
// Action Save
auto ptrActionFileMenuSave = std14_stl::make_unique<QAction>(QObject::tr("Save"),
m_pMainWindow);
ptrActionFileMenuSave->setActionGroup(ptrGroupFileMenuSaving.get());
const auto shortcutFileMenuSave = hasShortcutForID(actions::MENU_FILE_SAVE)
? m_savedShortcuts.value(actions::MENU_FILE_SAVE)
: DEFAULT_SHORTCUT_FILE_MENU_SAVE;
ptrActionFileMenuSave->setShortcut(shortcutFileMenuSave);
saveShortcut(actions::MENU_FILE_SAVE, shortcutFileMenuSave);
ptrActionFileMenuSave->setIcon(QIcon{":/icons/main/save"});
m_actions.insert(std::make_pair(actions::MENU_FILE_SAVE,
std::move(ptrActionFileMenuSave)));
// Action Save As
auto ptrActionFileMenuSaveAs = std14_stl::make_unique<QAction>(QObject::tr("Save As..."),
m_pMainWindow);
const auto shortcutFileMenuSaveAs = hasShortcutForID(actions::MENU_FILE_SAVE_AS)
? m_savedShortcuts.value(actions::MENU_FILE_SAVE_AS)
: DEFAULT_SHORTCUT_FILE_MENU_SAVE_AS;
ptrActionFileMenuSaveAs->setShortcut(shortcutFileMenuSaveAs);
saveShortcut(actions::MENU_FILE_SAVE_AS, shortcutFileMenuSaveAs);
ptrActionFileMenuSaveAs->setIcon(QIcon{":/icons/main/saveas"});
ptrActionFileMenuSaveAs->setActionGroup(ptrGroupFileMenuSaving.get());
m_actions.insert(std::make_pair(actions::MENU_FILE_SAVE_AS,
std::move(ptrActionFileMenuSaveAs)));
m_actionGroups.insert(std::make_pair(actions::groups::MENU_FILE_SAVING,
std::move(ptrGroupFileMenuSaving)));
// -----------------------------------------------------------
// ActionGroup Import/Export
auto ptrGroupFileMenuImpExp = std14_stl::make_unique<QActionGroup>(m_pMainWindow);
ptrGroupFileMenuImpExp->setExclusive(false);
// Action Import
auto ptrActionFileMenuImport = std14_stl::make_unique<QAction>(QObject::tr("Import..."),
m_pMainWindow);
ptrActionFileMenuImport->setActionGroup(ptrGroupFileMenuImpExp.get());
const auto shortcutFileMenuImport = hasShortcutForID(actions::MENU_FILE_IMPORT)
? m_savedShortcuts.value(actions::MENU_FILE_IMPORT)
: DEFAULT_SHORTCUT_FILE_MENU_IMPORT;
ptrActionFileMenuImport->setShortcut(shortcutFileMenuImport);
saveShortcut(actions::MENU_FILE_IMPORT, shortcutFileMenuImport);
ptrActionFileMenuImport->setIcon(QIcon{":/icons/main/import"});
m_actions.insert(std::make_pair(actions::MENU_FILE_IMPORT,
std::move(ptrActionFileMenuImport)));
// Action Export
auto ptrActionFileMenuExport = std14_stl::make_unique<QAction>(QObject::tr("Export..."),
m_pMainWindow);
ptrActionFileMenuExport->setActionGroup(ptrGroupFileMenuImpExp.get());
const auto shortcutFileMenuExport = hasShortcutForID(actions::MENU_FILE_EXPORT)
? m_savedShortcuts.value(actions::MENU_FILE_EXPORT)
: DEFAULT_SHORTCUT_FILE_MENU_EXPORT;
ptrActionFileMenuExport->setShortcut(shortcutFileMenuExport);
saveShortcut(actions::MENU_FILE_EXPORT, shortcutFileMenuExport);
ptrActionFileMenuExport->setIcon(QIcon{":/icons/main/export"});
m_actions.insert(std::make_pair(actions::MENU_FILE_EXPORT,
std::move(ptrActionFileMenuExport)));
m_actionGroups.insert(std::make_pair(actions::groups::MENU_FILE_IMPORT_EXPORT,
std::move(ptrGroupFileMenuImpExp)));
// -----------------------------------------------------------
// ActionGroup Printing
auto ptrGroupFileMenuPrinting = std14_stl::make_unique<QActionGroup>(m_pMainWindow);
ptrGroupFileMenuPrinting->setExclusive(false);
// Action Print Preview
auto ptrActionFileMenuPrintPreview = std14_stl::make_unique<QAction>(QObject::tr("Print Preview..."),
m_pMainWindow);
ptrActionFileMenuPrintPreview->setActionGroup(ptrGroupFileMenuPrinting.get());
const auto shortcutFileMenuPrintPreview = hasShortcutForID(actions::MENU_FILE_PRINT_PREVIEW)
? m_savedShortcuts.value(actions::MENU_FILE_PRINT_PREVIEW)
: DEFAULT_SHORTCUT_FILE_MENU_PRINT_PREVIEW;
ptrActionFileMenuPrintPreview->setShortcut(shortcutFileMenuPrintPreview);
saveShortcut(actions::MENU_FILE_PRINT_PREVIEW, shortcutFileMenuPrintPreview);
ptrActionFileMenuPrintPreview->setIcon(QIcon{":/icons/main/printpreview"});
m_actions.insert(std::make_pair(actions::MENU_FILE_PRINT_PREVIEW,
std::move(ptrActionFileMenuPrintPreview)));
// Action Print
auto ptrActionFileMenuPrint = std14_stl::make_unique<QAction>(QObject::tr("Print..."),
m_pMainWindow);
ptrActionFileMenuPrint->setActionGroup(ptrGroupFileMenuPrinting.get());
const auto shortcutFileMenuPrint = hasShortcutForID(actions::MENU_FILE_PRINT)
? m_savedShortcuts.value(actions::MENU_FILE_PRINT)
: DEFAULT_SHORTCUT_FILE_MENU_PRINT;
ptrActionFileMenuPrint->setShortcut(shortcutFileMenuPrint);
saveShortcut(actions::MENU_FILE_PRINT, shortcutFileMenuPrint);
ptrActionFileMenuPrint->setIcon(QIcon{":/icons/main/print"});
m_actions.insert(std::make_pair(actions::MENU_FILE_PRINT,
std::move(ptrActionFileMenuPrint)));
m_actionGroups.insert(std::make_pair(actions::groups::MENU_FILE_PRINTING,
std::move(ptrGroupFileMenuPrinting)));
// -----------------------------------------------------------
// Action Quit
auto ptrActionFileMenuQuit = std14_stl::make_unique<QAction>(QObject::tr("Quit"),
m_pMainWindow);
const auto shortcutFileMenuQuit = hasShortcutForID(actions::MENU_FILE_QUIT)
? m_savedShortcuts.value(actions::MENU_FILE_QUIT)
: DEFAULT_SHORTCUT_FILE_MENU_QUIT;
ptrActionFileMenuQuit->setShortcut(shortcutFileMenuQuit);
saveShortcut(actions::MENU_FILE_QUIT, shortcutFileMenuQuit);
ptrActionFileMenuQuit->setIcon(QIcon{":/icons/main/exit"});
m_actions.insert(std::make_pair(actions::MENU_FILE_QUIT,
std::move(ptrActionFileMenuQuit)));
}
void VCButton::createContents(QPtrList <QString> &list)
{
QRect rect(30, 30, 30, 30);
for (QString* s = list.next(); s != NULL; s = list.next())
{
if (*s == QString("Entry"))
{
s = list.prev();
break;
}
else if (*s == QString("Name"))
{
setCaption(*(list.next()));
}
else if (*s == QString("Parent"))
{
VCFrame* parent =
_app->virtualConsole()->getFrame(list.next()->toInt());
if (parent != NULL)
{
reparent((QWidget*)parent, 0, QPoint(0, 0), true);
}
// each Button should set
if (parent->buttonBehaviour() == VCFrame::Exclusive)
{
setExclusive(true);
}
else
{
setExclusive(false);
}
}
else if (*s == QString("X"))
{
rect.setX(list.next()->toInt());
}
else if (*s == QString("Y"))
{
rect.setY(list.next()->toInt());
}
else if (*s == QString("Width"))
{
rect.setWidth(list.next()->toInt());
}
else if (*s == QString("Height"))
{
rect.setHeight(list.next()->toInt());
}
else if (*s == QString("Textcolor"))
{
QColor qc;
qc.setRgb(list.next()->toUInt());
setPaletteForegroundColor(qc);
}
else if (*s == QString("Backgroundcolor"))
{
QColor qc;
qc.setRgb(list.next()->toUInt());
setPaletteBackgroundColor(qc);
}
else if (*s == QString("Color"))
{
// Backwards compatibility for button background color
QString t = *(list.next());
int i = t.find(QString(","));
int r = t.left(i).toInt();
int j = t.find(QString(","), i + 1);
int g = t.mid(i+1, j-i-1).toInt();
int b = t.mid(j+1).toInt();
QColor qc(r, g, b);
setPaletteBackgroundColor(qc);
}
else if (*s == QString("Pixmap"))
{
QString t;
t = *(list.next());
QPixmap pm(t);
if (pm.isNull() == false)
{
setIconText(t);
setPaletteBackgroundPixmap(pm);
}
}
else if (*s == QString("Font"))
{
QFont f = font();
QString q = *(list.next());
f.fromString(q);
setFont(f);
}
else if (*s == QString("Function"))
{
attachFunction(list.next()->toInt());
}
else if (*s == QString("BindKey"))
{
assert(m_keyBind);
QString t = *(list.next());
m_keyBind->setKey(t.toInt());
}
else if (*s == QString("BindMod"))
{
assert(m_keyBind);
QString t = *(list.next());
m_keyBind->setMod(t.toInt());
}
else if (*s == QString("BindPress"))
{
assert(m_keyBind);
QString t = *(list.next());
m_keyBind->setPressAction((KeyBind::PressAction) t.toInt());
}
else if (*s == QString("BindRelease"))
{
assert(m_keyBind);
QString t = *(list.next());
m_keyBind->setReleaseAction((KeyBind::ReleaseAction) t.toInt());
}
else
{
// Unknown keyword, ignore
*list.next();
}
}
setGeometry(rect);
}
