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); }