QMenu* MuseScore::genCreateMenu(QWidget* parent)
{
QMenu* popup = new QMenu(tr("&Create"), parent);
popup->setObjectName("Create");
popup->addAction(getAction("instruments"));
QMenu* measures = popup->addMenu(tr("&Measures"));
measures->addAction(getAction("insert-measure"));
measures->addAction(getAction("insert-measures"));
measures->addSeparator();
measures->addAction(getAction("append-measure"));
measures->addAction(getAction("append-measures"));
QMenu* frames = popup->addMenu(tr("&Frames"));
frames->addAction(getAction("insert-hbox"));
frames->addAction(getAction("insert-vbox"));
frames->addAction(getAction("insert-textframe"));
if(enableExperimental)
frames->addAction(getAction("insert-fretframe"));
frames->addSeparator();
frames->addAction(getAction("append-hbox"));
frames->addAction(getAction("append-vbox"));
frames->addAction(getAction("append-textframe"));
QMenu* text = popup->addMenu(tr("&Text"));
text->addAction(getAction("title-text"));
text->addAction(getAction("subtitle-text"));
text->addAction(getAction("composer-text"));
text->addAction(getAction("poet-text"));
text->addSeparator();
text->addAction(getAction("system-text"));
text->addAction(getAction("staff-text"));
text->addAction(getAction("chord-text"));
text->addAction(getAction("rehearsalmark-text"));
text->addSeparator();
text->addAction(getAction("lyrics"));
text->addAction(getAction("tempo"));
popup->addSeparator();
popup->addAction(getAction("add-slur"));
popup->addAction(getAction("add-hairpin"));
popup->addAction(getAction("add-hairpin-reverse"));
popup->addAction(getAction("add-noteline"));
return popup;
}
/*!
Creates a new menu with the given \a id.
Returns a new ActionContainer that you can use to get the QMenu instance
or to add menu items to the menu. The ActionManager owns
the returned ActionContainer.
Add your menu to some other menu or a menu bar via the
ActionManager::actionContainer and ActionContainer::addMenu functions.
*/
ActionContainer *ActionManager::createMenu(Id id)
{
const ActionManagerPrivate::IdContainerMap::const_iterator it = d->m_idContainerMap.constFind(id);
if (it != d->m_idContainerMap.constEnd())
return it.value();
QMenu *m = new QMenu(ICore::mainWindow());
m->setObjectName(QLatin1String(id.name()));
MenuActionContainer *mc = new MenuActionContainer(id);
mc->setMenu(m);
d->m_idContainerMap.insert(id, mc);
connect(mc, SIGNAL(destroyed()), d, SLOT(containerDestroyed()));
return mc;
}
ActionContainer *ActionManagerPrivate::createMenu(const QString &id)
{
const int uid = UniqueIDManager::instance()->uniqueIdentifier(id);
const IdContainerMap::const_iterator it = m_idContainerMap.constFind(uid);
if (it != m_idContainerMap.constEnd()) {
return it.value();
}
QMenu *m = new QMenu(m_mainWnd);
m->setObjectName(id);
MenuActionContainer *mc = new MenuActionContainer(uid);
mc->setMenu(m);
m_idContainerMap.insert(uid, mc);
return mc;
}
QMenu* ModuleExtEdit::initModuleMenu()
{
QList<QAction*> list;
QStringList appList = _extEdit->listAppNames();
for (int i = 0; i < appList.count(); ++i)
{
QAction* action = new QAction(0);
action->setText(appList.at(i));
QObject::connect(action, SIGNAL(triggered(bool)), _extEdit, SLOT(runExternalEditor()));
list.append(action);
_extEdit->addAppAction(action);
}
QMenu *menu = new QMenu(QObject::tr("Edit in..."), 0);
menu->addActions(list);
menu->setObjectName("menuExtedit");
return menu;
}
QMenu *ActionManager::insertMenu(const QString &id, const QString &title, const QString &idBefore)
{
QMenu *menu = m_idMenuMap.value(id);
if (menu) {
return menu;
}
menu = new QMenu(title,m_liteApp->mainWindow());
menu->setObjectName(id);
QMenu *m = 0;
if (!idBefore.isEmpty()) {
m = m_idMenuMap.value(idBefore);
}
if (m) {
m_liteApp->mainWindow()->menuBar()->insertMenu(m->menuAction(),menu);
} else {
m_liteApp->mainWindow()->menuBar()->addAction(menu->menuAction());
}
m_idMenuMap.insert(id,menu);
return menu;
}
//-----------------------------------------------------------------------------
void swftParaViewMenuBuilders::buildEditMenu(QMenu& menu)
{
QString objectName = menu.objectName();
Ui::pqEditMenuBuilder ui;
ui.setupUi(&menu);
// since the UI file tends to change the name of the menu.
menu.setObjectName(objectName);
new pqUndoRedoReaction(ui.actionEditUndo, true);
new pqUndoRedoReaction(ui.actionEditRedo, false);
new pqCameraUndoRedoReaction(ui.actionEditCameraUndo, true);
new pqCameraUndoRedoReaction(ui.actionEditCameraRedo, false);
new pqChangePipelineInputReaction(ui.actionChangeInput);
new pqIgnoreSourceTimeReaction(ui.actionIgnoreTime);
new pqDeleteReaction(ui.actionDelete);
new pqDeleteReaction(ui.actionDelete_All, true);
new pqCopyReaction(ui.actionCopy);
new pqCopyReaction(ui.actionPaste, true);
new pqApplicationSettingsReaction(ui.actionEditSettings);
new pqViewSettingsReaction(ui.actionEditViewSettings);
new pqDataQueryReaction(ui.actionQuery);
}
QMenu* NaviCubeImplementation::createNaviCubeMenu() {
QMenu* menu = new QMenu(getMainWindow());
menu->setObjectName(str("NaviCube_Menu"));
CommandManager &rcCmdMgr = Application::Instance->commandManager();
vector<Command*> commands;
commands.push_back( new ViewOrthographicCmd());
commands.push_back( new ViewPerspectiveCmd());
commands.push_back( 0);
commands.push_back( new ViewZoomToFitCmd());
//commands.push_back( 0);
//commands.push_back( new ViewNormalToSketchPlaneCmd());
for (vector<Command*>::iterator i=commands.begin(); i!=commands.end(); i++) {
if (*i) {
rcCmdMgr.addCommand(*i);
(*i)->addTo(menu);
}
else
menu->addSeparator();
}
return menu;
}
/**
\param bges
\return
**/
int entryPoint ( BfBulmaFact *bges )
{
BL_FUNC_DEBUG
g_pluginbf_bulmatpv = bges;
/// Inicializa el sistema de traducciones 'gettext'.
setlocale ( LC_ALL, "" );
blBindTextDomain ( "pluginbf_bulmatpv", g_confpr->value( CONF_DIR_TRADUCCION ).toLatin1().constData() );
/// Miramos si existe un menu Ventas
QMenu *pPluginMenu = NULL;
pPluginMenu = bges->menuBar() ->findChild<QMenu *> ( "menuVentas" );
/// Creamos el menú.
if ( !pPluginMenu ) {
QMenu *pPluginVentas = NULL;
pPluginVentas = bges->menuBar() ->findChild<QMenu *> ( "menuMaestro" );
pPluginMenu = new QMenu ( _("&Ventas"), bges->menuBar() );
pPluginMenu->setObjectName ( QString::fromUtf8 ( "menuVentas" ) );
bges->menuBar()->insertMenu ( pPluginVentas->menuAction(), pPluginMenu );
} // end if
/// Creamos el menú.
BlAction *accionA = new BlAction ( _("&Cuadres de caja"), 0 );
accionA->setStatusTip ( _("Listado de cuadres de caja") );
accionA->setWhatsThis ( _("Listado de cuadres de caja") );
accionA->setObjectName("mui_actionCuadresCaja");
/// Añadimos la nueva opción al menú principal del programa.
pPluginMenu->addSeparator();
pPluginMenu->addAction ( accionA );
return 0;
}
void QDesignerMenuBar::leaveEditMode(LeaveEditMode mode)
{
m_editor->releaseKeyboard();
if (mode == Default)
return;
if (m_editor->text().isEmpty())
return;
QAction *action = 0;
QDesignerFormWindowInterface *fw = formWindow();
Q_ASSERT(fw);
if (m_currentIndex >= 0 && m_currentIndex < realActionCount()) {
action = safeActionAt(m_currentIndex);
fw->beginCommand(QApplication::translate("Command", "Change Title"));
} else {
fw->beginCommand(QApplication::translate("Command", "Insert Menu"));
const QString niceObjectName = ActionEditor::actionTextToName(m_editor->text(), QStringLiteral("menu"));
QMenu *menu = qobject_cast<QMenu*>(fw->core()->widgetFactory()->createWidget(QStringLiteral("QMenu"), this));
fw->core()->widgetFactory()->initialize(menu);
menu->setObjectName(niceObjectName);
menu->setTitle(tr("Menu"));
fw->ensureUniqueObjectName(menu);
action = menu->menuAction();
AddMenuActionCommand *cmd = new AddMenuActionCommand(fw);
cmd->init(action, m_addMenu, this, this);
fw->commandHistory()->push(cmd);
}
SetPropertyCommand *cmd = new SetPropertyCommand(fw);
cmd->init(action, QStringLiteral("text"), m_editor->text());
fw->commandHistory()->push(cmd);
fw->endCommand();
}
void pdp::MainWindow::setupUi() {
// Add back button
QPushButton* back = new QPushButton(QIcon(":/common/res/common/back.png"), QApplication::translate("MainWindow", "Zur\303\274ck", 0, QApplication::UnicodeUTF8));
ui_main.tabWidget->setCornerWidget(back, Qt::TopRightCorner);
QObject::connect(back, SIGNAL(clicked()), this, SLOT(onBack()));
// Add the "start" tab.
new pdp::Home(this->ui_main.tabWidget, this);
// Creates progressDialog
m_progressDialog = new QProgressDialog("", QString(), 0, 100, this);
m_progressDialog->setMinimumDuration(0);
//m_progressDialog->setWindowModality(Qt::WindowModal);
// Correction of automatic segmentation via 3d interactive segmentation
m_NumberOfInstancesOfThreeDEditing = 0;
QMenu *menuWerkzeug;
menuWerkzeug = new QMenu(ui_main.menubar);
menuWerkzeug->setObjectName(QString::fromUtf8("menuWerkzeug"));
menuWerkzeug->setTitle(QApplication::translate("MainWindow", "Werkzeug", 0, QApplication::UnicodeUTF8));
ui_main.menubar->addMenu(menuWerkzeug);
QAction *actionThreeDEditing = new QAction(this);
actionThreeDEditing->setObjectName(QString::fromUtf8("actionThreeDEditing"));
actionThreeDEditing->setIconText("3DEditing");
QIcon icn_menu;
icn_menu.addFile(":/threeDEditing/res/threeDEditing/Rubber-32.png");
actionThreeDEditing->setIcon(icn_menu);
menuWerkzeug->addAction(actionThreeDEditing);
QObject::connect(actionThreeDEditing, SIGNAL(triggered()), this, SLOT(CreateThreeDEditing()));
// AutoRun
if(AUTO_IMPORT == 1)
CreateThreeDEditing();
}
// ??? Break this stuff off into an InstrumentPopup class. This class is too
// big.
void
TrackButtons::populateInstrumentPopup(Instrument *thisTrackInstr, QMenu* instrumentPopup)
{
// pixmaps for icons to show connection states as variously colored boxes
// ??? Factor out the icon-related stuff to make this routine clearer.
// getIcon(Instrument *) would be ideal, but might not be easy.
// getIcon(Device *) would also be needed.
static QPixmap connectedPixmap, unconnectedPixmap,
connectedUsedPixmap, unconnectedUsedPixmap,
connectedSelectedPixmap, unconnectedSelectedPixmap;
static bool havePixmaps = false;
if (!havePixmaps) {
IconLoader il;
connectedPixmap = il.loadPixmap("connected");
connectedUsedPixmap = il.loadPixmap("connected-used");
connectedSelectedPixmap = il.loadPixmap("connected-selected");
unconnectedPixmap = il.loadPixmap("unconnected");
unconnectedUsedPixmap = il.loadPixmap("unconnected-used");
unconnectedSelectedPixmap = il.loadPixmap("unconnected-selected");
havePixmaps = true;
}
Composition &comp = m_doc->getComposition();
// clear the popup
instrumentPopup->clear();
QMenu *currentSubMenu = 0;
// position index
int count = 0;
int currentDevId = -1;
// Get the list
Studio &studio = m_doc->getStudio();
InstrumentList list = studio.getPresentationInstruments();
// For each instrument
for (InstrumentList::iterator it = list.begin(); it != list.end(); ++it) {
if (!(*it)) continue; // sanity check
// get the Localized instrument name, with the string hackery performed
// in Instrument
QString iname((*it)->getLocalizedPresentationName());
// translate the program name
//
// Note we are converting the string from std to Q back to std then to
// C. This is obviously ridiculous, but the fact that we have programName
// here at all makes me think it exists as some kind of necessary hack
// to coax tr() into behaving nicely. I decided to change it as little
// as possible to get it to compile, and not refactor this down to the
// simplest way to call tr() on a C string.
QString programName(strtoqstr((*it)->getProgramName()));
programName = QObject::tr(programName.toStdString().c_str());
Device *device = (*it)->getDevice();
DeviceId devId = device->getId();
bool connectedIcon = false;
// Determine the proper program name and whether it is connected
if ((*it)->getType() == Instrument::SoftSynth) {
programName = "";
AudioPluginInstance *plugin =
(*it)->getPlugin(Instrument::SYNTH_PLUGIN_POSITION);
if (plugin) {
// we don't translate any plugin program names or other texts
programName = strtoqstr(plugin->getDisplayName());
connectedIcon = (plugin->getIdentifier() != "");
}
} else if ((*it)->getType() == Instrument::Audio) {
connectedIcon = true;
} else {
QString conn = RosegardenSequencer::getInstance()->
getConnection(devId);
connectedIcon = (conn != "");
}
// These two are for selecting the correct icon to display.
bool instrUsedByMe = false;
bool instrUsedByAnyone = false;
if (thisTrackInstr && thisTrackInstr->getId() == (*it)->getId()) {
instrUsedByMe = true;
instrUsedByAnyone = true;
}
// If we have switched to a new device, we'll create a new submenu
if (devId != (DeviceId)(currentDevId)) {
currentDevId = int(devId);
// For selecting the correct icon to display.
bool deviceUsedByAnyone = false;
if (instrUsedByMe)
deviceUsedByAnyone = true;
else {
for (Composition::trackcontainer::iterator tit =
comp.getTracks().begin();
tit != comp.getTracks().end(); ++tit) {
if (tit->second->getInstrument() == (*it)->getId()) {
instrUsedByAnyone = true;
deviceUsedByAnyone = true;
break;
}
Instrument *instr =
studio.getInstrumentById(tit->second->getInstrument());
if (instr && (instr->getDevice()->getId() == devId)) {
deviceUsedByAnyone = true;
}
}
}
QIcon icon
(connectedIcon ?
(deviceUsedByAnyone ?
connectedUsedPixmap : connectedPixmap) :
(deviceUsedByAnyone ?
unconnectedUsedPixmap : unconnectedPixmap));
// Create a submenu for this device
QMenu *subMenu = new QMenu(instrumentPopup);
subMenu->setMouseTracking(true);
subMenu->setIcon(icon);
// Not needed so long as AA_DontShowIconsInMenus is false.
//subMenu->menuAction()->setIconVisibleInMenu(true);
// Menu title
QString deviceName = QObject::tr(device->getName().c_str());
subMenu->setTitle(deviceName);
// QObject name
subMenu->setObjectName(deviceName);
// Add the submenu to the popup menu
instrumentPopup->addMenu(subMenu);
// Connect the submenu to slotInstrumentSelected()
connect(subMenu, SIGNAL(triggered(QAction*)),
this, SLOT(slotInstrumentSelected(QAction*)));
currentSubMenu = subMenu;
} else if (!instrUsedByMe) {
//-------------------------------------------------------------------------
QMenu * QGuidoItemContainer::buildContextMenu()
{
QMenu * menu = QLanguageItem::buildContextMenu();
QAction * exportAct = new QAction( "Export" , this );
connect( exportAct , SIGNAL( triggered() ) , this , SIGNAL( exportItem() ) );
menu->addAction( exportAct );
QMenu * layoutMenu = menu->addMenu( CONTEXT_MENU_LAYOUT );
layoutMenu->setObjectName( CONTEXT_MENU_LAYOUT );
//Layout actions :Proportional layout
QString layoutProportionalMsg = QString("Switch ") + ( mIsProportionalOn ? "OFF" : "ON" ) + " Proportionnal layout";
QAction * layoutProportionalSwitch = new QAction( layoutProportionalMsg , layoutMenu );
connect( layoutProportionalSwitch , SIGNAL(triggered()) , this , SLOT(switchProportional()) );
layoutMenu->addAction(layoutProportionalSwitch);
//Layout actions : Optimal page fill
QString layoutOptimalPageFillMsg = QString("Switch ") + ( mIsOptimalPageFillOn ? "OFF" : "ON" ) + " Optimal page fill";
QAction * layoutOptimalPageFillSwitch = new QAction( layoutOptimalPageFillMsg , layoutMenu );
connect( layoutOptimalPageFillSwitch , SIGNAL(triggered()) , this , SLOT(switchOptimalPageFill()) );
layoutMenu->addAction(layoutOptimalPageFillSwitch);
//Layout actions : Auto-resizePageToMusic
QString layoutResizePageMsg = QString("Switch ") + ( mGuidoItem->isResizePageToMusic() ? "OFF" : "ON" ) + " Auto Resize-Page";
QAction * layoutResizePageSwitch = new QAction( layoutResizePageMsg , layoutMenu );
connect( layoutResizePageSwitch , SIGNAL(triggered()) , this , SLOT(switchResizePage()) );
layoutMenu->addAction(layoutResizePageSwitch);
//"Change the current page" actions.
QAction * firstPage = new QAction( "First page" , this );
QAction * previousPage = new QAction( "Previous page" , this );
QAction * nextPage = new QAction( "Next page" , this );
QAction * lastPage = new QAction( "Last page" , this );
connect(firstPage , SIGNAL(triggered()) , this , SLOT(firstPage()) );
connect(previousPage , SIGNAL(triggered()) , this , SLOT(previousPage()) );
connect(nextPage , SIGNAL(triggered()) , this , SLOT(nextPage()) );
connect(lastPage , SIGNAL(triggered()) , this , SLOT(lastPage()) );
layoutMenu->addAction( newSeparator(this) );
layoutMenu->addAction(firstPage);
layoutMenu->addAction(previousPage);
layoutMenu->addAction(nextPage);
layoutMenu->addAction(lastPage);
/*
bool onceOnly = false;
for ( int i = 0 ; i < menu->actions().size() ; i++ )
{
if ( menu->actions()[i]->data().toString() == CONTEXT_MENU_LAYOUT )
{
if ( !onceOnly )
{
layoutMenu->addSeparator();
onceOnly = true;
}
// qDebug("QGuidoItemContainer::buildContextMenu() : action removed from menu and added to ");
layoutMenu->addAction( menu->actions()[i] );
menu->actions()[i]->setParent( layoutMenu );
menu->removeAction( menu->actions()[i] );
i--;
}
}
*/
return menu;
}
void QmitkExtWorkbenchWindowAdvisor::PostWindowCreate()
{
QmitkCommonWorkbenchWindowAdvisor::PostWindowCreate();
// very bad hack...
berry::IWorkbenchWindow::Pointer window =
this->GetWindowConfigurer()->GetWindow();
QMainWindow* mainWindow =
static_cast<QMainWindow*> (window->GetShell()->GetControl());
if (!windowIcon.empty())
{
mainWindow->setWindowIcon(QIcon(QString::fromStdString(windowIcon)));
}
mainWindow->setContextMenuPolicy(Qt::PreventContextMenu);
/*mainWindow->setStyleSheet("color: white;"
"background-color: #808080;"
"selection-color: #659EC7;"
"selection-background-color: #808080;"
" QMenuBar {"
"background-color: #808080; }");*/
// ==== Application menu ============================
QMenuBar* menuBar = mainWindow->menuBar();
menuBar->setContextMenuPolicy(Qt::PreventContextMenu);
QMenu* fileMenu = menuBar->addMenu("&File");
fileMenu->setObjectName("FileMenu");
QAction* fileOpenAction = new QmitkExtFileOpenAction(QIcon(":/org.mitk.gui.qt.ext/Load_48.png"), window);
fileMenu->addAction(fileOpenAction);
fileSaveProjectAction = new QmitkExtFileSaveProjectAction(window);
fileSaveProjectAction->setIcon(QIcon(":/org.mitk.gui.qt.ext/Save_48.png"));
fileMenu->addAction(fileSaveProjectAction);
closeProjectAction = new QmitkCloseProjectAction(window);
closeProjectAction->setIcon(QIcon(":/org.mitk.gui.qt.ext/Remove_48.png"));
fileMenu->addAction(closeProjectAction);
fileMenu->addSeparator();
QAction* fileExitAction = new QmitkFileExitAction(window);
fileExitAction->setObjectName("QmitkFileExitAction");
fileMenu->addAction(fileExitAction);
berry::IViewRegistry* viewRegistry =
berry::PlatformUI::GetWorkbench()->GetViewRegistry();
const std::vector<berry::IViewDescriptor::Pointer>& viewDescriptors =
viewRegistry->GetViews();
// another bad hack to get an edit/undo menu...
QMenu* editMenu = menuBar->addMenu("&Edit");
undoAction = editMenu->addAction(QIcon(":/org.mitk.gui.qt.ext/Undo_48.png"),
"&Undo",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onUndo()),
QKeySequence("CTRL+Z"));
undoAction->setToolTip("Undo the last action (not supported by all modules)");
redoAction = editMenu->addAction(QIcon(":/org.mitk.gui.qt.ext/Redo_48.png")
, "&Redo",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onRedo()),
QKeySequence("CTRL+Y"));
redoAction->setToolTip("execute the last action that was undone again (not supported by all modules)");
imageNavigatorAction = new QAction(QIcon(":/org.mitk.gui.qt.ext/Slider.png"), "&Image Navigator", NULL);
bool imageNavigatorViewFound = window->GetWorkbench()->GetViewRegistry()->Find("org.mitk.views.imagenavigator");
if (imageNavigatorViewFound)
{
QObject::connect(imageNavigatorAction, SIGNAL(triggered(bool)), QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onImageNavigator()));
imageNavigatorAction->setCheckable(true);
// add part listener for image navigator
imageNavigatorPartListener = new PartListenerForImageNavigator(imageNavigatorAction);
window->GetPartService()->AddPartListener(imageNavigatorPartListener);
berry::IViewPart::Pointer imageNavigatorView =
window->GetActivePage()->FindView("org.mitk.views.imagenavigator");
imageNavigatorAction->setChecked(false);
if (imageNavigatorView)
{
bool isImageNavigatorVisible = window->GetActivePage()->IsPartVisible(imageNavigatorView);
if (isImageNavigatorVisible)
imageNavigatorAction->setChecked(true);
}
imageNavigatorAction->setToolTip("Open image navigator for navigating through image");
}
// toolbar for showing file open, undo, redo and other main actions
QToolBar* mainActionsToolBar = new QToolBar;
mainActionsToolBar->setContextMenuPolicy(Qt::PreventContextMenu);
#ifdef __APPLE__
mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextUnderIcon );
#else
mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextBesideIcon );
#endif
mainActionsToolBar->addAction(fileOpenAction);
mainActionsToolBar->addAction(fileSaveProjectAction);
mainActionsToolBar->addAction(closeProjectAction);
mainActionsToolBar->addAction(undoAction);
mainActionsToolBar->addAction(redoAction);
if (imageNavigatorViewFound)
{
mainActionsToolBar->addAction(imageNavigatorAction);
}
mainWindow->addToolBar(mainActionsToolBar);
#ifdef __APPLE__
mainWindow->setUnifiedTitleAndToolBarOnMac(true);
#endif
// ==== Window Menu ==========================
QMenu* windowMenu = menuBar->addMenu("Window");
if (showNewWindowMenuItem)
{
windowMenu->addAction("&New Window", QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onNewWindow()));
windowMenu->addSeparator();
}
QMenu* perspMenu = windowMenu->addMenu("&Open Perspective");
QMenu* viewMenu;
if (showViewMenuItem)
{
viewMenu = windowMenu->addMenu("Show &View");
viewMenu->setObjectName("Show View");
}
windowMenu->addSeparator();
resetPerspAction = windowMenu->addAction("&Reset Perspective",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onResetPerspective()));
if(showClosePerspectiveMenuItem)
closePerspAction = windowMenu->addAction("&Close Perspective", QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onClosePerspective()));
windowMenu->addSeparator();
windowMenu->addAction("&Preferences...",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onEditPreferences()),
QKeySequence("CTRL+P"));
// fill perspective menu
berry::IPerspectiveRegistry* perspRegistry =
window->GetWorkbench()->GetPerspectiveRegistry();
QActionGroup* perspGroup = new QActionGroup(menuBar);
std::vector<berry::IPerspectiveDescriptor::Pointer> perspectives(
perspRegistry->GetPerspectives());
bool skip = false;
for (std::vector<berry::IPerspectiveDescriptor::Pointer>::iterator perspIt =
perspectives.begin(); perspIt != perspectives.end(); ++perspIt)
{
// if perspectiveExcludeList is set, it contains the id-strings of perspectives, which
// should not appear as an menu-entry in the perspective menu
if (perspectiveExcludeList.size() > 0)
{
for (unsigned int i=0; i<perspectiveExcludeList.size(); i++)
{
if (perspectiveExcludeList.at(i) == (*perspIt)->GetId())
{
skip = true;
break;
}
}
if (skip)
{
skip = false;
continue;
}
}
QAction* perspAction = new berry::QtOpenPerspectiveAction(window,
*perspIt, perspGroup);
mapPerspIdToAction.insert(std::make_pair((*perspIt)->GetId(), perspAction));
}
perspMenu->addActions(perspGroup->actions());
// sort elements (converting vector to map...)
std::vector<berry::IViewDescriptor::Pointer>::const_iterator iter;
std::map<std::string, berry::IViewDescriptor::Pointer> VDMap;
skip = false;
for (iter = viewDescriptors.begin(); iter != viewDescriptors.end(); ++iter)
{
// if viewExcludeList is set, it contains the id-strings of view, which
// should not appear as an menu-entry in the menu
if (viewExcludeList.size() > 0)
{
for (unsigned int i=0; i<viewExcludeList.size(); i++)
{
if (viewExcludeList.at(i) == (*iter)->GetId())
{
skip = true;
break;
}
}
if (skip)
{
skip = false;
continue;
}
}
if ((*iter)->GetId() == "org.blueberry.ui.internal.introview")
continue;
if ((*iter)->GetId() == "org.mitk.views.imagenavigator")
continue;
std::pair<std::string, berry::IViewDescriptor::Pointer> p(
(*iter)->GetLabel(), (*iter));
VDMap.insert(p);
}
// ==================================================
// ==== Perspective Toolbar ==================================
QToolBar* qPerspectiveToolbar = new QToolBar;
if (showPerspectiveToolbar)
{
qPerspectiveToolbar->addActions(perspGroup->actions());
mainWindow->addToolBar(qPerspectiveToolbar);
}
else
delete qPerspectiveToolbar;
// ==== View Toolbar ==================================
QToolBar* qToolbar = new QToolBar;
std::map<std::string, berry::IViewDescriptor::Pointer>::const_iterator
MapIter;
for (MapIter = VDMap.begin(); MapIter != VDMap.end(); ++MapIter)
{
berry::QtShowViewAction* viewAction = new berry::QtShowViewAction(window,
(*MapIter).second);
viewActions.push_back(viewAction);
if(showViewMenuItem)
viewMenu->addAction(viewAction);
if (showViewToolbar)
{
qToolbar->addAction(viewAction);
}
}
if (showViewToolbar)
{
mainWindow->addToolBar(qToolbar);
}
else
delete qToolbar;
QSettings settings(GetQSettingsFile(), QSettings::IniFormat);
mainWindow->restoreState(settings.value("ToolbarPosition").toByteArray());
// ====================================================
// ===== Help menu ====================================
QMenu* helpMenu = menuBar->addMenu("Help");
helpMenu->addAction("&Welcome",this, SLOT(onIntro()));
helpMenu->addAction("&Help Contents",this, SLOT(onHelp()), QKeySequence("F1"));
helpMenu->addAction("&About",this, SLOT(onAbout()));
// =====================================================
QStatusBar* qStatusBar = new QStatusBar();
//creating a QmitkStatusBar for Output on the QStatusBar and connecting it with the MainStatusBar
QmitkStatusBar *statusBar = new QmitkStatusBar(qStatusBar);
//disabling the SizeGrip in the lower right corner
statusBar->SetSizeGripEnabled(false);
QmitkProgressBar *progBar = new QmitkProgressBar();
qStatusBar->addPermanentWidget(progBar, 0);
progBar->hide();
// progBar->AddStepsToDo(2);
// progBar->Progress(1);
mainWindow->setStatusBar(qStatusBar);
QmitkMemoryUsageIndicatorView* memoryIndicator =
new QmitkMemoryUsageIndicatorView();
qStatusBar->addPermanentWidget(memoryIndicator, 0);
}
void EditorMainWindow::SetupUI(QMainWindow *MainWindow) {
setWindowIcon(*QtConfig::GetIcon("colorwheel.png"));
MainWindow->setWindowTitle("Sound Engine v0.2.3");
MainWindow->resize(1280, 720);
MainWindow->setDockOptions(QMainWindow::AnimatedDocks |
QMainWindow::AllowNestedDocks |
QMainWindow::AllowTabbedDocks);
MainWindow->setTabPosition(Qt::AllDockWidgetAreas, QTabWidget::TabPosition::North);
// ************************************************************************
// Load styling
ReloadStyleSheets();
// ************************************************************************
// File Picker
auto *picker = new FilePicker();
picker->setNameFilter("*.xml");
GUI::Set(QT_INSTACE::FILE_PICKER, (void*) picker);
// ************************************************************************
// Menu Bar
QMenuBar *menuBar = new QMenuBar(MainWindow);
menuBar->setObjectName(QStringLiteral("menuBar"));
menuBar->setGeometry(QRect(0, 0, 1051, 21));
MainWindow->setMenuBar(menuBar);
// Menu Entry
{
QMenu *menuEngine = new QMenu(menuBar);
menuEngine->setObjectName(QStringLiteral("menuEngine"));
menuEngine->setTitle("File");
menuBar->addAction(menuEngine->menuAction());
{
QAction *action = new QAction(MainWindow);
action->setText("Exit");
action->setIcon(*QtConfig::GetIcon("power.png"));
menuEngine->addAction(action);
QObject::connect(action, &QAction::triggered, this, &EditorMainWindow::close);
}
{
QAction *action = new QAction(MainWindow);
action->setText("Save As...");
action->setIcon(*QtConfig::GetIcon("memorycard.png"));
menuEngine->addAction(action);
QObject::connect(action, &QAction::triggered, this, [picker]() {
picker->OpenForSave();
});
QObject::connect(picker, &QFileDialog::fileSelected, this, [picker] (const QString & file) {
if (picker->IsSaving()) {
CSoundEditor::GetScene()->SaveSceneAs(file.toStdString().c_str());
}
});
}
}
// Menu Entry
{
QMenu *menu = new QMenu(menuBar);
menu->setTitle("Scene");
menuBar->addAction(menu->menuAction());
// Submenu buttons
QAction *action = new QAction(MainWindow);
action->setText("Clear Scene");
action->setIcon(*QtConfig::GetIcon("denied.png"));
menu->addAction(action);
QObject::connect(action, &QAction::triggered, this, []() {
CSoundEditor::GetScene()->Clear();
GUI::Get<SceneWindow>(QT_INSTACE::SCENE_EDITOR)->Clear();
});
}
// Menu Entry
{
QMenu *menu = new QMenu(menuBar);
menu->setTitle("Tools");
menuBar->addAction(menu->menuAction());
// Submenu buttons
{
QAction *action = new QAction(MainWindow);
action->setText("Reload StyleSheets");
action->setIcon(*QtConfig::GetIcon("cmyk.png"));
menu->addAction(action);
QObject::connect(action, &QAction::triggered, this, &EditorMainWindow::ReloadStyleSheets);
}
// Submenu buttons
{
QAction *action = new QAction(MainWindow);
action->setText("Reload CSound Config");
action->setIcon(*QtConfig::GetIcon("loading.png"));
menu->addAction(action);
QObject::connect(action, &QAction::triggered, this, []() {
SoundManager::Init();
});
}
}
// Menu Entry
{
QMenu *menu = new QMenu(menuBar);
menu->setTitle("CSound");
menuBar->addAction(menu->menuAction());
// Submenu buttons
QAction *action = new QAction(MainWindow);
action->setText("Options");
action->setIcon(*QtConfig::GetIcon("gear.png"));
menu->addAction(action);
appWindows["CSoundOptions"] = new CSoundOptionsWindow();
QObject::connect(action, &QAction::triggered, this, [&]() {
appWindows["CSoundOptions"]->Toggle();
});
}
// Menu Entry
{
QMenu *menu = new QMenu(menuBar);
menu->setTitle("Help");
menuBar->addAction(menu->menuAction());
// Submenu buttons
QAction *action = new QAction(MainWindow);
action->setText("About");
action->setIcon(*QtConfig::GetIcon("chat.png"));
menu->addAction(action);
appWindows["About"] = new AboutWindow();
QObject::connect(action, &QAction::triggered, this, [&]() {
appWindows["About"]->Toggle();
});
}
// ************************************************************************
// Toolbar
QToolBar *toolbar = new QToolBar();
toolbar->setWindowTitle("Toolbar");
// Play Audio
{
QToolButton *button = new QToolButton();
button->setText("Play");
button->setMaximumWidth(80);
button->setIcon(*QtConfig::GetIcon("play.png"));
button->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
QObject::connect(button, &QToolButton::clicked, this, []() {
CSoundEditor::GetScene()->Play();
});
toolbar->addWidget(button);
}
// Stop Audio
{
QToolButton *button = new QToolButton();
button->setText("Stop");
button->setMaximumWidth(80);
button->setIcon(*QtConfig::GetIcon("volume_disabled.png"));
button->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
QObject::connect(button, &QToolButton::clicked, this, []() {
CSoundEditor::GetScene()->Stop();
});
toolbar->addWidget(button);
}
// Save Scene
{
QToolButton *button = new QToolButton();
button->setText("Save Scene");
button->setIcon(*QtConfig::GetIcon("download.png"));
button->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
QObject::connect(button, &QToolButton::clicked, this, []() {
auto result = CSoundEditor::GetScene()->SaveScene();
if (!result) {
auto picker = GUI::Get<FilePicker>(QT_INSTACE::FILE_PICKER);
if (picker) {
picker->OpenForSave();
}
}
});
toolbar->addWidget(button);
}
// Load Scene
{
QToolButton *button = new QToolButton();
button->setText("Load Scene");
button->setIcon(*QtConfig::GetIcon("upload.png"));
button->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
QObject::connect(picker, &QFileDialog::fileSelected, this, [picker] (const QString & file) {
if (!picker->IsSaving())
{
CSoundEditor::GetScene()->LoadScene(file.toStdString().c_str());
GUI::Get<SceneWindow>(QT_INSTACE::SCENE_EDITOR)->Init();
}
});
QObject::connect(button, &QToolButton::clicked, this, [picker]() {
picker->OpenForLoad();
});
toolbar->addWidget(button);
}
// Headphone Test
{
QToolButton *button = new QToolButton();
button->setText("Headphone Test");
button->setIcon(*QtConfig::GetIcon("speaker.png"));
button->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
appWindows["HeadphoneTest"] = new HeadphoneTestWindow();
QObject::connect(button, &QToolButton::clicked, this, [this]() {
appWindows["HeadphoneTest"]->Toggle();
});
toolbar->addWidget(button);
}
// Moving Plane
{
QToolButton *button = new QToolButton();
button->setText("Moving Plane");
button->setIcon(*QtConfig::GetIcon("frames.png"));
button->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
toolbar->addWidget(button);
appWindows["MovingPlane"] = new MovingPlaneWindow();
QObject::connect(button, &QToolButton::clicked, this, [this]() {
appWindows["MovingPlane"]->Toggle();
});
}
// Sweeping Plane
{
QToolButton *button = new QToolButton();
button->setText("Horizontal Sweep");
button->setIcon(*QtConfig::GetIcon("half-loading.png"));
button->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
toolbar->addWidget(button);
appWindows["SweepingPlane"] = new SweepingPlaneWindow();
QObject::connect(button, &QToolButton::clicked, this, [this]() {
appWindows["SweepingPlane"]->Toggle();
});
}
// Expanding Sphere
{
QToolButton *button = new QToolButton();
button->setText("Expanding Sphere");
button->setIcon(*QtConfig::GetIcon("target.png"));
button->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
appWindows["ExpandingPlane"] = new ExpandingSphereWindow();
QObject::connect(button, &QToolButton::clicked, this, [this]() {
appWindows["ExpandingPlane"]->Toggle();
});
toolbar->addWidget(button);
}
// Padding Scene
{
QWidget *empty = new QWidget();
empty->setObjectName("ToolWiteSpace");
toolbar->addWidget(empty);
}
// Sound Output Mode
{
dropdown = new QComboBox();
dropdown->setMinimumWidth(60);
QStyledItemDelegate* itemDelegate = new QStyledItemDelegate();
dropdown->setItemDelegate(itemDelegate);
dropdown->addItem("None", QVariant(-1));
dropdown->addItem("Mono", QVariant(0));
dropdown->addItem("HRTF2", QVariant(1));
dropdown->addItem("Stereo", QVariant(2));
dropdown->addItem("ind-HRTF", QVariant(4));
dropdown->addItem("PAN2", QVariant(8));
dropdown->addItem("Quad-HRTF", QVariant(16));
dropdown->addItem("Multi-8", QVariant(32));
dropdown->addItem("Quad-Stereo", QVariant(64));
// Default is HRTF
dropdown->setCurrentIndex(2);
SoundManager::SetGlobalOutputModelIndex(1);
// Add widget
auto widget = new CustomWidget(QBoxLayout::LeftToRight);
widget->setObjectName("GlobalOutputDropdown");
auto label = new QLabel("Global output");
widget->AddWidget(label);
widget->AddWidget(dropdown);
toolbar->addWidget(widget);
void (QComboBox::* indexChangedSignal)(int index) = &QComboBox::currentIndexChanged;
QObject::connect(dropdown, indexChangedSignal, this, [&](int index) {
if (index == 0) {
SoundManager::SetGlobalOutputModelIndex(1024);
CSoundEditor::GetScene()->SetOutputModel("none");
return;
} else if (SoundManager::GetGlobalOutputModelIndex() == 1024) {
CSoundEditor::GetScene()->SetOutputModel("global-output");
}
auto data = dropdown->currentData().toUInt();
SoundManager::SetGlobalOutputModelIndex(data);
});
}
// Attach toobar to the main window
MainWindow->addToolBar(toolbar);
// ************************************************************************
// Status Bar
QStatusBar *statusBar = new QStatusBar(MainWindow);
statusBar->setObjectName(QStringLiteral("statusBar"));
MainWindow->setStatusBar(statusBar);
//QMetaObject::connectSlotsByName(MainWindow);
// ************************************************************************
// Central Area
QWidget *centeralWidget = new QWidget();
centeralWidget->setFixedWidth(0);
MainWindow->setCentralWidget(centeralWidget);
// ************************************************************************
// Attach windows
dockWindows["TextPreview"] = new TextPreviewWindow();
dockWindows["CodeEditor"] = new CodeEditorWindow();
dockWindows["ComponentList"] = new ComponentList();
dockWindows["InstrumentList"] = new InstrumentList();
dockWindows["ScoreList"] = new ScoreList();
dockWindows["ScoreEditor"] = new ScoreEditor();
dockWindows["InstrumentEditor"] = new InstrumentEditor();
dockWindows["ComponentEditor"] = new ComponentEditor();
dockWindows["SceneWindow"] = new SceneWindow();
dockWindows["GameWindow"] = new GameWindow();
dockWindows["ObjectProperty"] = new SceneObjectProperties();
dockWindows["CameraProperty"] = new CameraPropertyEditor();
dockWindows["CSoundControl"] = new CSoundControlWindow();
//// Left Dock
MainWindow->addDockWidget(Qt::DockWidgetArea::LeftDockWidgetArea, dockWindows["SceneWindow"], Qt::Orientation::Vertical);
MainWindow->addDockWidget(Qt::DockWidgetArea::LeftDockWidgetArea, dockWindows["ScoreEditor"], Qt::Orientation::Horizontal);
MainWindow->addDockWidget(Qt::DockWidgetArea::LeftDockWidgetArea, dockWindows["InstrumentEditor"], Qt::Orientation::Horizontal);
MainWindow->addDockWidget(Qt::DockWidgetArea::LeftDockWidgetArea, dockWindows["ComponentEditor"], Qt::Orientation::Vertical);
MainWindow->tabifyDockWidget(dockWindows["ComponentEditor"], dockWindows["ObjectProperty"]);
MainWindow->tabifyDockWidget(dockWindows["ComponentEditor"], dockWindows["CameraProperty"]);
MainWindow->tabifyDockWidget(dockWindows["ComponentEditor"], dockWindows["CSoundControl"]);
MainWindow->addDockWidget(Qt::DockWidgetArea::LeftDockWidgetArea, dockWindows["TextPreview"], Qt::Orientation::Horizontal);
MainWindow->tabifyDockWidget(dockWindows["TextPreview"], dockWindows["CodeEditor"]);
MainWindow->tabifyDockWidget(dockWindows["TextPreview"], dockWindows["GameWindow"]);
dockWindows["GameWindow"]->setFloating(true);
dockWindows["GameWindow"]->setFloating(false);
dockWindows["GameWindow"]->raise();
// Right Dock
MainWindow->addDockWidget(Qt::DockWidgetArea::RightDockWidgetArea, dockWindows["ComponentList"], Qt::Orientation::Vertical);
MainWindow->addDockWidget(Qt::DockWidgetArea::RightDockWidgetArea, dockWindows["InstrumentList"], Qt::Orientation::Vertical);
MainWindow->addDockWidget(Qt::DockWidgetArea::RightDockWidgetArea, dockWindows["ScoreList"], Qt::Orientation::Vertical);
// Activate Windows
dockWindows["ObjectProperty"]->raise();
}
static void* ui_companion_qt_init(void)
{
ui_companion_qt_t *handle = (ui_companion_qt_t*)calloc(1, sizeof(*handle));
MainWindow *mainwindow = NULL;
QHBoxLayout *browserButtonsHBoxLayout = NULL;
QVBoxLayout *layout = NULL;
QVBoxLayout *launchWithWidgetLayout = NULL;
QHBoxLayout *coreComboBoxLayout = NULL;
QMenuBar *menu = NULL;
QDesktopWidget *desktop = NULL;
QMenu *fileMenu = NULL;
QMenu *editMenu = NULL;
QMenu *viewMenu = NULL;
QMenu *viewClosedDocksMenu = NULL;
QRect desktopRect;
QDockWidget *thumbnailDock = NULL;
QDockWidget *thumbnail2Dock = NULL;
QDockWidget *thumbnail3Dock = NULL;
QDockWidget *browserAndPlaylistTabDock = NULL;
QDockWidget *coreSelectionDock = NULL;
QTabWidget *browserAndPlaylistTabWidget = NULL;
QWidget *widget = NULL;
QWidget *browserWidget = NULL;
QWidget *playlistWidget = NULL;
QWidget *coreSelectionWidget = NULL;
QWidget *launchWithWidget = NULL;
ThumbnailWidget *thumbnailWidget = NULL;
ThumbnailWidget *thumbnail2Widget = NULL;
ThumbnailWidget *thumbnail3Widget = NULL;
QPushButton *browserDownloadsButton = NULL;
QPushButton *browserUpButton = NULL;
QPushButton *browserStartButton = NULL;
ThumbnailLabel *thumbnail = NULL;
ThumbnailLabel *thumbnail2 = NULL;
ThumbnailLabel *thumbnail3 = NULL;
QAction *editSearchAction = NULL;
QAction *loadCoreAction = NULL;
QAction *unloadCoreAction = NULL;
QAction *exitAction = NULL;
QComboBox *launchWithComboBox = NULL;
QSettings *qsettings = NULL;
if (!handle)
return NULL;
handle->app = static_cast<ui_application_qt_t*>(ui_application_qt.initialize());
handle->window = static_cast<ui_window_qt_t*>(ui_window_qt.init());
desktop = qApp->desktop();
desktopRect = desktop->availableGeometry();
mainwindow = handle->window->qtWindow;
qsettings = mainwindow->settings();
mainwindow->resize(qMin(desktopRect.width(), INITIAL_WIDTH), qMin(desktopRect.height(), INITIAL_HEIGHT));
mainwindow->setGeometry(QStyle::alignedRect(Qt::LeftToRight, Qt::AlignCenter, mainwindow->size(), desktopRect));
mainwindow->setWindowTitle("RetroArch");
mainwindow->setDockOptions(QMainWindow::AnimatedDocks | QMainWindow::AllowNestedDocks | QMainWindow::AllowTabbedDocks | GROUPED_DRAGGING);
widget = new QWidget(mainwindow);
widget->setObjectName("tableWidget");
layout = new QVBoxLayout();
layout->addWidget(mainwindow->contentTableWidget());
widget->setLayout(layout);
mainwindow->setCentralWidget(widget);
menu = mainwindow->menuBar();
fileMenu = menu->addMenu(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_FILE));
loadCoreAction = fileMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_FILE_LOAD_CORE), mainwindow, SLOT(onLoadCoreClicked()));
loadCoreAction->setShortcut(QKeySequence("Ctrl+L"));
unloadCoreAction = fileMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_FILE_UNLOAD_CORE), mainwindow, SLOT(onUnloadCoreMenuAction()));
unloadCoreAction->setObjectName("unloadCoreAction");
unloadCoreAction->setEnabled(false);
unloadCoreAction->setShortcut(QKeySequence("Ctrl+U"));
exitAction = fileMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_FILE_EXIT), mainwindow, SLOT(close()));
exitAction->setShortcut(QKeySequence::Quit);
editMenu = menu->addMenu(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_EDIT));
editSearchAction = editMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_EDIT_SEARCH), mainwindow->searchLineEdit(), SLOT(setFocus()));
editSearchAction->setShortcut(QKeySequence::Find);
viewMenu = menu->addMenu(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_VIEW));
viewClosedDocksMenu = viewMenu->addMenu(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_VIEW_CLOSED_DOCKS));
viewClosedDocksMenu->setObjectName("viewClosedDocksMenu");
QObject::connect(viewClosedDocksMenu, SIGNAL(aboutToShow()), mainwindow, SLOT(onViewClosedDocksAboutToShow()));
viewMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_VIEW_OPTIONS), mainwindow->viewOptionsDialog(), SLOT(showDialog()));
playlistWidget = new QWidget();
playlistWidget->setLayout(new QVBoxLayout());
playlistWidget->setObjectName("playlistWidget");
playlistWidget->layout()->addWidget(mainwindow->playlistListWidget());
browserWidget = new QWidget();
browserWidget->setLayout(new QVBoxLayout());
browserWidget->setObjectName("browserWidget");
browserDownloadsButton = new QPushButton(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CORE_ASSETS_DIRECTORY));
browserUpButton = new QPushButton(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_TAB_FILE_BROWSER_UP));
browserStartButton = new QPushButton(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_FAVORITES));
QObject::connect(browserDownloadsButton, SIGNAL(clicked()), mainwindow, SLOT(onBrowserDownloadsClicked()));
QObject::connect(browserUpButton, SIGNAL(clicked()), mainwindow, SLOT(onBrowserUpClicked()));
QObject::connect(browserStartButton, SIGNAL(clicked()), mainwindow, SLOT(onBrowserStartClicked()));
browserButtonsHBoxLayout = new QHBoxLayout();
browserButtonsHBoxLayout->addWidget(browserUpButton);
browserButtonsHBoxLayout->addWidget(browserStartButton);
browserButtonsHBoxLayout->addWidget(browserDownloadsButton);
qobject_cast<QVBoxLayout*>(browserWidget->layout())->addLayout(browserButtonsHBoxLayout);
browserWidget->layout()->addWidget(mainwindow->dirTreeView());
browserAndPlaylistTabWidget = mainwindow->browserAndPlaylistTabWidget();
browserAndPlaylistTabWidget->setObjectName("browserAndPlaylistTabWidget");
/* Several functions depend on the same tab title strings here, so if you change these, make sure to change those too
* setCoreActions()
* onTabWidgetIndexChanged()
* onCurrentListItemChanged()
*/
browserAndPlaylistTabWidget->addTab(playlistWidget, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_TAB_PLAYLISTS));
browserAndPlaylistTabWidget->addTab(browserWidget, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_TAB_FILE_BROWSER));
browserAndPlaylistTabDock = new QDockWidget(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_DOCK_CONTENT_BROWSER), mainwindow);
browserAndPlaylistTabDock->setObjectName("browserAndPlaylistTabDock");
browserAndPlaylistTabDock->setProperty("default_area", Qt::LeftDockWidgetArea);
browserAndPlaylistTabDock->setProperty("menu_text", msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_DOCK_CONTENT_BROWSER));
browserAndPlaylistTabDock->setWidget(browserAndPlaylistTabWidget);
mainwindow->addDockWidget(static_cast<Qt::DockWidgetArea>(browserAndPlaylistTabDock->property("default_area").toInt()), browserAndPlaylistTabDock);
browserButtonsHBoxLayout->addItem(new QSpacerItem(browserAndPlaylistTabWidget->tabBar()->width(), 20, QSizePolicy::Expanding, QSizePolicy::Minimum));
thumbnailWidget = new ThumbnailWidget();
thumbnail2Widget = new ThumbnailWidget();
thumbnail3Widget = new ThumbnailWidget();
thumbnailWidget->setLayout(new QVBoxLayout());
thumbnail2Widget->setLayout(new QVBoxLayout());
thumbnail3Widget->setLayout(new QVBoxLayout());
thumbnailWidget->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
thumbnail2Widget->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
thumbnail3Widget->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
thumbnail = new ThumbnailLabel();
thumbnail->setObjectName("thumbnail");
thumbnail2 = new ThumbnailLabel();
thumbnail2->setObjectName("thumbnail2");
thumbnail3 = new ThumbnailLabel();
thumbnail3->setObjectName("thumbnail3");
thumbnail->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
thumbnail2->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
thumbnail3->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
QObject::connect(mainwindow, SIGNAL(thumbnailChanged(const QPixmap&)), thumbnail, SLOT(setPixmap(const QPixmap&)));
QObject::connect(mainwindow, SIGNAL(thumbnail2Changed(const QPixmap&)), thumbnail2, SLOT(setPixmap(const QPixmap&)));
QObject::connect(mainwindow, SIGNAL(thumbnail3Changed(const QPixmap&)), thumbnail3, SLOT(setPixmap(const QPixmap&)));
thumbnailWidget->layout()->addWidget(thumbnail);
thumbnail2Widget->layout()->addWidget(thumbnail2);
thumbnail3Widget->layout()->addWidget(thumbnail3);
thumbnailDock = new QDockWidget(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_THUMBNAIL_BOXART), mainwindow);
thumbnailDock->setObjectName("thumbnailDock");
thumbnailDock->setProperty("default_area", Qt::RightDockWidgetArea);
thumbnailDock->setProperty("menu_text", msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_THUMBNAIL_BOXART));
thumbnailDock->setWidget(thumbnailWidget);
mainwindow->addDockWidget(static_cast<Qt::DockWidgetArea>(thumbnailDock->property("default_area").toInt()), thumbnailDock);
thumbnail2Dock = new QDockWidget(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_THUMBNAIL_TITLE_SCREEN), mainwindow);
thumbnail2Dock->setObjectName("thumbnail2Dock");
thumbnail2Dock->setProperty("default_area", Qt::RightDockWidgetArea);
thumbnail2Dock->setProperty("menu_text", msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_THUMBNAIL_TITLE_SCREEN));
thumbnail2Dock->setWidget(thumbnail2Widget);
mainwindow->addDockWidget(static_cast<Qt::DockWidgetArea>(thumbnail2Dock->property("default_area").toInt()), thumbnail2Dock);
thumbnail3Dock = new QDockWidget(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_THUMBNAIL_SCREENSHOT), mainwindow);
thumbnail3Dock->setObjectName("thumbnail3Dock");
thumbnail3Dock->setProperty("default_area", Qt::RightDockWidgetArea);
thumbnail3Dock->setProperty("menu_text", msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_THUMBNAIL_SCREENSHOT));
thumbnail3Dock->setWidget(thumbnail3Widget);
mainwindow->addDockWidget(static_cast<Qt::DockWidgetArea>(thumbnail3Dock->property("default_area").toInt()), thumbnail3Dock);
mainwindow->tabifyDockWidget(thumbnailDock, thumbnail2Dock);
mainwindow->tabifyDockWidget(thumbnailDock, thumbnail3Dock);
/* when tabifying the dock widgets, the last tab added is selected by default, so we need to re-select the first tab */
thumbnailDock->raise();
coreSelectionWidget = new QWidget();
coreSelectionWidget->setLayout(new QVBoxLayout());
launchWithComboBox = mainwindow->launchWithComboBox();
launchWithWidgetLayout = new QVBoxLayout();
launchWithWidget = new QWidget();
launchWithWidget->setLayout(launchWithWidgetLayout);
coreComboBoxLayout = new QHBoxLayout();
mainwindow->runPushButton()->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Expanding));
mainwindow->stopPushButton()->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Expanding));
mainwindow->startCorePushButton()->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Expanding));
coreComboBoxLayout->addWidget(launchWithComboBox);
coreComboBoxLayout->addWidget(mainwindow->startCorePushButton());
coreComboBoxLayout->addWidget(mainwindow->coreInfoPushButton());
coreComboBoxLayout->addWidget(mainwindow->runPushButton());
coreComboBoxLayout->addWidget(mainwindow->stopPushButton());
mainwindow->stopPushButton()->hide();
coreComboBoxLayout->setStretchFactor(launchWithComboBox, 1);
launchWithWidgetLayout->addLayout(coreComboBoxLayout);
coreSelectionWidget->layout()->addWidget(launchWithWidget);
coreSelectionWidget->layout()->addItem(new QSpacerItem(20, browserAndPlaylistTabWidget->height(), QSizePolicy::Minimum, QSizePolicy::Expanding));
coreSelectionDock = new QDockWidget(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_CORE), mainwindow);
coreSelectionDock->setObjectName("coreSelectionDock");
coreSelectionDock->setProperty("default_area", Qt::LeftDockWidgetArea);
coreSelectionDock->setProperty("menu_text", msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_CORE));
coreSelectionDock->setWidget(coreSelectionWidget);
mainwindow->addDockWidget(static_cast<Qt::DockWidgetArea>(coreSelectionDock->property("default_area").toInt()), coreSelectionDock);
mainwindow->splitDockWidget(browserAndPlaylistTabDock, coreSelectionDock, Qt::Vertical);
#if (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0))
mainwindow->resizeDocks(QList<QDockWidget*>() << coreSelectionDock, QList<int>() << 1, Qt::Vertical);
#endif
/* this should come last */
mainwindow->resizeThumbnails(true, true, true);
if (qsettings->contains("geometry"))
if (qsettings->contains("save_geometry"))
mainwindow->restoreGeometry(qsettings->value("geometry").toByteArray());
if (qsettings->contains("save_dock_positions"))
if (qsettings->contains("dock_positions"))
mainwindow->restoreState(qsettings->value("dock_positions").toByteArray());
if (qsettings->contains("save_last_tab"))
{
if (qsettings->contains("last_tab"))
{
int lastTabIndex = qsettings->value("last_tab", 0).toInt();
if (lastTabIndex >= 0 && browserAndPlaylistTabWidget->count() > lastTabIndex)
browserAndPlaylistTabWidget->setCurrentIndex(lastTabIndex);
}
}
if (qsettings->contains("theme"))
{
QString themeStr = qsettings->value("theme").toString();
MainWindow::Theme theme = mainwindow->getThemeFromString(themeStr);
if (qsettings->contains("custom_theme") && theme == MainWindow::THEME_CUSTOM)
{
QString customThemeFilePath = qsettings->value("custom_theme").toString();
mainwindow->setCustomThemeFile(customThemeFilePath);
}
mainwindow->setTheme(theme);
}
else
mainwindow->setTheme();
return handle;
}
// ========================================================
int init1 ( )
{
BL_FUNC_DEBUG
PluginBl_Report *mcont = new PluginBl_Report;
QMenu *pPluginMenu = NULL;
/// Miramos si existe un menu Informes
pPluginMenu = g_pluginbl_report->menuBar()->findChild<QMenu *> ( "menuInformes" );
QMenu *pPluginVer = g_pluginbl_report->menuBar()->findChild<QMenu *> ( "menuVentana" );
/// Buscamos ficheros adecuados
QDir dir ( g_confpr->value( CONF_DIR_OPENREPORTS ) );
dir.setFilter ( QDir::Files | QDir::NoSymLinks );
dir.setSorting ( QDir::Size | QDir::Reversed );
/// Hacemos un filtrado de busqueda
QStringList filters;
filters << "inf_*.txt";
dir.setNameFilters ( filters );
QFileInfoList list = dir.entryInfoList();
for ( int i = 0; i < list.size(); ++i ) {
QFileInfo fileInfo = list.at ( i );
QFile file;
file.setFileName ( g_confpr->value( CONF_DIR_OPENREPORTS ) + fileInfo.fileName() );
file.open ( QIODevice::ReadOnly );
QTextStream stream ( &file );
QString buff = stream.readAll();
file.close();
/// Buscamos el titulo
QString titulo = fileInfo.fileName();
QRegExp rx3 ( " title\\s*=\\s*\"(.*)\"" );
rx3.setMinimal ( true );
if ( rx3.indexIn ( buff, 0 ) != -1 ) {
titulo = rx3.cap ( 1 );
} // end while
QString pathtitulo = fileInfo.fileName();
QRegExp rx1 ( "pathtitle\\s*=\\s*\"(.*)\"" );
rx1.setMinimal ( true );
if ( rx1.indexIn ( buff, 0 ) != -1 ) {
pathtitulo = rx1.cap ( 1 );
} else {
pathtitulo = titulo;
} // end while
/// Buscamos el icono
QString icon = ":/Images/template2rml.png";
QRegExp rx6 ( " icon\\s*=\\s*\"(.*)\"" );
rx6.setMinimal ( true );
if ( rx6.indexIn ( buff, 0 ) != -1 ) {
icon = rx6.cap ( 1 );
} // end while
QMenuBar *menubar =g_pluginbl_report->menuBar();
QMenu *menu = NULL;
QStringList path = pathtitulo.split("\\");
if (path.size() > 1) {
QList<QMenu *> allPButtons = menubar->findChildren<QMenu *>();
bool encontrado = false;
for (int j = 0; j < allPButtons.size(); ++j) {
if (allPButtons.at(j)->title() == path[0]) {
encontrado = true;
menu = allPButtons.at(j);
} // end if
} // end for
if (!encontrado) {
QMenu *pPluginMenu1 = new QMenu (path[0] , menubar );
menubar->insertMenu ( pPluginVer->menuAction(), pPluginMenu1 );
menu = pPluginMenu1;
} // end if
} else {
if (!pPluginMenu) {
pPluginMenu = new QMenu ( _ ( "Informes" ), g_pluginbl_report->menuBar() );
pPluginMenu->setObjectName ( QString::fromUtf8 ( "menuInformes" ) );
g_pluginbl_report->menuBar()->insertMenu ( pPluginVer->menuAction(), pPluginMenu );
} // end if
menu = pPluginMenu;
} // end if
for (int i = 1; i < path.size()-1; ++i) {
QList<QMenu *> allPButtons = menu->findChildren<QMenu *>();
bool encontrado = false;
for (int j = 0; j < allPButtons.size(); ++j) {
if (allPButtons.at(j)->title() == path[i]) {
encontrado = true;
menu = allPButtons.at(j);
} // end if
} // end for
if (!encontrado) {
QMenu *pPluginMenu1 = new QMenu ( path[i] , menu );
menu->addMenu ( pPluginMenu1 );
menu = pPluginMenu1;
} // end if
} // end for
/// Creamos el menú.
QAction *accion = new QAction ( path[path.size()-1], 0 );
accion->setIcon(QIcon(icon));
accion->setObjectName ( fileInfo.fileName() );
accion->setStatusTip ( titulo);
accion->setWhatsThis ( titulo );
mcont->connect ( accion, SIGNAL ( activated() ), mcont, SLOT ( elslot2() ) );
menu->addAction ( accion );
} // end for
return 0;
}
void MenuManager::setup(MenuItem* item, QMenu* menu) const
{
CommandManager& mgr = Application::Instance->commandManager();
QList<MenuItem*> items = item->getItems();
QList<QAction*> actions = menu->actions();
for (QList<MenuItem*>::ConstIterator it = items.begin(); it != items.end(); ++it) {
// search for the menu item
QList<QAction*> used_actions = findActions(actions, QString::fromAscii((*it)->command().c_str()));
if (used_actions.isEmpty()) {
if ((*it)->command() == "Separator") {
QAction* action = menu->addSeparator();
action->setObjectName(QLatin1String("Separator"));
// set the menu user data
action->setData(QLatin1String("Separator"));
used_actions.append(action);
}
else {
if ((*it)->hasItems()) {
// Creste a submenu
std::string menuName = (*it)->command();
QMenu* submenu = menu->addMenu(
QApplication::translate("Workbench", menuName.c_str(),
0, QApplication::UnicodeUTF8));
QAction* action = submenu->menuAction();
submenu->setObjectName(QString::fromAscii((*it)->command().c_str()));
action->setObjectName(QString::fromAscii((*it)->command().c_str()));
// set the menu user data
action->setData(QString::fromAscii((*it)->command().c_str()));
used_actions.append(action);
}
else {
// A command can have more than one QAction
int count = menu->actions().count();
// Check if action was added successfully
if (mgr.addTo((*it)->command().c_str(), menu)) {
QList<QAction*> acts = menu->actions();
for (int i=count; i < acts.count(); i++) {
QAction* a = acts[i];
// set the menu user data
a->setData(QString::fromAscii((*it)->command().c_str()));
used_actions.append(a);
}
}
}
}
}
else {
for (QList<QAction*>::Iterator it = used_actions.begin(); it != used_actions.end(); ++it) {
// put the menu item at the end
menu->removeAction(*it);
menu->addAction(*it);
int index = actions.indexOf(*it);
actions.removeAt(index);
}
}
// fill up the submenu
if ((*it)->hasItems())
setup(*it, used_actions.front()->menu());
}
// remove all menu items which we don't need for the moment
for (QList<QAction*>::Iterator it = actions.begin(); it != actions.end(); ++it) {
menu->removeAction(*it);
}
}
bool AddFxContextMenu::loadPreset(const string &name,
QMenu *insertFxGroup, QMenu *addFxGroup, QMenu *replaceFxGroup)
{
TFilePath presetsFilepath(m_presetPath + name);
if (TFileStatus(presetsFilepath).isDirectory()) {
TFilePathSet presets = TSystem::readDirectory(presetsFilepath, false);
if (!presets.empty()) {
QMenu *inserMenu = new QMenu(QString::fromStdWString(TStringTable::translate(name)), insertFxGroup);
insertFxGroup->addMenu(inserMenu);
QMenu *addMenu = new QMenu(QString::fromStdWString(TStringTable::translate(name)), addFxGroup);
addFxGroup->addMenu(addMenu);
QMenu *replaceMenu = new QMenu(QString::fromStdWString(TStringTable::translate(name)), replaceFxGroup);
replaceFxGroup->addMenu(replaceMenu);
//This is a workaround to set the bold style to the first element of this menu
//Setting a font directly to a QAction is not enought; style sheet definitions
//preval over QAction font settings.
inserMenu->setObjectName("fxMenu");
addMenu->setObjectName("fxMenu");
replaceMenu->setObjectName("fxMenu");
QAction *insertAction = new QAction(QString::fromStdWString(TStringTable::translate(name)), inserMenu);
QAction *addAction = new QAction(QString::fromStdWString(TStringTable::translate(name)), addMenu);
QAction *replaceAction = new QAction(QString::fromStdWString(TStringTable::translate(name)), replaceMenu);
insertAction->setCheckable(true);
addAction->setCheckable(true);
replaceAction->setCheckable(true);
insertAction->setData(QVariant(QString::fromStdString(name)));
addAction->setData(QVariant(QString::fromStdString(name)));
replaceAction->setData(QVariant(QString::fromStdString(name)));
inserMenu->addAction(insertAction);
addMenu->addAction(addAction);
replaceMenu->addAction(replaceAction);
m_insertActionGroup->addAction(insertAction);
m_addActionGroup->addAction(addAction);
m_replaceActionGroup->addAction(replaceAction);
for (TFilePathSet::iterator it2 = presets.begin(); it2 != presets.end(); ++it2) {
TFilePath presetName = *it2;
QString qPresetName = QString::fromStdWString(presetName.getWideName());
insertAction = new QAction(qPresetName, inserMenu);
addAction = new QAction(qPresetName, addMenu);
replaceAction = new QAction(qPresetName, replaceMenu);
insertAction->setData(QVariant(QString::fromStdWString(presetName.getWideString())));
addAction->setData(QVariant(QString::fromStdWString(presetName.getWideString())));
replaceAction->setData(QVariant(QString::fromStdWString(presetName.getWideString())));
inserMenu->addAction(insertAction);
addMenu->addAction(addAction);
replaceMenu->addAction(replaceAction);
m_insertActionGroup->addAction(insertAction);
m_addActionGroup->addAction(addAction);
m_replaceActionGroup->addAction(replaceAction);
}
return true;
} else
return false;
} else
return false;
}
static void* ui_companion_qt_init(void)
{
ui_companion_qt_t *handle = (ui_companion_qt_t*)calloc(1, sizeof(*handle));
MainWindow *mainwindow = NULL;
QHBoxLayout *browserButtonsHBoxLayout = NULL;
QVBoxLayout *layout = NULL;
QVBoxLayout *launchWithWidgetLayout = NULL;
QHBoxLayout *coreComboBoxLayout = NULL;
QMenuBar *menu = NULL;
QDesktopWidget *desktop = NULL;
QMenu *fileMenu = NULL;
QMenu *editMenu = NULL;
QMenu *viewMenu = NULL;
QMenu *viewClosedDocksMenu = NULL;
QMenu *toolsMenu = NULL;
QMenu *updaterMenu = NULL;
QMenu *helpMenu = NULL;
QRect desktopRect;
QDockWidget *thumbnailDock = NULL;
QDockWidget *thumbnail2Dock = NULL;
QDockWidget *thumbnail3Dock = NULL;
QDockWidget *browserAndPlaylistTabDock = NULL;
QDockWidget *coreSelectionDock = NULL;
QTabWidget *browserAndPlaylistTabWidget = NULL;
QWidget *widget = NULL;
QWidget *browserWidget = NULL;
QWidget *playlistWidget = NULL;
QWidget *coreSelectionWidget = NULL;
QWidget *launchWithWidget = NULL;
ThumbnailWidget *thumbnailWidget = NULL;
ThumbnailWidget *thumbnail2Widget = NULL;
ThumbnailWidget *thumbnail3Widget = NULL;
QPushButton *browserDownloadsButton = NULL;
QPushButton *browserUpButton = NULL;
QPushButton *browserStartButton = NULL;
ThumbnailLabel *thumbnail = NULL;
ThumbnailLabel *thumbnail2 = NULL;
ThumbnailLabel *thumbnail3 = NULL;
QAction *editSearchAction = NULL;
QAction *loadCoreAction = NULL;
QAction *unloadCoreAction = NULL;
QAction *exitAction = NULL;
QComboBox *launchWithComboBox = NULL;
QSettings *qsettings = NULL;
QListWidget *listWidget = NULL;
int i = 0;
if (!handle)
return NULL;
handle->app = static_cast<ui_application_qt_t*>(ui_application_qt.initialize());
handle->window = static_cast<ui_window_qt_t*>(ui_window_qt.init());
desktop = qApp->desktop();
desktopRect = desktop->availableGeometry();
mainwindow = handle->window->qtWindow;
qsettings = mainwindow->settings();
mainwindow->resize(qMin(desktopRect.width(), INITIAL_WIDTH), qMin(desktopRect.height(), INITIAL_HEIGHT));
mainwindow->setGeometry(QStyle::alignedRect(Qt::LeftToRight, Qt::AlignCenter, mainwindow->size(), desktopRect));
mainwindow->setWindowTitle("RetroArch");
mainwindow->setDockOptions(QMainWindow::AnimatedDocks | QMainWindow::AllowNestedDocks | QMainWindow::AllowTabbedDocks | GROUPED_DRAGGING);
listWidget = mainwindow->playlistListWidget();
widget = new FileDropWidget(mainwindow);
widget->setObjectName("tableWidget");
widget->setContextMenuPolicy(Qt::CustomContextMenu);
QObject::connect(widget, SIGNAL(filesDropped(QStringList)), mainwindow, SLOT(onPlaylistFilesDropped(QStringList)));
QObject::connect(widget, SIGNAL(deletePressed()), mainwindow, SLOT(deleteCurrentPlaylistItem()));
QObject::connect(widget, SIGNAL(customContextMenuRequested(const QPoint&)), mainwindow, SLOT(onFileDropWidgetContextMenuRequested(const QPoint&)));
layout = new QVBoxLayout();
layout->addWidget(mainwindow->contentTableWidget());
layout->addWidget(mainwindow->contentGridWidget());
widget->setLayout(layout);
mainwindow->setCentralWidget(widget);
menu = mainwindow->menuBar();
fileMenu = menu->addMenu(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_FILE));
loadCoreAction = fileMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_FILE_LOAD_CORE), mainwindow, SLOT(onLoadCoreClicked()));
loadCoreAction->setShortcut(QKeySequence("Ctrl+L"));
unloadCoreAction = fileMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_FILE_UNLOAD_CORE), mainwindow, SLOT(onUnloadCoreMenuAction()));
unloadCoreAction->setObjectName("unloadCoreAction");
unloadCoreAction->setEnabled(false);
unloadCoreAction->setShortcut(QKeySequence("Ctrl+U"));
exitAction = fileMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_FILE_EXIT), mainwindow, SLOT(close()));
exitAction->setShortcut(QKeySequence::Quit);
editMenu = menu->addMenu(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_EDIT));
editSearchAction = editMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_EDIT_SEARCH), mainwindow->searchLineEdit(), SLOT(setFocus()));
editSearchAction->setShortcut(QKeySequence::Find);
viewMenu = menu->addMenu(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_VIEW));
viewClosedDocksMenu = viewMenu->addMenu(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_VIEW_CLOSED_DOCKS));
viewClosedDocksMenu->setObjectName("viewClosedDocksMenu");
QObject::connect(viewClosedDocksMenu, SIGNAL(aboutToShow()), mainwindow, SLOT(onViewClosedDocksAboutToShow()));
viewMenu->addSeparator();
viewMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_VIEW_TYPE_ICONS), mainwindow, SLOT(onIconViewClicked()));
viewMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_VIEW_TYPE_LIST), mainwindow, SLOT(onListViewClicked()));
viewMenu->addSeparator();
viewMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_VIEW_OPTIONS), mainwindow->viewOptionsDialog(), SLOT(showDialog()));
toolsMenu = menu->addMenu(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_TOOLS));
updaterMenu = toolsMenu->addMenu(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_ONLINE_UPDATER));
#ifdef Q_OS_WIN
updaterMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_UPDATE_RETROARCH_NIGHTLY), mainwindow, SLOT(updateRetroArchNightly()));
#endif
helpMenu = menu->addMenu(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_HELP));
helpMenu->addAction(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_HELP_DOCUMENTATION)), mainwindow, SLOT(showDocs()));
helpMenu->addAction(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_HELP_ABOUT)) + "...", mainwindow, SLOT(showAbout()));
helpMenu->addAction("About Qt...", qApp, SLOT(aboutQt()));
playlistWidget = new QWidget();
playlistWidget->setLayout(new QVBoxLayout());
playlistWidget->setObjectName("playlistWidget");
playlistWidget->layout()->addWidget(mainwindow->playlistListWidget());
browserWidget = new QWidget();
browserWidget->setLayout(new QVBoxLayout());
browserWidget->setObjectName("browserWidget");
browserDownloadsButton = new QPushButton(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CORE_ASSETS_DIRECTORY));
browserUpButton = new QPushButton(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_TAB_FILE_BROWSER_UP));
browserStartButton = new QPushButton(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_FAVORITES));
QObject::connect(browserDownloadsButton, SIGNAL(clicked()), mainwindow, SLOT(onBrowserDownloadsClicked()));
QObject::connect(browserUpButton, SIGNAL(clicked()), mainwindow, SLOT(onBrowserUpClicked()));
QObject::connect(browserStartButton, SIGNAL(clicked()), mainwindow, SLOT(onBrowserStartClicked()));
browserButtonsHBoxLayout = new QHBoxLayout();
browserButtonsHBoxLayout->addWidget(browserUpButton);
browserButtonsHBoxLayout->addWidget(browserStartButton);
browserButtonsHBoxLayout->addWidget(browserDownloadsButton);
qobject_cast<QVBoxLayout*>(browserWidget->layout())->addLayout(browserButtonsHBoxLayout);
browserWidget->layout()->addWidget(mainwindow->dirTreeView());
browserAndPlaylistTabWidget = mainwindow->browserAndPlaylistTabWidget();
browserAndPlaylistTabWidget->setObjectName("browserAndPlaylistTabWidget");
/* Several functions depend on the same tab title strings here, so if you change these, make sure to change those too
* setCoreActions()
* onTabWidgetIndexChanged()
* onCurrentListItemChanged()
*/
browserAndPlaylistTabWidget->addTab(playlistWidget, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_TAB_PLAYLISTS));
browserAndPlaylistTabWidget->addTab(browserWidget, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_TAB_FILE_BROWSER));
browserAndPlaylistTabDock = new QDockWidget(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_DOCK_CONTENT_BROWSER), mainwindow);
browserAndPlaylistTabDock->setObjectName("browserAndPlaylistTabDock");
browserAndPlaylistTabDock->setProperty("default_area", Qt::LeftDockWidgetArea);
browserAndPlaylistTabDock->setProperty("menu_text", msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_DOCK_CONTENT_BROWSER));
browserAndPlaylistTabDock->setWidget(browserAndPlaylistTabWidget);
mainwindow->addDockWidget(static_cast<Qt::DockWidgetArea>(browserAndPlaylistTabDock->property("default_area").toInt()), browserAndPlaylistTabDock);
browserButtonsHBoxLayout->addItem(new QSpacerItem(browserAndPlaylistTabWidget->tabBar()->width(), 20, QSizePolicy::Expanding, QSizePolicy::Minimum));
thumbnailWidget = new ThumbnailWidget();
thumbnail2Widget = new ThumbnailWidget();
thumbnail3Widget = new ThumbnailWidget();
thumbnailWidget->setLayout(new QVBoxLayout());
thumbnail2Widget->setLayout(new QVBoxLayout());
thumbnail3Widget->setLayout(new QVBoxLayout());
thumbnailWidget->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
thumbnail2Widget->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
thumbnail3Widget->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
thumbnail = new ThumbnailLabel();
thumbnail->setObjectName("thumbnail");
thumbnail2 = new ThumbnailLabel();
thumbnail2->setObjectName("thumbnail2");
thumbnail3 = new ThumbnailLabel();
thumbnail3->setObjectName("thumbnail3");
thumbnail->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
thumbnail2->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
thumbnail3->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
QObject::connect(mainwindow, SIGNAL(thumbnailChanged(const QPixmap&)), thumbnail, SLOT(setPixmap(const QPixmap&)));
QObject::connect(mainwindow, SIGNAL(thumbnail2Changed(const QPixmap&)), thumbnail2, SLOT(setPixmap(const QPixmap&)));
QObject::connect(mainwindow, SIGNAL(thumbnail3Changed(const QPixmap&)), thumbnail3, SLOT(setPixmap(const QPixmap&)));
thumbnailWidget->layout()->addWidget(thumbnail);
thumbnail2Widget->layout()->addWidget(thumbnail2);
thumbnail3Widget->layout()->addWidget(thumbnail3);
thumbnailDock = new QDockWidget(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_THUMBNAIL_BOXART), mainwindow);
thumbnailDock->setObjectName("thumbnailDock");
thumbnailDock->setProperty("default_area", Qt::RightDockWidgetArea);
thumbnailDock->setProperty("menu_text", msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_THUMBNAIL_BOXART));
thumbnailDock->setWidget(thumbnailWidget);
mainwindow->addDockWidget(static_cast<Qt::DockWidgetArea>(thumbnailDock->property("default_area").toInt()), thumbnailDock);
thumbnail2Dock = new QDockWidget(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_THUMBNAIL_TITLE_SCREEN), mainwindow);
thumbnail2Dock->setObjectName("thumbnail2Dock");
thumbnail2Dock->setProperty("default_area", Qt::RightDockWidgetArea);
thumbnail2Dock->setProperty("menu_text", msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_THUMBNAIL_TITLE_SCREEN));
thumbnail2Dock->setWidget(thumbnail2Widget);
mainwindow->addDockWidget(static_cast<Qt::DockWidgetArea>(thumbnail2Dock->property("default_area").toInt()), thumbnail2Dock);
thumbnail3Dock = new QDockWidget(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_THUMBNAIL_SCREENSHOT), mainwindow);
thumbnail3Dock->setObjectName("thumbnail3Dock");
thumbnail3Dock->setProperty("default_area", Qt::RightDockWidgetArea);
thumbnail3Dock->setProperty("menu_text", msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_THUMBNAIL_SCREENSHOT));
thumbnail3Dock->setWidget(thumbnail3Widget);
mainwindow->addDockWidget(static_cast<Qt::DockWidgetArea>(thumbnail3Dock->property("default_area").toInt()), thumbnail3Dock);
mainwindow->tabifyDockWidget(thumbnailDock, thumbnail2Dock);
mainwindow->tabifyDockWidget(thumbnailDock, thumbnail3Dock);
/* when tabifying the dock widgets, the last tab added is selected by default, so we need to re-select the first tab */
thumbnailDock->raise();
coreSelectionWidget = new QWidget();
coreSelectionWidget->setLayout(new QVBoxLayout());
launchWithComboBox = mainwindow->launchWithComboBox();
launchWithWidgetLayout = new QVBoxLayout();
launchWithWidget = new QWidget();
launchWithWidget->setLayout(launchWithWidgetLayout);
coreComboBoxLayout = new QHBoxLayout();
mainwindow->runPushButton()->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Expanding));
mainwindow->stopPushButton()->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Expanding));
mainwindow->startCorePushButton()->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Expanding));
coreComboBoxLayout->addWidget(launchWithComboBox);
coreComboBoxLayout->addWidget(mainwindow->startCorePushButton());
coreComboBoxLayout->addWidget(mainwindow->coreInfoPushButton());
coreComboBoxLayout->addWidget(mainwindow->runPushButton());
coreComboBoxLayout->addWidget(mainwindow->stopPushButton());
mainwindow->stopPushButton()->hide();
coreComboBoxLayout->setStretchFactor(launchWithComboBox, 1);
launchWithWidgetLayout->addLayout(coreComboBoxLayout);
coreSelectionWidget->layout()->addWidget(launchWithWidget);
coreSelectionWidget->layout()->addItem(new QSpacerItem(20, browserAndPlaylistTabWidget->height(), QSizePolicy::Minimum, QSizePolicy::Expanding));
coreSelectionDock = new QDockWidget(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_CORE), mainwindow);
coreSelectionDock->setObjectName("coreSelectionDock");
coreSelectionDock->setProperty("default_area", Qt::LeftDockWidgetArea);
coreSelectionDock->setProperty("menu_text", msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_CORE));
coreSelectionDock->setWidget(coreSelectionWidget);
mainwindow->addDockWidget(static_cast<Qt::DockWidgetArea>(coreSelectionDock->property("default_area").toInt()), coreSelectionDock);
mainwindow->splitDockWidget(browserAndPlaylistTabDock, coreSelectionDock, Qt::Vertical);
#if (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0))
mainwindow->resizeDocks(QList<QDockWidget*>() << coreSelectionDock, QList<int>() << 1, Qt::Vertical);
#endif
/* this should come last */
mainwindow->resizeThumbnails(true, true, true);
if (qsettings->contains("all_playlists_list_max_count"))
mainwindow->setAllPlaylistsListMaxCount(qsettings->value("all_playlists_list_max_count", 0).toInt());
if (qsettings->contains("all_playlists_grid_max_count"))
mainwindow->setAllPlaylistsGridMaxCount(qsettings->value("all_playlists_grid_max_count", 5000).toInt());
if (qsettings->contains("geometry"))
if (qsettings->contains("save_geometry"))
mainwindow->restoreGeometry(qsettings->value("geometry").toByteArray());
if (qsettings->contains("save_dock_positions"))
if (qsettings->contains("dock_positions"))
mainwindow->restoreState(qsettings->value("dock_positions").toByteArray());
if (qsettings->contains("theme"))
{
QString themeStr = qsettings->value("theme").toString();
MainWindow::Theme theme = mainwindow->getThemeFromString(themeStr);
if (qsettings->contains("custom_theme") && theme == MainWindow::THEME_CUSTOM)
{
QString customThemeFilePath = qsettings->value("custom_theme").toString();
mainwindow->setCustomThemeFile(customThemeFilePath);
}
mainwindow->setTheme(theme);
}
else
mainwindow->setTheme();
if (qsettings->contains("view_type"))
{
QString viewType = qsettings->value("view_type", "list").toString();
if (viewType == "list")
mainwindow->setCurrentViewType(MainWindow::VIEW_TYPE_LIST);
else if (viewType == "icons")
mainwindow->setCurrentViewType(MainWindow::VIEW_TYPE_ICONS);
else
mainwindow->setCurrentViewType(MainWindow::VIEW_TYPE_LIST);
/* we set it to the same thing a second time so that m_lastViewType is also equal to the startup view type */
mainwindow->setCurrentViewType(mainwindow->getCurrentViewType());
}
else
mainwindow->setCurrentViewType(MainWindow::VIEW_TYPE_LIST);
/* We make sure to hook up the tab widget callback only after the tabs themselves have been added,
* but before changing to a specific one, to avoid the callback firing before the view type is set.
*/
QObject::connect(browserAndPlaylistTabWidget, SIGNAL(currentChanged(int)), mainwindow, SLOT(onTabWidgetIndexChanged(int)));
/* setting the last tab must come after setting the view type */
if (qsettings->contains("save_last_tab"))
{
int lastTabIndex = qsettings->value("last_tab", 0).toInt();
if (lastTabIndex >= 0 && browserAndPlaylistTabWidget->count() > lastTabIndex)
{
browserAndPlaylistTabWidget->setCurrentIndex(lastTabIndex);
mainwindow->onTabWidgetIndexChanged(lastTabIndex);
}
}
else
{
browserAndPlaylistTabWidget->setCurrentIndex(0);
mainwindow->onTabWidgetIndexChanged(0);
}
for (i = 0; i < listWidget->count() && listWidget->count() > 0; i++)
{
/* select the first non-hidden row */
if (!listWidget->isRowHidden(i))
{
listWidget->setCurrentRow(i);
break;
}
}
return handle;
}
void setupUi(QMainWindow *Detection)
{
if (Detection->objectName().isEmpty())
Detection->setObjectName(QString::fromUtf8("Detection"));
Detection->resize(729, 480);
actionE_xit = new QAction(Detection);
actionE_xit->setObjectName(QString::fromUtf8("actionE_xit"));
action_Load_Map = new QAction(Detection);
action_Load_Map->setObjectName(QString::fromUtf8("action_Load_Map"));
action_Connect = new QAction(Detection);
action_Connect->setObjectName(QString::fromUtf8("action_Connect"));
action_Disconnect = new QAction(Detection);
action_Disconnect->setObjectName(QString::fromUtf8("action_Disconnect"));
centralWidget = new QWidget(Detection);
centralWidget->setObjectName(QString::fromUtf8("centralWidget"));
gridLayoutWidget = new QWidget(centralWidget);
gridLayoutWidget->setObjectName(QString::fromUtf8("gridLayoutWidget"));
gridLayoutWidget->setGeometry(QRect(0, 0, 721, 421));
gridLayout = new QGridLayout(gridLayoutWidget);
gridLayout->setSpacing(6);
gridLayout->setContentsMargins(11, 11, 11, 11);
gridLayout->setObjectName(QString::fromUtf8("gridLayout"));
gridLayout->setSizeConstraint(QLayout::SetNoConstraint);
gridLayout->setVerticalSpacing(5);
gridLayout->setContentsMargins(0, 0, 0, 0);
ugvFeedLabel = new QLabel(gridLayoutWidget);
ugvFeedLabel->setObjectName(QString::fromUtf8("ugvFeedLabel"));
QSizePolicy sizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
sizePolicy.setHorizontalStretch(0);
sizePolicy.setVerticalStretch(0);
sizePolicy.setHeightForWidth(ugvFeedLabel->sizePolicy().hasHeightForWidth());
ugvFeedLabel->setSizePolicy(sizePolicy);
gridLayout->addWidget(ugvFeedLabel, 1, 2, 1, 1);
connectionButton = new QCommandLinkButton(gridLayoutWidget);
connectionButton->setObjectName(QString::fromUtf8("connectionButton"));
gridLayout->addWidget(connectionButton, 0, 2, 1, 1);
uavFeedLabel = new QLabel(gridLayoutWidget);
uavFeedLabel->setObjectName(QString::fromUtf8("uavFeedLabel"));
sizePolicy.setHeightForWidth(uavFeedLabel->sizePolicy().hasHeightForWidth());
uavFeedLabel->setSizePolicy(sizePolicy);
uavFeedLabel->setMaximumSize(QSize(16777215, 16777215));
gridLayout->addWidget(uavFeedLabel, 1, 0, 1, 1);
ugvMapLabel = new QLabel(gridLayoutWidget);
ugvMapLabel->setObjectName(QString::fromUtf8("ugvMapLabel"));
QSizePolicy sizePolicy1(QSizePolicy::MinimumExpanding, QSizePolicy::Expanding);
sizePolicy1.setHorizontalStretch(0);
sizePolicy1.setVerticalStretch(0);
sizePolicy1.setHeightForWidth(ugvMapLabel->sizePolicy().hasHeightForWidth());
ugvMapLabel->setSizePolicy(sizePolicy1);
gridLayout->addWidget(ugvMapLabel, 1, 3, 1, 1);
horizontalLayout_4 = new QHBoxLayout();
horizontalLayout_4->setSpacing(6);
horizontalLayout_4->setObjectName(QString::fromUtf8("horizontalLayout_4"));
label_2 = new QLabel(gridLayoutWidget);
label_2->setObjectName(QString::fromUtf8("label_2"));
horizontalLayout_4->addWidget(label_2);
uavTakeoffLandButton = new QPushButton(gridLayoutWidget);
uavTakeoffLandButton->setObjectName(QString::fromUtf8("uavTakeoffLandButton"));
horizontalLayout_4->addWidget(uavTakeoffLandButton);
gridLayout->addLayout(horizontalLayout_4, 2, 0, 1, 1);
horizontalLayout_2 = new QHBoxLayout();
horizontalLayout_2->setSpacing(6);
horizontalLayout_2->setObjectName(QString::fromUtf8("horizontalLayout_2"));
label = new QLabel(gridLayoutWidget);
label->setObjectName(QString::fromUtf8("label"));
horizontalLayout_2->addWidget(label);
ugvSpeedLCD = new QLCDNumber(gridLayoutWidget);
ugvSpeedLCD->setObjectName(QString::fromUtf8("ugvSpeedLCD"));
ugvSpeedLCD->setFrameShape(QFrame::Box);
horizontalLayout_2->addWidget(ugvSpeedLCD);
gridLayout->addLayout(horizontalLayout_2, 4, 2, 1, 1);
horizontalLayout_6 = new QHBoxLayout();
horizontalLayout_6->setSpacing(6);
horizontalLayout_6->setObjectName(QString::fromUtf8("horizontalLayout_6"));
label_3 = new QLabel(gridLayoutWidget);
label_3->setObjectName(QString::fromUtf8("label_3"));
horizontalLayout_6->addWidget(label_3);
ugvSpeakerButton = new QPushButton(gridLayoutWidget);
ugvSpeakerButton->setObjectName(QString::fromUtf8("ugvSpeakerButton"));
horizontalLayout_6->addWidget(ugvSpeakerButton);
gridLayout->addLayout(horizontalLayout_6, 2, 2, 1, 1);
verticalLayout = new QVBoxLayout();
verticalLayout->setSpacing(6);
verticalLayout->setObjectName(QString::fromUtf8("verticalLayout"));
label_4 = new QLabel(gridLayoutWidget);
label_4->setObjectName(QString::fromUtf8("label_4"));
label_4->setAlignment(Qt::AlignCenter);
verticalLayout->addWidget(label_4);
sauverStatus = new QTextBrowser(gridLayoutWidget);
sauverStatus->setObjectName(QString::fromUtf8("sauverStatus"));
sauverStatus->setEnabled(true);
QSizePolicy sizePolicy2(QSizePolicy::Minimum, QSizePolicy::Minimum);
sizePolicy2.setHorizontalStretch(0);
sizePolicy2.setVerticalStretch(0);
sizePolicy2.setHeightForWidth(sauverStatus->sizePolicy().hasHeightForWidth());
sauverStatus->setSizePolicy(sizePolicy2);
sauverStatus->setMaximumSize(QSize(777215, 215));
verticalLayout->addWidget(sauverStatus);
gridLayout->addLayout(verticalLayout, 4, 3, 1, 1);
label_5 = new QLabel(gridLayoutWidget);
label_5->setObjectName(QString::fromUtf8("label_5"));
gridLayout->addWidget(label_5, 0, 0, 1, 1);
Detection->setCentralWidget(centralWidget);
menuBar = new QMenuBar(Detection);
menuBar->setObjectName(QString::fromUtf8("menuBar"));
menuBar->setGeometry(QRect(0, 0, 729, 23));
menuFile = new QMenu(menuBar);
menuFile->setObjectName(QString::fromUtf8("menuFile"));
menu_Tools = new QMenu(menuBar);
menu_Tools->setObjectName(QString::fromUtf8("menu_Tools"));
menu_Help = new QMenu(menuBar);
menu_Help->setObjectName(QString::fromUtf8("menu_Help"));
Detection->setMenuBar(menuBar);
mainToolBar = new QToolBar(Detection);
mainToolBar->setObjectName(QString::fromUtf8("mainToolBar"));
Detection->addToolBar(Qt::TopToolBarArea, mainToolBar);
statusBar = new QStatusBar(Detection);
statusBar->setObjectName(QString::fromUtf8("statusBar"));
Detection->setStatusBar(statusBar);
menuBar->addAction(menuFile->menuAction());
menuBar->addAction(menu_Tools->menuAction());
menuBar->addAction(menu_Help->menuAction());
menuFile->addAction(action_Load_Map);
menuFile->addAction(action_Disconnect);
menuFile->addAction(actionE_xit);
menu_Tools->addAction(action_Connect);
retranslateUi(Detection);
QObject::connect(actionE_xit, SIGNAL(activated()), Detection, SLOT(close()));
QObject::connect(action_Connect, SIGNAL(activated()), connectionButton, SLOT(click()));
QMetaObject::connectSlotsByName(Detection);
} // setupUi
void QmitkExtWorkbenchWindowAdvisor::PostWindowCreate()
{
// very bad hack...
berry::IWorkbenchWindow::Pointer window =
this->GetWindowConfigurer()->GetWindow();
QMainWindow* mainWindow =
qobject_cast<QMainWindow*> (window->GetShell()->GetControl());
if (!windowIcon.isEmpty())
{
mainWindow->setWindowIcon(QIcon(windowIcon));
}
mainWindow->setContextMenuPolicy(Qt::PreventContextMenu);
/*mainWindow->setStyleSheet("color: white;"
"background-color: #808080;"
"selection-color: #659EC7;"
"selection-background-color: #808080;"
" QMenuBar {"
"background-color: #808080; }");*/
// Load selected icon theme
QStringList searchPaths = QIcon::themeSearchPaths();
searchPaths.push_front( QString(":/org_mitk_icons/icons/") );
QIcon::setThemeSearchPaths( searchPaths );
berry::IPreferencesService* prefService = berry::Platform::GetPreferencesService();
berry::IPreferences::Pointer stylePref = prefService->GetSystemPreferences()->Node(berry::QtPreferences::QT_STYLES_NODE);
QString iconTheme = stylePref->Get(berry::QtPreferences::QT_ICON_THEME, "<<default>>");
if( iconTheme == QString( "<<default>>" ) )
{
iconTheme = QString( "tango" );
}
QIcon::setThemeName( iconTheme );
// ==== Application menu ============================
QMenuBar* menuBar = mainWindow->menuBar();
menuBar->setContextMenuPolicy(Qt::PreventContextMenu);
#ifdef __APPLE__
menuBar->setNativeMenuBar(true);
#else
menuBar->setNativeMenuBar(false);
#endif
QAction* fileOpenAction = new QmitkFileOpenAction(QIcon::fromTheme("document-open",QIcon(":/org_mitk_icons/icons/tango/scalable/actions/document-open.svg")), window);
fileOpenAction->setShortcut(QKeySequence::Open);
QAction* fileSaveAction = new QmitkFileSaveAction(QIcon(":/org.mitk.gui.qt.ext/Save_48.png"), window);
fileSaveAction->setShortcut(QKeySequence::Save);
fileSaveProjectAction = new QmitkExtFileSaveProjectAction(window);
fileSaveProjectAction->setIcon(QIcon::fromTheme("document-save",QIcon(":/org_mitk_icons/icons/tango/scalable/actions/document-save.svg")));
closeProjectAction = new QmitkCloseProjectAction(window);
closeProjectAction->setIcon(QIcon::fromTheme("edit-delete",QIcon(":/org_mitk_icons/icons/tango/scalable/actions/edit-delete.svg")));
auto perspGroup = new QActionGroup(menuBar);
std::map<QString, berry::IViewDescriptor::Pointer> VDMap;
// sort elements (converting vector to map...)
QList<berry::IViewDescriptor::Pointer>::const_iterator iter;
berry::IViewRegistry* viewRegistry =
berry::PlatformUI::GetWorkbench()->GetViewRegistry();
const QList<berry::IViewDescriptor::Pointer> viewDescriptors = viewRegistry->GetViews();
bool skip = false;
for (iter = viewDescriptors.begin(); iter != viewDescriptors.end(); ++iter)
{
// if viewExcludeList is set, it contains the id-strings of view, which
// should not appear as an menu-entry in the menu
if (viewExcludeList.size() > 0)
{
for (int i=0; i<viewExcludeList.size(); i++)
{
if (viewExcludeList.at(i) == (*iter)->GetId())
{
skip = true;
break;
}
}
if (skip)
{
skip = false;
continue;
}
}
if ((*iter)->GetId() == "org.blueberry.ui.internal.introview")
continue;
if ((*iter)->GetId() == "org.mitk.views.imagenavigator")
continue;
if ((*iter)->GetId() == "org.mitk.views.viewnavigatorview")
continue;
std::pair<QString, berry::IViewDescriptor::Pointer> p(
(*iter)->GetLabel(), (*iter));
VDMap.insert(p);
}
std::map<QString, berry::IViewDescriptor::Pointer>::const_iterator
MapIter;
for (MapIter = VDMap.begin(); MapIter != VDMap.end(); ++MapIter)
{
berry::QtShowViewAction* viewAction = new berry::QtShowViewAction(window,
(*MapIter).second);
viewActions.push_back(viewAction);
}
if (!USE_EXPERIMENTAL_COMMAND_CONTRIBUTIONS)
{
QMenu* fileMenu = menuBar->addMenu("&File");
fileMenu->setObjectName("FileMenu");
fileMenu->addAction(fileOpenAction);
fileMenu->addAction(fileSaveAction);
fileMenu->addAction(fileSaveProjectAction);
fileMenu->addAction(closeProjectAction);
fileMenu->addSeparator();
QAction* fileExitAction = new QmitkFileExitAction(window);
fileExitAction->setIcon(QIcon::fromTheme("system-log-out",QIcon(":/org_mitk_icons/icons/tango/scalable/actions/system-log-out.svg")));
fileExitAction->setShortcut(QKeySequence::Quit);
fileExitAction->setObjectName("QmitkFileExitAction");
fileMenu->addAction(fileExitAction);
// another bad hack to get an edit/undo menu...
QMenu* editMenu = menuBar->addMenu("&Edit");
undoAction = editMenu->addAction(QIcon::fromTheme("edit-undo",QIcon(":/org_mitk_icons/icons/tango/scalable/actions/edit-undo.svg")),
"&Undo",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onUndo()),
QKeySequence("CTRL+Z"));
undoAction->setToolTip("Undo the last action (not supported by all modules)");
redoAction = editMenu->addAction(QIcon::fromTheme("edit-redo",QIcon(":/org_mitk_icons/icons/tango/scalable/actions/edit-redo.svg"))
, "&Redo",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onRedo()),
QKeySequence("CTRL+Y"));
redoAction->setToolTip("execute the last action that was undone again (not supported by all modules)");
// ==== Window Menu ==========================
QMenu* windowMenu = menuBar->addMenu("Window");
if (showNewWindowMenuItem)
{
windowMenu->addAction("&New Window", QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onNewWindow()));
windowMenu->addSeparator();
}
QMenu* perspMenu = windowMenu->addMenu("&Open Perspective");
QMenu* viewMenu;
if (showViewMenuItem)
{
viewMenu = windowMenu->addMenu("Show &View");
viewMenu->setObjectName("Show View");
}
windowMenu->addSeparator();
resetPerspAction = windowMenu->addAction("&Reset Perspective",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onResetPerspective()));
if(showClosePerspectiveMenuItem)
closePerspAction = windowMenu->addAction("&Close Perspective", QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onClosePerspective()));
windowMenu->addSeparator();
windowMenu->addAction("&Preferences...",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onEditPreferences()),
QKeySequence("CTRL+P"));
// fill perspective menu
berry::IPerspectiveRegistry* perspRegistry =
window->GetWorkbench()->GetPerspectiveRegistry();
QList<berry::IPerspectiveDescriptor::Pointer> perspectives(
perspRegistry->GetPerspectives());
skip = false;
for (QList<berry::IPerspectiveDescriptor::Pointer>::iterator perspIt =
perspectives.begin(); perspIt != perspectives.end(); ++perspIt)
{
// if perspectiveExcludeList is set, it contains the id-strings of perspectives, which
// should not appear as an menu-entry in the perspective menu
if (perspectiveExcludeList.size() > 0)
{
for (int i=0; i<perspectiveExcludeList.size(); i++)
{
if (perspectiveExcludeList.at(i) == (*perspIt)->GetId())
{
skip = true;
break;
}
}
if (skip)
{
skip = false;
continue;
}
}
QAction* perspAction = new berry::QtOpenPerspectiveAction(window,
*perspIt, perspGroup);
mapPerspIdToAction.insert((*perspIt)->GetId(), perspAction);
}
perspMenu->addActions(perspGroup->actions());
if (showViewMenuItem)
{
for (auto viewAction : viewActions)
{
viewMenu->addAction(viewAction);
}
}
// ===== Help menu ====================================
QMenu* helpMenu = menuBar->addMenu("&Help");
helpMenu->addAction("&Welcome",this, SLOT(onIntro()));
helpMenu->addAction("&Open Help Perspective", this, SLOT(onHelpOpenHelpPerspective()));
helpMenu->addAction("&Context Help",this, SLOT(onHelp()), QKeySequence("F1"));
helpMenu->addAction("&About",this, SLOT(onAbout()));
// =====================================================
}
else
{
//undoAction = new QAction(QIcon::fromTheme("edit-undo",QIcon(":/org_mitk_icons/icons/tango/scalable/actions/edit-undo.svg")),
// "&Undo", nullptr);
undoAction = new QmitkUndoAction(QIcon::fromTheme("edit-undo",QIcon(":/org_mitk_icons/icons/tango/scalable/actions/edit-undo.svg")), nullptr);
undoAction->setShortcut(QKeySequence::Undo);
redoAction = new QmitkRedoAction(QIcon::fromTheme("edit-redo",QIcon(":/org_mitk_icons/icons/tango/scalable/actions/edit-redo.svg")), nullptr);
redoAction->setShortcut(QKeySequence::Redo);
}
// toolbar for showing file open, undo, redo and other main actions
auto mainActionsToolBar = new QToolBar;
mainActionsToolBar->setObjectName("mainActionsToolBar");
mainActionsToolBar->setContextMenuPolicy(Qt::PreventContextMenu);
#ifdef __APPLE__
mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextUnderIcon );
#else
mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextBesideIcon );
#endif
imageNavigatorAction = new QAction(QIcon(":/org.mitk.gui.qt.ext/Slider.png"), "&Image Navigator", nullptr);
bool imageNavigatorViewFound = window->GetWorkbench()->GetViewRegistry()->Find("org.mitk.views.imagenavigator");
if(this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.dicomeditor"))
{
openDicomEditorAction = new QmitkOpenDicomEditorAction(QIcon(":/org.mitk.gui.qt.ext/dcm-icon.png"),window);
}
if (imageNavigatorViewFound)
{
QObject::connect(imageNavigatorAction, SIGNAL(triggered(bool)), QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onImageNavigator()));
imageNavigatorAction->setCheckable(true);
// add part listener for image navigator
imageNavigatorPartListener.reset(new PartListenerForImageNavigator(imageNavigatorAction));
window->GetPartService()->AddPartListener(imageNavigatorPartListener.data());
berry::IViewPart::Pointer imageNavigatorView =
window->GetActivePage()->FindView("org.mitk.views.imagenavigator");
imageNavigatorAction->setChecked(false);
if (imageNavigatorView)
{
bool isImageNavigatorVisible = window->GetActivePage()->IsPartVisible(imageNavigatorView);
if (isImageNavigatorVisible)
imageNavigatorAction->setChecked(true);
}
imageNavigatorAction->setToolTip("Toggle image navigator for navigating through image");
}
viewNavigatorAction = new QAction(QIcon(":/org.mitk.gui.qt.ext/view-manager_48.png"),"&View Navigator", nullptr);
viewNavigatorFound = window->GetWorkbench()->GetViewRegistry()->Find("org.mitk.views.viewnavigatorview");
if (viewNavigatorFound)
{
QObject::connect(viewNavigatorAction, SIGNAL(triggered(bool)), QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onViewNavigator()));
viewNavigatorAction->setCheckable(true);
// add part listener for view navigator
viewNavigatorPartListener.reset(new PartListenerForViewNavigator(viewNavigatorAction));
window->GetPartService()->AddPartListener(viewNavigatorPartListener.data());
berry::IViewPart::Pointer viewnavigatorview =
window->GetActivePage()->FindView("org.mitk.views.viewnavigatorview");
viewNavigatorAction->setChecked(false);
if (viewnavigatorview)
{
bool isViewNavigatorVisible = window->GetActivePage()->IsPartVisible(viewnavigatorview);
if (isViewNavigatorVisible)
viewNavigatorAction->setChecked(true);
}
viewNavigatorAction->setToolTip("Toggle View Navigator");
}
mainActionsToolBar->addAction(fileOpenAction);
mainActionsToolBar->addAction(fileSaveProjectAction);
mainActionsToolBar->addAction(closeProjectAction);
mainActionsToolBar->addAction(undoAction);
mainActionsToolBar->addAction(redoAction);
if(this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.dicomeditor"))
{
mainActionsToolBar->addAction(openDicomEditorAction);
}
if (imageNavigatorViewFound)
{
mainActionsToolBar->addAction(imageNavigatorAction);
}
if (viewNavigatorFound)
{
mainActionsToolBar->addAction(viewNavigatorAction);
}
mainWindow->addToolBar(mainActionsToolBar);
// ==== Perspective Toolbar ==================================
auto qPerspectiveToolbar = new QToolBar;
qPerspectiveToolbar->setObjectName("perspectiveToolBar");
if (showPerspectiveToolbar)
{
qPerspectiveToolbar->addActions(perspGroup->actions());
mainWindow->addToolBar(qPerspectiveToolbar);
}
else
delete qPerspectiveToolbar;
// ==== View Toolbar ==================================
auto qToolbar = new QToolBar;
qToolbar->setObjectName("viewToolBar");
if (showViewToolbar)
{
mainWindow->addToolBar(qToolbar);
for (auto viewAction : viewActions)
{
qToolbar->addAction(viewAction);
}
}
else
delete qToolbar;
QSettings settings(GetQSettingsFile(), QSettings::IniFormat);
mainWindow->restoreState(settings.value("ToolbarPosition").toByteArray());
auto qStatusBar = new QStatusBar();
//creating a QmitkStatusBar for Output on the QStatusBar and connecting it with the MainStatusBar
auto statusBar = new QmitkStatusBar(qStatusBar);
//disabling the SizeGrip in the lower right corner
statusBar->SetSizeGripEnabled(false);
auto progBar = new QmitkProgressBar();
qStatusBar->addPermanentWidget(progBar, 0);
progBar->hide();
// progBar->AddStepsToDo(2);
// progBar->Progress(1);
mainWindow->setStatusBar(qStatusBar);
if (showMemoryIndicator)
{
auto memoryIndicator = new QmitkMemoryUsageIndicatorView();
qStatusBar->addPermanentWidget(memoryIndicator, 0);
}
}
void RackWindow::createToolBars()
{
//main toolbar actions:
QAction *fullscreenAct = new QAction(tr("Fullscreen"), this);
fullscreenAct->setCheckable(true);
QAction *enterSettingsAct = new QAction(tr("Change Widget Layout"), this);
QAction *quitAct = new QAction(tr("Quit"), this);
//main toolbar menus:
QMenu *mainMenu = new QMenu(this);
mainMenu->setObjectName("rackMainMenu");
QAction *titleAct = new QAction(tr("R.A.C.K."),this);
titleAct->setDisabled(true);
mainMenu->addAction(titleAct);
mainMenu->setDefaultAction(titleAct);
mainMenu->addAction(fullscreenAct);
mainMenu->addAction(enterSettingsAct);
mainMenu->addAction(quitAct);
//main toolbar buttons:
RPushButton *settingsButton = new RPushButton(tr("Menu"));
settingsButton->setObjectName("rackSettingsButton");
settingsButton->setMenu(mainMenu);
RBlinkButton *deleteButton = new RBlinkButton(tr("Delete"));
deleteButton->setObjectName("rackDeleteButton");
RBlinkButton *previewButton = new RBlinkButton(tr("Preview"));
previewButton->setObjectName("rackPreviewButton");
//main toolbar:
QToolBar *mainToolBar = new QToolBar;
mainToolBar->setObjectName("rackMainToolBar");
mainToolBar->setMovable(false);
mainToolBar->addWidget(settingsButton);
mainToolBar->addWidget(deleteButton);
mainToolBar->addWidget(previewButton);
//delete state:
QObject::connect(deleteButton, SIGNAL(clicked()), m_coreImpl, SLOT(toggleDeleteState()));
QObject::connect(m_coreImpl, SIGNAL(deleteStateChanged(bool)), deleteButton, SLOT(setBlinking(bool)));
//preview state:
QObject::connect(previewButton, SIGNAL(clicked()), m_coreImpl, SLOT(togglePreviewState()));
QObject::connect(m_coreImpl, SIGNAL(previewStateChanged(bool)), previewButton, SLOT(setBlinking(bool)));
//normal state:
QObject::connect(this, SIGNAL(enterSettingsMode()), m_coreImpl, SLOT(setNormalState()));
//main toolbar signals & slots:
QObject::connect(fullscreenAct, SIGNAL(triggered(bool)), this, SLOT(toggleFullscreen()));
QObject::connect(enterSettingsAct, SIGNAL(triggered()), SIGNAL(enterSettingsMode()));
QObject::connect(quitAct, SIGNAL(triggered()), this, SLOT(close()));
QObject::connect(this, SIGNAL(enterSettingsMode()), mainToolBar, SLOT(hide()));
QObject::connect(this, SIGNAL(leaveSettingsMode()), mainToolBar, SLOT(show()));
/////////////////////////save tests
QAction *saveAct = new QAction(tr("Save"), this);
mainMenu->addAction(saveAct);
QObject::connect(saveAct, SIGNAL(triggered()), this, SLOT(savePluginHosts()));
////////////////////////////
/////////////////////////style sheet load
QAction *styleAct = new QAction(tr("Load Style Sheet"), this);
mainMenu->addAction(styleAct);
QObject::connect(styleAct, SIGNAL(triggered()), this, SLOT(openStyleSheet()));
////////////////////////////
/////////////////////////style sheet reload
QAction *restyleAct = new QAction(tr("Reload Style Sheet"), this);
mainMenu->addAction(restyleAct);
QObject::connect(restyleAct, SIGNAL(triggered()), this, SLOT(loadStyleSheet()));
////////////////////////////
//settings toolbar buttons:
RPushButton *settingsOKButton = new RPushButton(tr("OK"));
settingsOKButton->setObjectName("rackSettingsOKButton");
RPushButton *settingsCancelButton = new RPushButton(tr("Cancel"));
settingsCancelButton->setObjectName("rackSettingsCancelButton");
//settings toolbar:
QToolBar *settingsToolBar = new QToolBar;
settingsToolBar->setObjectName("rackSettingsToolBar");
settingsToolBar->setMovable(false);
settingsToolBar->addWidget(settingsOKButton);
settingsToolBar->addWidget(settingsCancelButton);
//settings toolbar signals & slots:
QObject::connect(settingsOKButton, SIGNAL(clicked()), SIGNAL(leaveSettingsMode()));
QObject::connect(this, SIGNAL(enterSettingsMode()), settingsToolBar, SLOT(show()));
QObject::connect(this, SIGNAL(leaveSettingsMode()), settingsToolBar, SLOT(hide()));
//add toolbars to mainwindow:
addToolBar(Qt::BottomToolBarArea, mainToolBar);
addToolBar(Qt::BottomToolBarArea, settingsToolBar);
}
void MainWindow::menuBookmarksAboutToShow()
{
QMenu *menu = qobject_cast<QMenu*>(sender());
if (!menu || !menu->menuAction())
{
return;
}
menu->setObjectName(QLatin1String("bookmarks"));
menu->installEventFilter(this);
const int folder = menu->menuAction()->data().toInt();
if ((folder == 0 && menu->actions().count() == 3) || (folder != 0 && menu->actions().isEmpty()))
{
WebBackend *backend = WebBackendsManager::getBackend();
const QList<BookmarkInformation*> bookmarks = BookmarksManager::getFolder(folder);
if (folder != 0 && bookmarks.count() > 1)
{
QAction *openAllAction = menu->addAction(Utils::getIcon(QLatin1String("document-open-folder")), tr("Open All"));
openAllAction->setData(folder);
connect(openAllAction, SIGNAL(triggered()), this, SLOT(actionOpenBookmarkFolder()));
menu->addSeparator();
}
for (int i = 0; i < bookmarks.count(); ++i)
{
if (bookmarks.at(i)->type == FolderBookmark || bookmarks.at(i)->type == UrlBookmark)
{
QAction *action = menu->addAction(((bookmarks.at(i)->type == FolderBookmark) ? Utils::getIcon(QLatin1String("inode-directory")) : backend->getIconForUrl(QUrl(bookmarks.at(i)->url))), (bookmarks.at(i)->title.isEmpty() ? tr("(Untitled)") : Utils::elideText(QString(bookmarks.at(i)->title).replace(QLatin1Char('&'), QLatin1String("&&")), menu)));
action->setToolTip(bookmarks.at(i)->description);
if (bookmarks.at(i)->type == FolderBookmark)
{
action->setData(bookmarks.at(i)->identifier);
if (!bookmarks.at(i)->children.isEmpty())
{
action->setMenu(new QMenu());
connect(action->menu(), SIGNAL(aboutToShow()), this, SLOT(menuBookmarksAboutToShow()));
}
}
else
{
action->setData(bookmarks.at(i)->url);
connect(action, SIGNAL(triggered()), this, SLOT(actionOpenBookmark()));
}
}
else
{
menu->addSeparator();
}
}
}
}
QWidget* WidgetStyle::createWidget(const QString& name)
{
if(name == "CheckBox")
{
QCheckBox* box = new QCheckBox("CheckBox");
box->setObjectName("CheckBox");
return setLayoutWidget({ box }, { 100, 30 });
}
else if(name == "ComboBox")
{
QComboBox* box = new QComboBox;
box->addItem("Item1");
box->addItem("Item3");
box->addItem("Item3");
box->setObjectName("ComboBox");
return setLayoutWidget({ box }, { 70, 30 });
}
else if(name == "DateEdit")
{
QDateEdit* date = new QDateEdit;
date->setObjectName("DateEdit");
return setLayoutWidget({ date }, { 110, 40 });
}
else if(name == "DateTimeEdit")
{
QDateTimeEdit* date = new QDateTimeEdit;
date->setObjectName("DateTimeEdit");
return setLayoutWidget({ date }, { 160, 30 });
}
else if(name == "Dialog")
{
QDialog* dialog = new QDialog;
dialog->setObjectName("Dialog");
return setLayoutWidget({ dialog }, { 160, 110 });
}
else if(name == "DockWidget") //?
{
QDockWidget* widget = new QDockWidget;
widget->setObjectName("DockWidget");
widget->resize(61, 22);
return widget;
}
else if(name == "DoubleSpinBox")
{
QDoubleSpinBox* box = new QDoubleSpinBox;
box->setObjectName("DoubleSpinBox");
return setLayoutWidget({ box }, { 90, 40 });
}
else if(name == "Frame") //??
{
QFrame* frame = new QFrame;
frame->setObjectName("Frame");
frame->resize(150, 100);
return frame;
}
else if(name == "GroupBox")
{
QGroupBox* box = new QGroupBox("GroupBox");
box->setObjectName("GroupBox");
return setLayoutWidget({ box }, { 160, 110 });
}
else if(name == "Label")
{
QLabel* label = new QLabel("Label");
label->setObjectName("Label");
return setLayoutWidget({ label }, { 40, 20});
}
else if(name == "LineEdit")
{
QLineEdit* line = new QLineEdit;
line->setObjectName("LineEdit");
return setLayoutWidget({ line }, { 30, 30 });
}
else if(name == "ListView") //??
{
QListView* view = new QListView;
view->setObjectName("ListView");
view->resize(71, 71);
return view;
}
else if(name == "ListWidget")
{
QListWidget* list = new QListWidget;
list->setObjectName("ListWidget");
for(int i = 0; i < 20; i++)
list->addItem(QString("Item %1").arg(i));
return setLayoutWidget({ list }, { 80, 80 });
}
else if(name == "MainWindow")
{
QMainWindow* window = new QMainWindow;
window->setObjectName("MainWindow");
return setLayoutWidget({ window }, { 160, 110 });
}
else if(name == "Menu")
{
QMenu* parentMenu = new QMenu;
parentMenu->setObjectName("Menu");
parentMenu->addMenu("Menu1");
QMenu* menu1 = parentMenu->addMenu("Menu2");
menu1->addMenu("Menu1");
menu1->addMenu("Menu2");
parentMenu->addSeparator();
parentMenu->addMenu("Menu3");
return setLayoutWidget({ parentMenu }, { 160, 110 });
}
else if(name == "MenuBar")
{
QMenuBar* bar = new QMenuBar;
bar->setObjectName("QMenuBar");
QMenu* menu1 = bar->addMenu("MenuBar1");
menu1->addMenu("Menu1");
menu1->addSeparator();
menu1->addMenu("Menu2");
QMenu* menu2 = bar->addMenu("MenuBar2");
menu2->addMenu("Menu1");
menu2->addSeparator();
menu2->addMenu("Menu2");
QMenu* menu3 = bar->addMenu("MenuBar3");
menu3->addMenu("Menu1");
menu3->addSeparator();
menu3->addMenu("Menu2");
return setLayoutWidget({ bar }, { 280, 60 });
}
else if(name == "ProgressBar")
{
QProgressBar* bar = new QProgressBar;
bar->setObjectName("ProgressBar");
bar->setRange(0, 100);
bar->setValue(0);
QTimer* timer = new QTimer(bar);
this->connect(timer, &QTimer::timeout, this, [bar]()
{
if(bar->value() == 100)
bar->setValue(0);
else
bar->setValue(bar->value() + 1);
});
timer->start(100);
return setLayoutWidget({ bar }, { 110, 30 });
}
else if(name == "PushButton")
{
QPushButton* button = new QPushButton("PushButton");
button->setObjectName("PushButton");
return setLayoutWidget({ button }, { 125, 30 });
}
else if(name == "RadioButton")
{
QRadioButton* button = new QRadioButton("RadioButton");
button->setObjectName("RadioButton");
return setLayoutWidget({ button }, { 125, 30 });
}
else if(name == "ScrollBar")
{
QScrollBar* barH = new QScrollBar(Qt::Horizontal);
QScrollBar* barV = new QScrollBar(Qt::Vertical);
barH->setObjectName("ScrollBarH");
barV->setObjectName("ScrollBarV");
return setLayoutWidget({ barH, barV }, { 200, 100 });
}
else if(name == "Slider")
{
QSlider* sliderH = new QSlider(Qt::Horizontal);
QSlider* sliderV = new QSlider(Qt::Vertical);
sliderH->setObjectName("SliderH");
sliderV->setObjectName("SliderV");
return setLayoutWidget({ sliderH, sliderV }, { 200, 100 });
}
else if(name == "SpinBox")
{
QSpinBox* spinBox = new QSpinBox;
spinBox->setObjectName("SpinBox");
return setLayoutWidget({ spinBox }, { 60, 35 });
}
else if(name == "Splitter")
{
QSplitter* splitterV = new QSplitter(Qt::Vertical);
QSplitter* splitterH = new QSplitter(Qt::Horizontal);
splitterV->setObjectName("SplitterV");
splitterH->setObjectName("SplitterH");
splitterV->addWidget(new QPushButton("PushButton1"));
splitterV->addWidget(new QPushButton("PushButton2"));
splitterH->addWidget(splitterV);
splitterH->addWidget(new QPushButton("PushButton3"));
return setLayoutWidget({ splitterH }, { 250, 110 });
}
else if(name == "TabWidget")
{
QTabWidget* tab = new QTabWidget;
tab->addTab(new QWidget, "Widget1");
tab->addTab(new QWidget, "Widget2");
tab->addTab(new QWidget, "Widget3");
tab->setObjectName("TabWidget");
return setLayoutWidget({ tab }, { 210, 110 });
}
else if(name == "TableView") //?
{
QTableView* view = new QTableView;
view->setObjectName("TableView");
view->resize(200, 100);
return view;
}
else if(name == "TableWidget")
{
const int n = 100;
QStringList list = { "one", "two", "three" };
QTableWidget* table = new QTableWidget(n, n);
table->setObjectName("TableWidget");
table->setHorizontalHeaderLabels(list);
table->setVerticalHeaderLabels(list);
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
table->setItem(i, j, new QTableWidgetItem(QString("%1, %2").arg(i).arg(j)));
return setLayoutWidget({ table }, { 210, 110 });
}
else if(name == "TextEdit")
{
QTextEdit* text = new QTextEdit;
text->setObjectName("TextEdit");
return setLayoutWidget({ text }, { 80, 80 });
}
else if(name == "TimeEdit")
{
QTimeEdit* time = new QTimeEdit;
time->setObjectName("TimeEdit");
return setLayoutWidget({ time }, { 80, 80 });
}
else if(name == "ToolButton")
{
QToolButton* button = new QToolButton;
button->setText("ToolButton");
button->setObjectName("ToolButton");
return setLayoutWidget({ button }, { 95, 25 });
}
else if(name == "ToolBox")
{
QToolBox* box = new QToolBox;
box->addItem(new QWidget, "Widget1");
box->addItem(new QWidget, "Widget2");
box->addItem(new QWidget, "Widget3");
box->setObjectName("ToolBox");
return setLayoutWidget({ box }, { 110, 180 });
}
else if(name == "TreeView") //?
{
QTreeView* tree = new QTreeView;
tree->setObjectName("TreeView");
tree->resize(200, 100);
return tree;
}
else if(name == "TreeWidget")
{
QTreeWidget* tree = new QTreeWidget;
tree->setObjectName("TreeWidget");
tree->setHeaderLabels({ "Folders", "Used Space" });
QTreeWidgetItem* item = new QTreeWidgetItem(tree);
item->setText(0, "Local Disk");
for(int i = 1; i < 20; i++)
{
QTreeWidgetItem* dir = new QTreeWidgetItem(item);
dir->setText(0, "Directory" + QString::number(i));
dir->setText(1, QString::number(i) + "MB");
}
tree->setItemExpanded(item, true);
return setLayoutWidget({ tree }, { 210, 110 });
}
else if(name == "Widget")
{
QWidget* widget = new QWidget;
widget->setObjectName("Widget");
return setLayoutWidget({ widget }, { 210, 110 });
}
return nullptr;
}
void QSofaListView::RunSofaRightClicked( const QPoint& point)
{
QTreeWidgetItem *item = this->itemAt( point );
if( item == NULL) return;
updateMatchingObjectmodel(item);
QAction* act;
bool object_hasData = false;
if(object_.type == typeObject)
{
object_hasData = object_.ptr.Object->getDataFields().size() > 0 ? true : false;
}
QMenu *contextMenu = new QMenu ( this );
contextMenu->setObjectName( "ContextMenu");
if( object_.isNode() )
{
act = contextMenu->addAction("Focus", this,SLOT(focusNode()));
bool enable = object_.ptr.Node->f_bbox.getValue().isValid() && !object_.ptr.Node->f_bbox.getValue().isFlat();
act->setEnabled(enable);
}
if( object_.isObject() )
{
act = contextMenu->addAction("Focus", this,SLOT(focusObject()));
bool enable = object_.ptr.Object->f_bbox.getValue().isValid() && !object_.ptr.Object->f_bbox.getValue().isFlat() ;
act->setEnabled(enable);
}
contextMenu->addSeparator();
//Creation of the context Menu
if ( object_.type == typeNode)
{
act = contextMenu->addAction("Collapse", this,SLOT(collapseNode()));
act = contextMenu->addAction("Expand", this,SLOT(expandNode()));
contextMenu->addSeparator();
/*****************************************************************************************************************/
if (object_.ptr.Node->isActive())
{
act = contextMenu->addAction("Deactivate", this,SLOT(DeactivateNode()));
}
else
{
act = contextMenu->addAction("Activate", this,SLOT(ActivateNode()));
}
if (object_.ptr.Node->isSleeping())
{
act = contextMenu->addAction("Wake up", this,SLOT(WakeUpNode()));
}
else
{
act = contextMenu->addAction("Put to sleep", this,SLOT(PutNodeToSleep()));
}
contextMenu->addSeparator();
/*****************************************************************************************************************/
act = contextMenu->addAction("Save Node", this,SLOT(SaveNode()));
act = contextMenu->addAction("Export OBJ", this,SLOT(exportOBJ()));
if ( attribute_ == SIMULATION)
{
act = contextMenu->addAction("Add Node", this,SLOT(RaiseAddObject()));
act = contextMenu->addAction("Remove Node", this,SLOT(RemoveNode()));
//If one of the elements or child of the current node is beeing modified, you cannot allow the user to erase the node
if ( !isNodeErasable ( object_.ptr.Node ) )
{
act->setEnabled(false);
}
}
}
act = contextMenu->addAction("Modify", this,SLOT(Modify()));
if(object_hasData)
{
if(item->childCount() > 0)
{
act = contextMenu->addAction("Hide Data", this,SLOT(HideDatas()));
}
else
{
act = contextMenu->addAction("Show Data", this,SLOT(ShowDatas()));
}
}
contextMenu->addSeparator();
act = contextMenu->addAction("Copy file path", this,SLOT(copyFilePathToClipBoard()));
act = contextMenu->addAction("Open file in editor", this,SLOT(openInEditor()));
contextMenu->exec ( this->mapToGlobal(point) /*, index */);
}
void setupUi(QMainWindow *MainWindow)
{
if (MainWindow->objectName().isEmpty())
MainWindow->setObjectName(QString::fromUtf8("MainWindow"));
MainWindow->resize(999, 913);
actionAbout = new QAction(MainWindow);
actionAbout->setObjectName(QString::fromUtf8("actionAbout"));
actionAtlas = new QAction(MainWindow);
actionAtlas->setObjectName(QString::fromUtf8("actionAtlas"));
actionMapping = new QAction(MainWindow);
actionMapping->setObjectName(QString::fromUtf8("actionMapping"));
actionLibrary = new QAction(MainWindow);
actionLibrary->setObjectName(QString::fromUtf8("actionLibrary"));
actionToolbox = new QAction(MainWindow);
actionToolbox->setObjectName(QString::fromUtf8("actionToolbox"));
centralwidget = new QWidget(MainWindow);
centralwidget->setObjectName(QString::fromUtf8("centralwidget"));
gridLayout = new QGridLayout(centralwidget);
gridLayout->setObjectName(QString::fromUtf8("gridLayout"));
mainSizer = new QGridLayout();
mainSizer->setObjectName(QString::fromUtf8("mainSizer"));
mainSizer->setVerticalSpacing(14);
mainSizer->setContentsMargins(0, -1, -1, -1);
renderFrame = new QFrame(centralwidget);
renderFrame->setObjectName(QString::fromUtf8("renderFrame"));
renderFrame->setMinimumSize(QSize(800, 600));
renderFrame->setFrameShape(QFrame::Box);
renderFrame->setFrameShadow(QFrame::Raised);
mainSizer->addWidget(renderFrame, 0, 0, 1, 1);
gridLayout->addLayout(mainSizer, 0, 0, 1, 1);
MainWindow->setCentralWidget(centralwidget);
menubar = new QMenuBar(MainWindow);
menubar->setObjectName(QString::fromUtf8("menubar"));
menubar->setGeometry(QRect(0, 0, 999, 21));
menuFile = new QMenu(menubar);
menuFile->setObjectName(QString::fromUtf8("menuFile"));
menuTools = new QMenu(menubar);
menuTools->setObjectName(QString::fromUtf8("menuTools"));
menuAbout = new QMenu(menubar);
menuAbout->setObjectName(QString::fromUtf8("menuAbout"));
menuWindows = new QMenu(menubar);
menuWindows->setObjectName(QString::fromUtf8("menuWindows"));
MainWindow->setMenuBar(menubar);
statusbar = new QStatusBar(MainWindow);
statusbar->setObjectName(QString::fromUtf8("statusbar"));
MainWindow->setStatusBar(statusbar);
menubar->addAction(menuFile->menuAction());
menubar->addAction(menuTools->menuAction());
menubar->addAction(menuWindows->menuAction());
menubar->addAction(menuAbout->menuAction());
menuTools->addAction(actionAtlas);
menuTools->addAction(actionMapping);
menuAbout->addAction(actionAbout);
menuWindows->addAction(actionLibrary);
menuWindows->addAction(actionToolbox);
retranslateUi(MainWindow);
QMetaObject::connectSlotsByName(MainWindow);
} // setupUi