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;
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
// Setup this MainWindow with the parameters mainwindow.ui:
// Definition of size, creation of widgets inside etc..
ui->setupUi(this);
// Retrieve pointers of widgets already created by the up operation
// Those who will be used again outside the creator are saved at class variables
QMenuBar * menuBar = ui->menuBar;
QSlider *slider_color = ui->verticalSlider;
QSlider *slider_style = ui->verticalSlider_2;
QToolBar * toolbar = ui->toolBar;
mydrawzone = ui->widget;
// Declaration of menus and adition inside menubar
QMenu * openMenu = menuBar->addMenu( tr("&Open"));
QMenu * saveMenu = menuBar->addMenu( tr("&Save"));
QMenu * quitMenu = menuBar->addMenu( tr("&Quit"));
QMenu * penMenu = menuBar->addMenu( tr("&Pen Settings"));
QMenu * colorMenu = menuBar->addMenu( tr("&Color Settings"));
QMenu * styleMenu = menuBar->addMenu( tr("&Style Settings"));
QMenu * formMenu = menuBar->addMenu( tr("&Form Settings"));
// Declaration of principal actions
// Those that will be shown at the toolbar
QAction * openAction = new QAction( QIcon(":/icons/open.png"), tr("&Open"), this);
QAction * saveAction = new QAction( QIcon(":/icons/save.png"), tr("&Save"), this);
QAction * quitAction = new QAction( QIcon(":/icons/quit.png"), tr("&Quit"), this);
QAction * paintAction = new QAction( QIcon(":/icons/paint.png"), tr("&Paint"), this);
QAction * editAction = new QAction( QIcon(":/icons/edit.png"), tr("&Edit"), this);
QAction * moveAction = new QAction( QIcon(":/icons/move.png"), tr("&Edit"), this);
// Declaration of some other actions
// Those that will have shortcuts as well but wont be shown in the toolbar
QAction *set_pen_color =new QAction(tr("Alternate Color Pen"), this);
QAction *set_pen_width_larger =new QAction(tr("&Pen Width +"), this);
QAction *set_pen_width_shorter =new QAction(tr("&Pen Width -"), this);
QAction *set_pen_style =new QAction(tr("&Alternate Style Pen"), this);
QAction *set_figure_form =new QAction(tr("&Alternate Figure Form"), this);
QAction *undo =new QAction(tr("&Undo"), this);
// Declaration of action groups
// The pointers for the actions are saved inside class variables
// to be used outside the class creator
QActionGroup *action_group_color = new QActionGroup(this);
color0 = action_group_color->addAction(tr("Black Pen"));
color1 = action_group_color->addAction(tr("White Pen"));
color2 = action_group_color->addAction(tr("Dark Gray Pen"));
color3 = action_group_color->addAction(tr("Gray Pen"));
color4 = action_group_color->addAction(tr("Light Gray Pen"));
color5 = action_group_color->addAction(tr("Red Pen"));
color6 = action_group_color->addAction(tr("Green Pen"));
color7 = action_group_color->addAction(tr("Blue Pen"));
color8 = action_group_color->addAction(tr("Cyan Pen"));
color9 = action_group_color->addAction(tr("Magenta Pen"));
color10 = action_group_color->addAction(tr("Yellow Pen"));
color11 = action_group_color->addAction(tr("Dark Red Pen"));
color12 = action_group_color->addAction(tr("Dark Green Pen"));
color13 = action_group_color->addAction(tr("Dark Blue Pen"));
color14 = action_group_color->addAction(tr("Dark Cyan Pen"));
color15 = action_group_color->addAction(tr("Dark Magenta Pen"));
color16 = action_group_color->addAction(tr("Dark Yellow Pen"));
color17 = action_group_color->addAction(tr("Transparent"));
QActionGroup *action_group_style = new QActionGroup(this);
style0 = action_group_style->addAction(tr("Solid Pen"));
style1 = action_group_style->addAction(tr("Dash Line Pen"));
style2 = action_group_style->addAction(tr("Dot Line Pen"));
style3 = action_group_style->addAction(tr("Dash dot Line Pen"));
style4 = action_group_style->addAction(tr("Dash Dot Dot Line Pen"));
style5 = action_group_style->addAction(tr("Custom Dash Line Pen"));
QActionGroup *action_group_form = new QActionGroup(this);
form0 = action_group_form->addAction(tr("Line Form"));
form1 = action_group_form->addAction(tr("Rectangle Form"));
form2 = action_group_form->addAction(tr("Elipse Form"));
// Adition of shortcuts for principal actions
openAction->setShortcut( tr("Ctrl+O"));
saveAction->setShortcut( tr("Ctrl+S"));
quitAction->setShortcut( tr("Ctrl+Q"));
paintAction->setShortcut( tr("Ctrl+P"));
editAction->setShortcut( tr("Ctrl+E"));
moveAction->setShortcut( tr("Ctrl+M"));
// Adition of shortcuts for those other actions
set_pen_color->setShortcut( tr("Ctrl+C"));
set_pen_style->setShortcut( tr("Ctrl+Space"));
set_pen_width_larger->setShortcut( tr("Ctrl++"));
set_pen_width_shorter->setShortcut( tr("Ctrl+-"));
set_figure_form->setShortcut( tr("Ctrl+F"));
undo->setShortcut(tr ("Ctrl+Z"));
// Adition of tool tips for principal actions
openAction->setToolTip( tr("Open file"));
saveAction->setToolTip( tr("Save file"));
quitAction->setToolTip( tr("Quit file"));
// Adition of status tips for principal actions
openAction->setStatusTip( tr("Open file"));
saveAction->setStatusTip( tr("Save file"));
quitAction->setStatusTip( tr("Quit file"));
// Adition of actions to menus
openMenu->addAction(openAction);
saveMenu->addAction(saveAction);
quitMenu->addAction(quitAction);
penMenu->addAction(set_pen_width_larger);
penMenu->addAction(set_pen_width_shorter);
penMenu->addAction(undo);
colorMenu->addAction(set_pen_color);
colorMenu->addActions(action_group_color->actions());
styleMenu->addAction(set_pen_style);
styleMenu->addActions(action_group_style->actions());
formMenu->addAction(set_figure_form);
formMenu->addActions(action_group_form->actions());
// Adition of principal actions to toolbar
toolbar->addAction(openAction);
toolbar->addAction(saveAction);
toolbar->addAction(quitAction);
toolbar->addAction(paintAction);
toolbar->addAction(editAction);
toolbar->addAction(moveAction);
// Set some parameters to the sliders
slider_color->setTickPosition(QSlider::TicksBothSides);
slider_color->setMinimum(0);
slider_color->setMaximum(17);
slider_color->setSingleStep(1);
slider_style->setTickPosition(QSlider::TicksBothSides);
slider_style->setMinimum(0);
slider_style->setMaximum(5);
slider_style->setSingleStep(1);
// Link actions and signals to slots
connect(openAction, SIGNAL(triggered( )), this, SLOT(openFile()));
connect(saveAction, SIGNAL(triggered( )), this, SLOT(saveFile()));
connect(quitAction, SIGNAL(triggered( )), this, SLOT(quitApp()));
connect(paintAction, SIGNAL(triggered( )), mydrawzone, SLOT(set_draw_mode_paint()));
connect(editAction, SIGNAL(triggered( )), mydrawzone, SLOT(set_draw_mode_edit()));
connect(moveAction, SIGNAL(triggered( )), mydrawzone, SLOT(set_draw_mode_move()));
connect(set_pen_width_larger, SIGNAL(triggered( )), mydrawzone, SLOT(set_pen_width_larger()));
connect(set_pen_width_shorter, SIGNAL(triggered( )), mydrawzone, SLOT(set_pen_width_shorter()));
connect(undo, SIGNAL(triggered( )), mydrawzone, SLOT(undo()));
connect(set_pen_color, SIGNAL(triggered( )), mydrawzone, SLOT(set_pen_color()));
connect(action_group_color, SIGNAL(triggered(QAction *)), this, SLOT(doIt(QAction *)));
connect(this, SIGNAL(color_pen_changed(int)), mydrawzone, SLOT(set_pen_color(int)));
connect(set_pen_style, SIGNAL(triggered( )), mydrawzone, SLOT(set_pen_style()));
connect(action_group_style, SIGNAL(triggered(QAction *)), this, SLOT(doIt2(QAction *)));
connect(this, SIGNAL(style_pen_changed(int)), mydrawzone, SLOT(set_pen_style(int)));
connect(set_figure_form, SIGNAL(triggered( )), mydrawzone, SLOT(set_figure_form()));
connect(action_group_form, SIGNAL(triggered(QAction *)), this, SLOT(doIt3(QAction *)));
connect(this, SIGNAL(form_painter_changed(int)), mydrawzone, SLOT(set_figure_form(int)));
connect(slider_color, SIGNAL(valueChanged(int)), this, SLOT(slide_color_pen_changed(int)));
connect(slider_style, SIGNAL(valueChanged(int)), this, SLOT(slide_style_pen_changed(int)));
}
void ProgramWindow::setup()
{
if (parentWidget() == NULL) {
resize(500,700);
setAttribute(Qt::WA_DeleteOnClose, true);
}
QFrame * mainFrame = new QFrame(this);
QFrame * headerFrame = createHeader();
QFrame * centerFrame = createCenter();
layout()->setMargin(0);
layout()->setSpacing(0);
QGridLayout *layout = new QGridLayout(mainFrame);
layout->setMargin(0);
layout->setSpacing(0);
layout->addWidget(headerFrame,0,0);
layout->addWidget(centerFrame,1,0);
setCentralWidget(mainFrame);
setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
QSettings settings;
if (!settings.value("programwindow/state").isNull()) {
restoreState(settings.value("programwindow/state").toByteArray());
}
if (!settings.value("programwindow/geometry").isNull()) {
restoreGeometry(settings.value("programwindow/geometry").toByteArray());
}
installEventFilter(this);
// Setup new menu bar for the programming window
QMenuBar * menubar = NULL;
if (parentWidget()) {
QMainWindow * mainWindow = qobject_cast<QMainWindow *>(parentWidget());
if (mainWindow) menubar = mainWindow->menuBar();
}
if (menubar == NULL) menubar = menuBar();
m_fileMenu = menubar->addMenu(tr("&File"));
QAction *currentAction = new QAction(tr("New Code File"), this);
currentAction->setShortcut(tr("Ctrl+N"));
currentAction->setStatusTip(tr("Create a new program"));
connect(currentAction, SIGNAL(triggered()), this, SLOT(addTab()));
m_fileMenu->addAction(currentAction);
currentAction = new QAction(tr("&Open Code File..."), this);
currentAction->setShortcut(tr("Ctrl+O"));
currentAction->setStatusTip(tr("Open a program"));
connect(currentAction, SIGNAL(triggered()), this, SLOT(loadProgramFile()));
m_fileMenu->addAction(currentAction);
m_fileMenu->addSeparator();
m_saveAction = new QAction(tr("&Save Code File"), this);
m_saveAction->setShortcut(tr("Ctrl+S"));
m_saveAction->setStatusTip(tr("Save the current program"));
connect(m_saveAction, SIGNAL(triggered()), this, SLOT(save()));
m_fileMenu->addAction(m_saveAction);
currentAction = new QAction(tr("Rename Code File"), this);
currentAction->setStatusTip(tr("Rename the current program"));
connect(currentAction, SIGNAL(triggered()), this, SLOT(rename()));
m_fileMenu->addAction(currentAction);
currentAction = new QAction(tr("Duplicate tab"), this);
currentAction->setStatusTip(tr("Copies the current program into a new tab"));
connect(currentAction, SIGNAL(triggered()), this, SLOT(duplicateTab()));
m_fileMenu->addAction(currentAction);
m_fileMenu->addSeparator();
currentAction = new QAction(tr("Remove tab"), this);
currentAction->setShortcut(tr("Ctrl+W"));
currentAction->setStatusTip(tr("Remove the current program from the sketch"));
connect(currentAction, SIGNAL(triggered()), this, SLOT(closeCurrentTab()));
m_fileMenu->addAction(currentAction);
m_fileMenu->addSeparator();
m_printAction = new QAction(tr("&Print..."), this);
m_printAction->setShortcut(tr("Ctrl+P"));
m_printAction->setStatusTip(tr("Print the current program"));
connect(m_printAction, SIGNAL(triggered()), this, SLOT(print()));
m_fileMenu->addAction(m_printAction);
m_fileMenu->addSeparator();
currentAction = new QAction(tr("&Quit"), this);
currentAction->setShortcut(tr("Ctrl+Q"));
currentAction->setStatusTip(tr("Quit the application"));
currentAction->setMenuRole(QAction::QuitRole);
connect(currentAction, SIGNAL(triggered()), qApp, SLOT(closeAllWindows2()));
m_fileMenu->addAction(currentAction);
m_editMenu = menubar->addMenu(tr("&Edit"));
m_undoAction = new QAction(tr("Undo"), this);
m_undoAction->setShortcuts(QKeySequence::Undo);
m_undoAction->setEnabled(false);
connect(m_undoAction, SIGNAL(triggered()), this, SLOT(undo()));
m_editMenu->addAction(m_undoAction);
m_redoAction = new QAction(tr("Redo"), this);
m_redoAction->setShortcuts(QKeySequence::Redo);
m_redoAction->setEnabled(false);
connect(m_redoAction, SIGNAL(triggered()), this, SLOT(redo()));
m_editMenu->addAction(m_redoAction);
m_editMenu->addSeparator();
m_cutAction = new QAction(tr("&Cut"), this);
m_cutAction->setShortcut(tr("Ctrl+X"));
m_cutAction->setStatusTip(tr("Cut selection"));
m_cutAction->setEnabled(false);
connect(m_cutAction, SIGNAL(triggered()), this, SLOT(cut()));
m_editMenu->addAction(m_cutAction);
m_copyAction = new QAction(tr("&Copy"), this);
m_copyAction->setShortcut(tr("Ctrl+C"));
m_copyAction->setStatusTip(tr("Copy selection"));
m_copyAction->setEnabled(false);
connect(m_copyAction, SIGNAL(triggered()), this, SLOT(copy()));
m_editMenu->addAction(m_copyAction);
currentAction = new QAction(tr("&Paste"), this);
currentAction->setShortcut(tr("Ctrl+V"));
currentAction->setStatusTip(tr("Paste clipboard contents"));
// TODO: Check clipboard status and disable appropriately here
connect(currentAction, SIGNAL(triggered()), this, SLOT(paste()));
m_editMenu->addAction(currentAction);
m_editMenu->addSeparator();
currentAction = new QAction(tr("&Select All"), this);
currentAction->setShortcut(tr("Ctrl+A"));
currentAction->setStatusTip(tr("Select all text"));
connect(currentAction, SIGNAL(triggered()), this, SLOT(selectAll()));
m_editMenu->addAction(currentAction);
m_programMenu = menubar->addMenu(tr("&Code"));
QMenu *languageMenu = new QMenu(tr("Select language"), this);
m_programMenu->addMenu(languageMenu);
QString currentLanguage = settings.value("programwindow/language", "").toString();
QStringList languages = getAvailableLanguages();
QActionGroup *languageActionGroup = new QActionGroup(this);
foreach (QString language, languages) {
currentAction = new QAction(language, this);
currentAction->setCheckable(true);
m_languageActions.insert(language, currentAction);
languageActionGroup->addAction(currentAction);
languageMenu->addAction(currentAction);
if (!currentLanguage.isEmpty()) {
if (language.compare(currentLanguage) == 0) {
currentAction->setChecked(true);
}
}
}
DrawPad::DrawPad(QWidget* parent, const char* name, WFlags /*fl*/ )
: QMainWindow(parent, name, WStyle_ContextHelp)
{
// init members
connect( qApp, SIGNAL(appMessage(const QCString&, const QByteArray&)),
this, SLOT(slotAppMessage(const QCString&, const QByteArray&)) );
m_pDrawPadCanvas = new DrawPadCanvas(this, this);
connect(m_pDrawPadCanvas, SIGNAL(pagesChanged()), this, SLOT(updateView()));
setCentralWidget(m_pDrawPadCanvas);
// init menu
setToolBarsMovable(false);
QToolBar* menuToolBar = new QToolBar(this);
QMenuBar* menuBar = new QMenuBar(menuToolBar);
QPopupMenu* toolsPopupMenu = new QPopupMenu(menuBar);
QAction* deleteAllAction = new QAction(tr("Delete All"), QString::null, 0, this);
connect(deleteAllAction, SIGNAL(activated()), this, SLOT(deleteAll()));
deleteAllAction->addTo(toolsPopupMenu);
toolsPopupMenu->insertSeparator();
QAction* importPageAction = new QAction(tr("Import"), tr("Import..."), 0, this);
connect(importPageAction, SIGNAL(activated()), this, SLOT(importPage()));
importPageAction->addTo(toolsPopupMenu);
QAction* exportPageAction = new QAction(tr("Export"), tr("Export..."), 0, this);
connect(exportPageAction, SIGNAL(activated()), this, SLOT(exportPage()));
exportPageAction->addTo(toolsPopupMenu);
toolsPopupMenu->insertSeparator();
QAction* thumbnailViewAction = new QAction(tr("Thumbnail View"), tr("Thumbnail View..."), 0, this);
connect(thumbnailViewAction, SIGNAL(activated()), this, SLOT(thumbnailView()));
thumbnailViewAction->addTo(toolsPopupMenu);
QAction* pageInformationAction = new QAction(tr("Page Information"), tr("Page Information..."), 0, this);
connect(pageInformationAction, SIGNAL(activated()), this, SLOT(pageInformation()));
pageInformationAction->addTo(toolsPopupMenu);
toolsPopupMenu->insertSeparator();
m_pAntiAliasingAction = new QAction(tr("Anti-Aliasing"), QString::null, 0, this);
m_pAntiAliasingAction->setToggleAction(true);
m_pAntiAliasingAction->addTo(toolsPopupMenu);
menuBar->insertItem(tr("Tools"), toolsPopupMenu);
// init page toolbar
QToolBar* pageToolBar = new QToolBar(this);
QAction* newPageAction = new QAction(tr("New Page"), Opie::Core::OResource::loadPixmap("new", Opie::Core::OResource::SmallIcon),
QString::null, 0, this);
connect(newPageAction, SIGNAL(activated()), this, SLOT(newPage()));
newPageAction->addTo(pageToolBar);
newPageAction->setWhatsThis( tr( "Click here to add a new sheet." ) );
QAction* clearPageAction = new QAction(tr("Clear Page"),
Opie::Core::OResource::loadPixmap("drawpad/clear", Opie::Core::OResource::SmallIcon),
QString::null, 0, this);
connect(clearPageAction, SIGNAL(activated()), this, SLOT(clearPage()));
clearPageAction->addTo(pageToolBar);
clearPageAction->setWhatsThis( tr( "Click here to erase the current sheet." ) );
QAction* deletePageAction = new QAction(tr("Delete Page"),
Opie::Core::OResource::loadPixmap("trash", Opie::Core::OResource::SmallIcon),
QString::null, 0, this);
connect(deletePageAction, SIGNAL(activated()), this, SLOT(deletePage()));
deletePageAction->addTo(pageToolBar);
deletePageAction->setWhatsThis( tr( "Click here to remove the current sheet." ) );
QToolBar* emptyToolBar = new QToolBar(this);
emptyToolBar->setHorizontalStretchable(true);
// init navigation toolbar
QToolBar* navigationToolBar = new QToolBar(this);
m_pUndoAction = new QAction(tr("Undo"), Opie::Core::OResource::loadPixmap("undo", Opie::Core::OResource::SmallIcon),
QString::null, 0, this);
connect(m_pUndoAction, SIGNAL(activated()), m_pDrawPadCanvas, SLOT(undo()));
m_pUndoAction->addTo(navigationToolBar);
m_pUndoAction->setWhatsThis( tr( "Click here to undo the last action." ) );
m_pRedoAction = new QAction(tr("Redo"), Opie::Core::OResource::loadPixmap("redo", Opie::Core::OResource::SmallIcon),
QString::null, 0, this);
connect(m_pRedoAction, SIGNAL(activated()), m_pDrawPadCanvas, SLOT(redo()));
m_pRedoAction->addTo(navigationToolBar);
m_pRedoAction->setWhatsThis( tr( "Click here to re-perform the last action." ) );
m_pFirstPageAction = new QAction(tr("First Page"),
Opie::Core::OResource::loadPixmap("fastback", Opie::Core::OResource::SmallIcon),
QString::null, 0, this);
connect(m_pFirstPageAction, SIGNAL(activated()), m_pDrawPadCanvas, SLOT(goFirstPage()));
m_pFirstPageAction->addTo(navigationToolBar);
m_pFirstPageAction->setWhatsThis( tr( "Click here to view the first page." ) );
m_pPreviousPageAction = new QAction(tr("Previous Page"),
Opie::Core::OResource::loadPixmap("back", Opie::Core::OResource::SmallIcon),
QString::null, 0, this);
connect(m_pPreviousPageAction, SIGNAL(activated()), m_pDrawPadCanvas, SLOT(goPreviousPage()));
m_pPreviousPageAction->addTo(navigationToolBar);
m_pPreviousPageAction->setWhatsThis( tr( "Click here to view the previous page." ) );
m_pNextPageAction = new QAction(tr("Next Page"),
Opie::Core::OResource::loadPixmap("forward", Opie::Core::OResource::SmallIcon),
QString::null, 0, this);
connect(m_pNextPageAction, SIGNAL(activated()), m_pDrawPadCanvas, SLOT(goNextPage()));
m_pNextPageAction->addTo(navigationToolBar);
m_pNextPageAction->setWhatsThis( tr( "Click here to view the next page." ) );
m_pLastPageAction = new QAction(tr("Last Page"),
Opie::Core::OResource::loadPixmap("fastforward", Opie::Core::OResource::SmallIcon),
QString::null, 0, this);
connect(m_pLastPageAction, SIGNAL(activated()), m_pDrawPadCanvas, SLOT(goLastPage()));
m_pLastPageAction->addTo(navigationToolBar);
m_pLastPageAction->setWhatsThis( tr( "Click here to view the last page." ) );
// init draw mode toolbar
QToolBar* drawModeToolBar = new QToolBar(this);
m_pLineToolButton = new QToolButton(drawModeToolBar);
m_pLineToolButton->setToggleButton(true);
QWhatsThis::add( m_pLineToolButton, tr( "Click here to select one of the available tools to draw lines." ) );
QPopupMenu* linePopupMenu = new QPopupMenu(m_pLineToolButton);
m_pPointToolAction = new QAction(tr("Draw Point"),
Opie::Core::OResource::loadPixmap("drawpad/point", Opie::Core::OResource::SmallIcon),
"", 0, this);
connect(m_pPointToolAction, SIGNAL(activated()), this, SLOT(setPointTool()));
m_pPointToolAction->addTo(linePopupMenu);
m_pLineToolAction = new QAction(tr("Draw Line"),
Opie::Core::OResource::loadPixmap("drawpad/line", Opie::Core::OResource::SmallIcon),
"", 0, this);
connect(m_pLineToolAction, SIGNAL(activated()), this, SLOT(setLineTool()));
m_pLineToolAction->addTo(linePopupMenu);
m_pLineToolButton->setPopup(linePopupMenu);
m_pLineToolButton->setPopupDelay(0);
m_pRectangleToolButton = new QToolButton(drawModeToolBar);
m_pRectangleToolButton->setToggleButton(true);
QWhatsThis::add( m_pRectangleToolButton, tr( "Click here to select one of the available tools to draw rectangles." ) );
QPopupMenu* rectanglePopupMenu = new QPopupMenu(m_pRectangleToolButton);
m_pRectangleToolAction = new QAction(tr("Draw Rectangle"),
Opie::Core::OResource::loadPixmap("drawpad/rectangle", Opie::Core::OResource::SmallIcon),
"", 0, this);
connect(m_pRectangleToolAction, SIGNAL(activated()), this, SLOT(setRectangleTool()));
m_pRectangleToolAction->addTo(rectanglePopupMenu);
m_pFilledRectangleToolAction = new QAction(tr("Draw Filled Rectangle"),
Opie::Core::OResource::loadPixmap("drawpad/filledrectangle",
Opie::Core::OResource::SmallIcon), "", 0, this);
connect(m_pFilledRectangleToolAction, SIGNAL(activated()), this, SLOT(setFilledRectangleTool()));
m_pFilledRectangleToolAction->addTo(rectanglePopupMenu);
m_pRectangleToolButton->setPopup(rectanglePopupMenu);
m_pRectangleToolButton->setPopupDelay(0);
m_pEllipseToolButton = new QToolButton(drawModeToolBar);
m_pEllipseToolButton->setToggleButton(true);
QWhatsThis::add( m_pEllipseToolButton, tr( "Click here to select one of the available tools to draw ellipses." ) );
QPopupMenu* ellipsePopupMenu = new QPopupMenu(m_pEllipseToolButton);
m_pEllipseToolAction = new QAction(tr("Draw Ellipse"),
Opie::Core::OResource::loadPixmap("drawpad/ellipse", Opie::Core::OResource::SmallIcon),
"", 0, this);
connect(m_pEllipseToolAction, SIGNAL(activated()), this, SLOT(setEllipseTool()));
m_pEllipseToolAction->addTo(ellipsePopupMenu);
m_pFilledEllipseToolAction = new QAction(tr("Draw Filled Ellipse"),
Opie::Core::OResource::loadPixmap("drawpad/filledellipse",
Opie::Core::OResource::SmallIcon), "", 0, this);
connect(m_pFilledEllipseToolAction, SIGNAL(activated()), this, SLOT(setFilledEllipseTool()));
m_pFilledEllipseToolAction->addTo(ellipsePopupMenu);
m_pEllipseToolButton->setPopup(ellipsePopupMenu);
m_pEllipseToolButton->setPopupDelay(0);
m_pTextToolAction = new QAction(tr("Insert Text"),
Opie::Core::OResource::loadPixmap("drawpad/text", Opie::Core::OResource::SmallIcon),
QString::null, 0, this);
m_pTextToolAction->setToggleAction(true);
connect(m_pTextToolAction, SIGNAL(activated()), this, SLOT(setTextTool()));
m_pTextToolAction->addTo(drawModeToolBar);
m_pTextToolAction->setWhatsThis( tr( "Click here to select the text drawing tool." ) );
m_pFillToolAction = new QAction(tr("Fill Region"),
Opie::Core::OResource::loadPixmap("drawpad/fill", Opie::Core::OResource::SmallIcon),
QString::null, 0, this);
m_pFillToolAction->setToggleAction(true);
connect(m_pFillToolAction, SIGNAL(activated()), this, SLOT(setFillTool()));
m_pFillToolAction->addTo(drawModeToolBar);
m_pFillToolAction->setWhatsThis( tr( "Click here to select the fill tool." ) );
m_pEraseToolAction = new QAction(tr("Erase Point"),
Opie::Core::OResource::loadPixmap("drawpad/erase", Opie::Core::OResource::SmallIcon),
QString::null, 0, this);
m_pEraseToolAction->setToggleAction(true);
connect(m_pEraseToolAction, SIGNAL(activated()), this, SLOT(setEraseTool()));
m_pEraseToolAction->addTo(drawModeToolBar);
m_pEraseToolAction->setWhatsThis( tr( "Click here to select the eraser tool." ) );
m_pTool = 0;
setRectangleTool();
setEllipseTool();
setPointTool();
emptyToolBar = new QToolBar(this);
emptyToolBar->setHorizontalStretchable(true);
emptyToolBar->addSeparator();
// init draw parameters toolbar
QToolBar* drawParametersToolBar = new QToolBar(this);
m_pPenWidthSpinBox = new QSpinBox(1, 9, 1, drawParametersToolBar);
connect(m_pPenWidthSpinBox, SIGNAL(valueChanged(int)), this, SLOT(changePenWidth(int)));
QToolTip::add(m_pPenWidthSpinBox, tr("Pen Width"));
m_pPenWidthSpinBox->setValue(1);
m_pPenWidthSpinBox->setFocusPolicy(QWidget::NoFocus);
QWhatsThis::add( m_pPenWidthSpinBox, tr( "Click here to select the width of the drawing pen." ) );
bool useBigIcon = qApp->desktop()->size().width() > 330;
m_pPenColorToolButton = new QToolButton(drawParametersToolBar);
m_pPenColorToolButton->setUsesBigPixmap( useBigIcon );
m_pPenColorToolButton->setPixmap(Opie::Core::OResource::loadPixmap("drawpad/pencolor", Opie::Core::OResource::SmallIcon));
QWhatsThis::add( m_pPenColorToolButton, tr( "Click here to select the color used when drawing." ) );
Opie::OColorPopupMenu* penColorPopupMenu = new Opie::OColorPopupMenu(Qt::black, m_pPenColorToolButton);
connect(penColorPopupMenu, SIGNAL(colorSelected(const QColor&)), this, SLOT(changePenColor(const QColor&)));
QToolTip::add(m_pPenColorToolButton, tr("Pen Color"));
m_pPenColorToolButton->setPopup(penColorPopupMenu);
m_pPenColorToolButton->setPopupDelay(0);
changePenColor(Qt::black);
m_pBrushColorToolButton = new QToolButton(drawParametersToolBar);
m_pBrushColorToolButton->setUsesBigPixmap( useBigIcon );
m_pBrushColorToolButton->setPixmap(Opie::Core::OResource::loadPixmap("drawpad/brushcolor", Opie::Core::OResource::SmallIcon));
QWhatsThis::add( m_pBrushColorToolButton, tr( "Click here to select the color used when filling in areas." ) );
Opie::OColorPopupMenu* brushColorPopupMenu = new Opie::OColorPopupMenu(Qt::white, m_pBrushColorToolButton);
connect(brushColorPopupMenu, SIGNAL(colorSelected(const QColor&)), this, SLOT(changeBrushColor(const QColor&)));
QToolTip::add(m_pBrushColorToolButton, tr("Fill Color"));
m_pBrushColorToolButton->setPopup(brushColorPopupMenu);
m_pBrushColorToolButton->setPopupDelay(0);
changeBrushColor(Qt::white);
// delay the rest of the initialization and do it from within the mainloop
// if we don't do this, the widget layout may not be constructed upon
// and we will end up with a wrong QScrollview page size (Mickeyl)
QTimer::singleShot( 100, this, SLOT( finishStartup() ) );
}
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
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();
}
ViewerWindow::ViewerWindow(QWidget* parent, Qt::WindowFlags flags)
: QMainWindow(parent, flags), gameData(nullptr), gameWorld(nullptr), renderer(nullptr)
{
setMinimumSize(640, 480);
QMenuBar* mb = this->menuBar();
QMenu* file = mb->addMenu("&File");
file->addAction("Open &Game", this, SLOT(loadGame()));
file->addSeparator();
for(int i = 0; i < MaxRecentGames; ++i) {
QAction* r = file->addAction("");
recentGames.append(r);
connect(r, SIGNAL(triggered()), SLOT(openRecent()));
}
recentSep = file->addSeparator();
auto ex = file->addAction("E&xit");
ex->setShortcut(QKeySequence::Quit);
connect(ex, SIGNAL(triggered()), QApplication::instance(), SLOT(closeAllWindows()));
viewerWidget = new ViewerWidget;
viewerWidget->context()->makeCurrent();
glewExperimental = 1;
glewInit();
objectViewer = new ObjectViewer(viewerWidget);
connect(this, SIGNAL(loadedData(GameWorld*)), objectViewer, SLOT(showData(GameWorld*)));
connect(this, SIGNAL(loadedData(GameWorld*)), viewerWidget, SLOT(dataLoaded(GameWorld*)));
modelViewer = new ModelViewer(viewerWidget);
connect(this, SIGNAL(loadedData(GameWorld*)), modelViewer, SLOT(showData(GameWorld*)));
viewSwitcher = new QStackedWidget;
viewSwitcher->addWidget(objectViewer);
viewSwitcher->addWidget(modelViewer);
//connect(objectViewer, SIGNAL(modelChanged(Model*)), modelViewer, SLOT(showModel(Model*)));
connect(objectViewer, SIGNAL(showObjectModel(uint16_t)), this, SLOT(showObjectModel(uint16_t)));
objectViewer->setViewerWidget( viewerWidget );
QMenu* view = mb->addMenu("&View");
QAction* objectAction = view->addAction("&Object");
QAction* modelAction = view->addAction("&Model");
objectAction->setData(0);
modelAction->setData(1);
connect(objectAction, SIGNAL(triggered()), this, SLOT(switchWidget()));
connect(modelAction, SIGNAL(triggered()), this, SLOT(switchWidget()));
QMenu* data = mb->addMenu("&Data");
//data->addAction("Export &Model", objectViewer, SLOT(exportModel()));
QMenu* anim = mb->addMenu("&Animation");
anim->addAction("Load &Animations", this, SLOT(openAnimations()));
this->setCentralWidget(viewSwitcher);
updateRecentGames();
}
MultipleParameterWindowWidget::MultipleParameterWindowWidget(const QString &name, QWidget *parent)
: MultipleWindowWidget(name, parent), mCounter(1)
{
setWindowTitle("Object Properties");
resize(200, 500);
addButtonPressed();
connect(this, SIGNAL(initPhaseCompleted()), this, SLOT(handleInitPhase()));
connect(this, SIGNAL(shutDownPhaseStarted()), this, SLOT(handleShutDownPhase()));
QMenuBar *localMenuBar = menuBar();
QMenu *fileMenu = localMenuBar->addMenu("File");
QAction *saveSinglePanelsAction = fileMenu->addAction("Save Panel");
connect(saveSinglePanelsAction, SIGNAL(triggered()),
this, SLOT(saveSinglePanelToFile()));
QAction *loadSinglePanelsAction = fileMenu->addAction("Load Panel");
connect(loadSinglePanelsAction, SIGNAL(triggered()),
this, SLOT(loadSinglePanelFromFile()));
fileMenu->addSeparator();
QAction *saveAllPanelsAction = fileMenu->addAction("Save All Panels");
connect(saveAllPanelsAction, SIGNAL(triggered()),
this, SLOT(saveAllPanelsToFile()));
QAction *loadAllPanelsAction = fileMenu->addAction("Load All Panels");
connect(loadAllPanelsAction, SIGNAL(triggered()),
this, SLOT(loadAllPanelsFromFile()));
QMenu *editMenu = localMenuBar->addMenu("Edit");
QAction *selectSingleAction = editMenu->addAction("Select Panel");
connect(selectSingleAction, SIGNAL(triggered()),
this, SLOT(selectSinglePanel()));
QAction *applySingleAction = editMenu->addAction("Apply Panel");
connect(applySingleAction, SIGNAL(triggered()),
this, SLOT(applySinglePanel()));
QAction *clearSingleAction = editMenu->addAction("Clear Panel");
connect(clearSingleAction, SIGNAL(triggered()),
this, SLOT(clearSinglePanel()));
editMenu->addSeparator();
QAction *applyAllAction = editMenu->addAction("Apply All in All Panels");
connect(applyAllAction, SIGNAL(triggered()),
this, SLOT(applyAllProperties()));
QAction *applyAndSelectAllAction = editMenu->addAction("Apply and Select All in All Panels");
connect(applyAndSelectAllAction, SIGNAL(triggered()),
this, SLOT(applyAndSelectAllProperties()));
QAction *selectAllAction = editMenu->addAction("Select All in All Panels");
connect(selectAllAction, SIGNAL(triggered()),
this, SLOT(selectAllProperties()));
QAction *deselectAllAction = editMenu->addAction("Deselect All in All Panels");
connect(deselectAllAction, SIGNAL(triggered()),
this, SLOT(deselectAllProperties()));
editMenu->addSeparator();
QAction *copyToAllValuesAction = editMenu->addAction("Copy First To All");
connect(copyToAllValuesAction, SIGNAL(triggered()),
this, SLOT(copyFirstValueToAllOtherValues()));
QAction *setInitForAllValuesAction = editMenu->addAction("Set Init To All");
connect(setInitForAllValuesAction, SIGNAL(triggered()),
this, SLOT(setInitToAllValues()));
QMenu *plotterMenu = localMenuBar->addMenu("Plotter");
QAction *activateHistoryPlotter = plotterMenu->addAction("History Plotter");
connect(activateHistoryPlotter, SIGNAL(triggered()),
this, SLOT(activateHistoryPlotter()));
//QAction *activateXYPlotter = plotterMenu->addAction("X/Y Plotter");
//connect(activateXYPlotter, SIGNAL(triggered()),
// this, SLOT(activateXYPlotter()));
QMenu *helpMenu = localMenuBar->addMenu("Help");
helpMenu->addAction(QWhatsThis::createAction());
}
void MainWindow::makeMenu()
{
QToolBar *toolBar = new QToolBar( this );
QToolBar *searchBar = new QToolBar(this);
QMenuBar *menuBar = new QMenuBar( toolBar );
QPopupMenu *searchMenu = new QPopupMenu( menuBar );
// QPopupMenu *viewMenu = new QPopupMenu( menuBar );
QPopupMenu *cfgMenu = new QPopupMenu( menuBar );
QPopupMenu *searchOptions = new QPopupMenu( cfgMenu );
setToolBarsMovable( false );
toolBar->setHorizontalStretchable( true );
menuBar->insertItem( tr( "Search" ), searchMenu );
menuBar->insertItem( tr( "Settings" ), cfgMenu );
//SETTINGS MENU
cfgMenu->insertItem( tr( "Search" ), searchOptions );
QPopupMenu *pop;
for (SearchGroup *s = searches.first(); s != 0; s = searches.next() ){
pop = s->popupMenu();
if (pop){
cfgMenu->insertItem( s->text(0), pop );
}
}
//SEARCH
SearchAllAction = new QAction( tr("Search all"),QString::null, 0, this, 0 );
SearchAllAction->setIconSet( Opie::Core::OResource::loadPixmap( "find", Opie::Core::OResource::SmallIcon ) );
// QWhatsThis::add( SearchAllAction, tr("Search everything...") );
connect( SearchAllAction, SIGNAL(activated()), this, SLOT(searchAll()) );
SearchAllAction->addTo( searchMenu );
searchMenu->insertItem( tr( "Options" ), searchOptions );
//SEARCH OPTIONS
//actionWholeWordsOnly = new QAction( tr("Whole words only"),QString::null, 0, this, 0, true );
//actionWholeWordsOnly->addTo( searchOptions );
actionCaseSensitiv = new QAction( tr("Case sensitive"),QString::null, 0, this, 0, true );
actionCaseSensitiv->addTo( searchOptions );
actionWildcards = new QAction( tr("Use wildcards"),QString::null, 0, this, 0, true );
actionWildcards->addTo( searchOptions );
//SEARCH BAR
LabelEnterText = new QLabel( searchBar, "Label" );
LabelEnterText->setAutoMask( FALSE );
LabelEnterText->setText( tr( "Search for: " ) );
LabelEnterText->setFrameStyle( QFrame::NoFrame );
LabelEnterText->setBackgroundMode( PaletteButton );
addToolBar( searchBar, "Search", QMainWindow::Top, TRUE );
QLineEdit *searchEdit = new QLineEdit( searchBar, "seachEdit" );
QWhatsThis::add( searchEdit, tr("Enter your search terms here") );
searchEdit->setFocus();
searchBar->setHorizontalStretchable( TRUE );
searchBar->setStretchableWidget( searchEdit );
//Search button
SearchAllAction->addTo( searchBar );
//Clear text
ClearSearchText = new QToolButton( searchBar, "ClearSearchText");
ClearSearchText->setText( "" );
ClearSearchText->setPixmap( Opie::Core::OResource::loadPixmap( "close", Opie::Core::OResource::SmallIcon ) );
connect( searchEdit, SIGNAL( textChanged(const QString&) ),this, SLOT( setSearch(const QString&) ) );
connect( ClearSearchText, SIGNAL( clicked() ), searchEdit, SLOT( clear() ) );
}
MainWindow::MainWindow()
: QMainWindow()
{
_scene.reset();
if (!QGLFormat::hasOpenGL()) {
QMessageBox::critical(this,
"No OpenGL Support",
"This system does not appear to support OpenGL.\n\n"
"The Tungsten scene editor requires OpenGL "
"to work properly. The editor will now terminate.\n\n"
"Please install any available updates for your graphics card driver and try again");
std::exit(0);
}
QGLFormat qglFormat;
qglFormat.setVersion(3, 2);
qglFormat.setProfile(QGLFormat::CoreProfile);
qglFormat.setAlpha(true);
qglFormat.setSampleBuffers(true);
qglFormat.setSamples(16);
_windowSplit = new QSplitter(this);
_stackWidget = new QStackedWidget(_windowSplit);
_renderWindow = new RenderWindow(_stackWidget, this);
_previewWindow = new PreviewWindow(_stackWidget, this, qglFormat);
_propertyWindow = new PropertyWindow(_windowSplit, this);
_stackWidget->addWidget(_renderWindow);
_stackWidget->addWidget(_previewWindow);
_windowSplit->addWidget(_stackWidget);
_windowSplit->addWidget(_propertyWindow);
_windowSplit->setStretchFactor(0, 1);
_windowSplit->setStretchFactor(1, 0);
setCentralWidget(_windowSplit);
_previewWindow->addStatusWidgets(statusBar());
_renderWindow->addStatusWidgets(statusBar());
connect(this, SIGNAL(sceneChanged()), _previewWindow, SLOT(sceneChanged()));
connect(this, SIGNAL(sceneChanged()), _renderWindow, SLOT(sceneChanged()));
connect(this, SIGNAL(sceneChanged()), _propertyWindow, SLOT(sceneChanged()));
connect( _previewWindow, SIGNAL(primitiveListChanged()), _propertyWindow, SLOT(primitiveListChanged()));
connect( _previewWindow, SIGNAL(selectionChanged()), _propertyWindow, SLOT(changeSelection()));
connect(_propertyWindow, SIGNAL(selectionChanged()), _previewWindow, SLOT(changeSelection()));
showPreview(true);
QMenu *fileMenu = new QMenu("&File");
fileMenu->addAction("New", this, SLOT(newScene()), QKeySequence("Ctrl+N"));
fileMenu->addAction("Open File...", this, SLOT(openScene()), QKeySequence("Ctrl+O"));
fileMenu->addAction("Reload File...", this, SLOT(reloadScene()), QKeySequence("Shift+R"));
fileMenu->addSeparator();
fileMenu->addAction("Close", this, SLOT(closeScene()), QKeySequence("Ctrl+W"));
fileMenu->addSeparator();
fileMenu->addAction("Save", this, SLOT(saveScene()), QKeySequence("Ctrl+S"));
fileMenu->addAction("Save as...", this, SLOT(saveSceneAs()), QKeySequence("Ctrl+Shift+S"));
fileMenu->addSeparator();
fileMenu->addAction("Exit", this, SLOT(close()));
QMenuBar *menuBar = new QMenuBar();
menuBar->addMenu(fileMenu);
setMenuBar(menuBar);
newScene();
}
void AdvancedFm::init() {
b = false;
setCaption( tr( "AdvancedFm" ) );
// QFrame* frame = new QFrame(this);
// setCentralWidget(frame);
// QVBoxLayout *layout = new QVBoxLayout( frame );
QVBoxLayout *layout = new QVBoxLayout( this);
layout->setSpacing( 2);
layout->setMargin( 0); // squeeze
QMenuBar *menuBar = new QMenuBar(this);
menuBar->setMargin( 0 ); // squeeze
fileMenu = new QPopupMenu( this );
viewMenu = new QPopupMenu( this );
// customDirMenu = new QPopupMenu( this );
layout->addWidget( menuBar );
menuBar->insertItem( tr( "File" ), fileMenu);
menuBar->insertItem( tr( "View" ), viewMenu);
connect(fileMenu,SIGNAL(aboutToShow()),this,SLOT(enableDisableMenu()));
bool useBigIcon = qApp->desktop()->size().width() > 330;
cdUpButton = new QToolButton( 0,"cdUpButton");
cdUpButton->setUsesBigPixmap( useBigIcon );
cdUpButton->setPixmap( Opie::Core::OResource::loadPixmap( "up", Opie::Core::OResource::SmallIcon ) );
cdUpButton->setAutoRaise( true );
menuBar->insertItem( cdUpButton );
qpeDirButton= new QToolButton( 0,"QPEButton");
qpeDirButton->setUsesBigPixmap( useBigIcon );
qpeDirButton->setPixmap( Opie::Core::OResource::loadPixmap( "logo/opielogo", Opie::Core::OResource::SmallIcon ) );
qpeDirButton->setAutoRaise( true );
menuBar->insertItem( qpeDirButton );
fsButton = new OFileSystemButton( 0 );
fsButton->setUsesBigPixmap( useBigIcon );
fsButton->setAutoRaise( true );
menuBar->insertItem( fsButton );
docButton = new QToolButton( 0,"docsButton");
docButton->setUsesBigPixmap( useBigIcon );
docButton->setPixmap( Opie::Core::OResource::loadPixmap( "DocsIcon", Opie::Core::OResource::SmallIcon ) );
docButton->setAutoRaise( true );
menuBar->insertItem( docButton );
homeButton = new QToolButton( 0, "homeButton");
homeButton->setUsesBigPixmap( useBigIcon );
homeButton->setPixmap( Opie::Core::OResource::loadPixmap( "home", Opie::Core::OResource::SmallIcon ) );
homeButton->setAutoRaise( true );
menuBar->insertItem( homeButton );
// fileMenu->insertItem( tr( "File Search" ), this, SLOT( openSearch() ));
// fileMenu->insertSeparator();
fileMenu->insertItem( tr( "Make Directory" ), this, SLOT( mkDir() ), 0, 101);
fileMenu->insertItem( tr( "Select All" ), this, SLOT( selectAll() ), 0, 102);
fileMenu->insertSeparator();
fileMenu->insertItem( tr( "Make Symlink" ), this, SLOT( mkSym() ), 0, 103);
fileMenu->insertItem( tr( "Add To Documents" ), this, SLOT( addToDocs() ), 0, 104);
fileMenu->insertItem( tr( "Run Command" ), this, SLOT( runCommandStd() ), 0, 105);
fileMenu->insertItem( tr( "Run Command with Output" ), this, SLOT( runCommand() ), 0, 106);
fileMenu->insertItem( tr( "Rename" ), this, SLOT( rn() ), 0, 107);
fileMenu->insertItem( tr( "Delete" ), this, SLOT( del() ), 0, 108);
viewMenu->insertItem( tr( "Switch to View 1" ), this, SLOT( switchToLocalTab()));
viewMenu->insertItem( tr( "Switch to View 2" ), this, SLOT( switchToRemoteTab()));
viewMenu->insertSeparator();
viewMenu->insertItem( tr( "Refresh" ), this, SLOT( refreshCurrentTab()));
viewMenu->insertSeparator();
viewMenu->insertItem( tr( "Show Hidden Files" ), this, SLOT( showMenuHidden() ));
// viewMenu->insertSeparator();
// viewMenu->insertItem( tr( "About" ), this, SLOT( doAbout() ));
viewMenu->setCheckable(true);
viewMenu->setItemChecked( viewMenu->idAt(0), true);
viewMenu->setItemChecked( viewMenu->idAt(1), false);
viewMenu->setItemChecked( viewMenu->idAt(5), false);
s_addBookmark = tr("Bookmark Directory");
s_removeBookmark = tr("Remove Current Directory from Bookmarks");
// menuButton->insertItem("");
// customDirMenu->insertItem(tr("Add This Directory"));
// customDirMenu->insertItem(tr("Remove This Directory"));
// customDirMenu->insertSeparator();
QHBoxLayout *CBHB = new QHBoxLayout(); // parent layout will be set later
CBHB->setMargin( 0 );
CBHB->setSpacing( 1 );
menuButton = new MenuButton( this );
menuButton->setUseLabel(false);
menuButton->setMaximumWidth( 20 );
menuButton->insertItem( s_addBookmark);
menuButton->insertItem( s_removeBookmark);
menuButton->insertSeparator();
// menuButton->setFocusPolicy(NoFocus);
CBHB->addWidget( menuButton );
customDirsToMenu();
currentPathCombo = new QComboBox( FALSE, this, "currentPathCombo" );
currentPathCombo->setEditable(TRUE);
currentPathCombo->lineEdit()->setText( currentDir.canonicalPath());
// currentPathCombo->setFocusPolicy(NoFocus);
CBHB->addWidget( currentPathCombo );
layout->addLayout( CBHB );
TabWidget = new OSplitter( Horizontal, this, "TabWidget" );
// TabWidget = new QTabWidget( this, "TabWidget" );
layout->addWidget( TabWidget, 4 );
tab = new QWidget( TabWidget, "tab" );
tabLayout = new QGridLayout( tab );
tabLayout->setSpacing( 2);
tabLayout->setMargin( 2);
Local_View = new QListView( tab, "Local_View" );
Local_View->addColumn( tr("File"),130);
Local_View->addColumn( tr("Size"),-1);
Local_View->setColumnAlignment(1,QListView::AlignRight);
Local_View->addColumn( tr("Date"),-1);
Local_View->setColumnAlignment(2,QListView::AlignRight);
Local_View->setAllColumnsShowFocus(TRUE);
Local_View->setMultiSelection( TRUE );
Local_View->setSelectionMode(QListView::Extended);
Local_View->setFocusPolicy(StrongFocus);
Local_View->installEventFilter( this );
QPEApplication::setStylusOperation( Local_View->viewport() , QPEApplication::RightOnHold);
tabLayout->addWidget( Local_View, 0, 0 );
TabWidget->addWidget( tab,"advancedfm/smFileBrowser.png", tr("1"));
// TabWidget->insertTab( tab, tr("1"));
tab_2 = new QWidget( TabWidget, "tab_2" );
tabLayout_2 = new QGridLayout( tab_2 );
tabLayout_2->setSpacing( 2);
tabLayout_2->setMargin( 2);
Remote_View = new QListView( tab_2, "Remote_View" );
Remote_View->addColumn( tr("File"),130);
Remote_View->addColumn( tr("Size"),-1);
Remote_View->setColumnAlignment(1,QListView::AlignRight);
Remote_View->addColumn( tr("Date"),-1);
Remote_View->setColumnAlignment(2,QListView::AlignRight);
Remote_View->setAllColumnsShowFocus(TRUE);
Remote_View->setMultiSelection( TRUE );
Remote_View->setSelectionMode(QListView::Extended);
Remote_View->setFocusPolicy(StrongFocus);
Remote_View->installEventFilter( this );
QPEApplication::setStylusOperation( Remote_View->viewport(), QPEApplication::RightOnHold);
tabLayout_2->addWidget( Remote_View, 0, 0 );
TabWidget->addWidget( tab_2, "advancedfm/smFileBrowser.png",tr( "2"));
TabWidget->setSizeChange( 370 );
// TabWidget->insertTab( tab_2, tr( "2"));
/* tab_3 = new QWidget( TabWidget, "tab_3" );
tabLayout_3 = new QGridLayout( tab_3 );
tabLayout_3->setSpacing( 2);
tabLayout_3->setMargin( 2);
// OFileDialog fileDialog;
// fileDialog;
// fileSelector = new FileSelector( "*",tab_3, "fileselector" , FALSE, FALSE); //buggy
// fileDialog = new OFileDialog("bangalow", tab_3, 4, 2, "Bungalow");
// OFileSelector fileDialog = new OFileSelector( tab_3, 4, 2,"/");
QListView *fileTree;
fileTree = new QListView( tab_3, "tree" );
tabLayout_3->addMultiCellWidget( fileTree, 0, 0, 0, 3 );
TabWidget->insertTab( tab_3, tr( "Remote" ) );
*/
///////////////
currentDir.setFilter( QDir::Files | QDir::Dirs | QDir::Hidden | QDir::All);
currentDir.setPath( QDir::currentDirPath());
currentRemoteDir.setFilter( QDir::Files | QDir::Dirs | QDir::Hidden | QDir::All);
currentRemoteDir.setPath( QDir::currentDirPath());
filterStr="*";
showHidden();
TabWidget->setCurrentWidget(0);
}
JoCASSViewer::JoCASSViewer(QWidget *parent, Qt::WindowFlags flags)
: QMainWindow(parent,flags),
_updateInProgress(false)
{
QSettings settings;
TCPClient *client(new TCPClient);
/** set up the window */
// Add a menu to the window
QMenuBar *menu = menuBar();
// Add file menu
QMenu *fmenu = menu->addMenu(tr("&File"));
fmenu->addAction(QIcon::fromTheme("document-open"),tr("Load Data"),this,
SLOT(openFile()),QKeySequence(QKeySequence::Open))->setShortcutContext(Qt::ApplicationShortcut);
fmenu->addAction(QIcon::fromTheme("document-save"),tr("Save"),this,
SLOT(autoSave()),QKeySequence(tr("F10")))->setShortcutContext(Qt::ApplicationShortcut);
fmenu->addAction(QIcon::fromTheme("document-save-as"),tr("Save as..."),this,
SLOT(saveFile()),QKeySequence(QKeySequence::SaveAs))->setShortcutContext(Qt::ApplicationShortcut);
fmenu->addAction(QIcon::fromTheme("document-print"),tr("Print"),this,
SLOT(print()),QKeySequence(QKeySequence::Print))->setShortcutContext(Qt::ApplicationShortcut);
fmenu->addSeparator();
fmenu->addAction(QIcon::fromTheme("application-exit"),tr("Quit"),qApp,
SLOT(closeAllWindows()),QKeySequence("Ctrl+q"))->setShortcutContext(Qt::ApplicationShortcut);
// Add control menu
QMenu *cmenu = menu->addMenu(tr("&Control"));
cmenu->addAction(tr("Refresh List"),this,
SLOT(refreshDisplayableItemsList()),QKeySequence(tr("F5")))->setShortcutContext(Qt::ApplicationShortcut);
cmenu->addAction(tr("Get Data"),this,
SLOT(updateViewers()),QKeySequence(tr("Ctrl+i")))->setShortcutContext(Qt::ApplicationShortcut);
cmenu->addAction(tr("Clear Histogram"),this,
SLOT(clearHistogram()));
cmenu->addAction(tr("Send custom Command"),this,
SLOT(sendCustomCommand()));
cmenu->addAction(tr("Broadcast darkcal command"),this,
SLOT(broadcastDarkcalCommand()),QKeySequence(tr("Ctrl+d")))->setShortcutContext(Qt::ApplicationShortcut);
cmenu->addAction(tr("Broadcast gaincal command"),this,
SLOT(broadcastGaincalCommand()),QKeySequence(tr("Ctrl+g")))->setShortcutContext(Qt::ApplicationShortcut);
cmenu->addSeparator()->setText("Server Control");
cmenu->addAction(tr("Reload ini File"),client,
SLOT(reloadIni()),QKeySequence(tr("Ctrl+r")))->setShortcutContext(Qt::ApplicationShortcut);
cmenu->addAction(tr("Quit Server"),client,SLOT(quitServer()));
// Add the source menu
DataSourceManager::setMenu(menu->addMenu(tr("&Sources")));
// Add help menu
QMenu *hmenu = menu->addMenu(tr("&Help"));
hmenu->addAction(tr("About"),this,SLOT(about()));
hmenu->addAction(tr("About Qt"),qApp,SLOT(aboutQt()));
// Add a toolbar where we can add the general tools
_serverToolBar = addToolBar(tr("Display control"));
_serverToolBar->setContextMenuPolicy(Qt::PreventContextMenu);
// Add servername and port to toolbar.
_servername = new QLineEdit(settings.value("Servername", "localhost").toString());
_servername->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
_servername->setToolTip(tr("Name of the server to connect to."));
connect(_servername,SIGNAL(textEdited(QString)),this,SLOT(changeServerAddress()));
_serverToolBar->addWidget(_servername);
_serverport = new QSpinBox();
_serverport->setKeyboardTracking(false);
_serverport->setRange(1000, 50000);
_serverport->setValue(settings.value("Serverport", 12321).toInt());
_serverport->setToolTip(tr("Port of the server to connect to."));
connect(_serverport,SIGNAL(valueChanged(int)),this,SLOT(changeServerAddress()));
_serverToolBar->addWidget(_serverport);
// Add spacer to toolbar.
QWidget *spacer1(new QWidget());
spacer1->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
_serverToolBar->addWidget(spacer1);
// Add a separator
_serverToolBar->addSeparator();
// Add spacer to toolbar.
QWidget *spacer2(new QWidget());
spacer2->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
_serverToolBar->addWidget(spacer2);
// Add run control to toolbar.
_autoUpdate = new QAction(QIcon(":images/auto_update.png"),tr("Toggle auto update"),_serverToolBar);
_autoUpdate->setCheckable(true);
_autoUpdate->setChecked(settings.value("AutoUpdateOn",false).toBool());
_autoUpdate->setToolTip(tr("If checked, continuously retrieve and display images."));
connect(_autoUpdate,SIGNAL(triggered()),
this,SLOT(changeAutoUpdate()));
_serverToolBar->addAction(_autoUpdate);
// Add status LED to toolbar.
_statusLED = new StatusLED();
_statusLED->setToolTip("Status indicator (green = Data retrieved ok, red = communciation Problems, yellow = busy).");
_statusLED->setStatus(StatusLED::off);
_serverToolBar->addWidget(_statusLED);
// Add rate to toolbar.
_rate = new QDoubleSpinBox();
_rate->setRange(0.01, 100.);
_rate->setValue(settings.value("Rate", 10.).toDouble());
_rate->setToolTip(tr("Image update frequency."));
connect(_rate,SIGNAL(valueChanged(double)),
this,SLOT(changeAutoUpdate()));
_serverToolBar->addWidget(_rate);
QLabel *punit = new QLabel;
punit->setText("Hz");
_serverToolBar->addWidget(punit);
// set up status bar
statusBar()->setToolTip(tr("Actual frequency to get and display "
"images averaged over (n) times."));
// Set a list item as central widget
QListWidget *listview(new QListWidget(this));
listview->setSelectionMode(QAbstractItemView::MultiSelection);
connect(listview,SIGNAL(itemClicked(QListWidgetItem*)),
this,SLOT(changeViewers(QListWidgetItem*)));
setCentralWidget(listview);
/** use the timer as single shot */
_updateTimer.setSingleShot(true);
connect(&_updateTimer,SIGNAL(timeout()),this,SLOT(updateViewers()));
/** initialize the server data source and add them to the manager */
DataSourceManager::addSource("Server",client);
changeServerAddress();
connect(DataSourceManager::instance(),SIGNAL(sourceChanged(QString)),
this,SLOT(on_source_changed(QString)));
// Set the size and position of the window
resize(settings.value("MainWindowSize",size()).toSize());
move(settings.value("MainWindowPosition",pos()).toPoint());
show();
}
ExampleWidget::ExampleWidget( QWidget *parent, const char *name )
: QWidget( parent, name )
{
// Make the top-level layout; a vertical box to contain all widgets
// and sub-layouts.
QBoxLayout *topLayout = new QVBoxLayout( this, 5 );
// Create a menubar...
QMenuBar *menubar = new QMenuBar( this );
menubar->setSeparator( QMenuBar::InWindowsStyle );
QPopupMenu* popup;
popup = new QPopupMenu( this );
popup->insertItem( "&Quit", qApp, SLOT(quit()) );
menubar->insertItem( "&File", popup );
// ...and tell the layout about it.
topLayout->setMenuBar( menubar );
// Make an hbox that will hold a row of buttons.
QBoxLayout *buttons = new QHBoxLayout( topLayout );
int i;
for ( i = 1; i <= 4; i++ ) {
QPushButton* but = new QPushButton( this );
QString s;
s.sprintf( "Button %d", i );
but->setText( s );
// Set horizontal stretch factor to 10 to let the buttons
// stretch horizontally. The buttons will not stretch
// vertically, since bigWidget below will take up vertical
// stretch.
buttons->addWidget( but, 10 );
// (Actually, the result would have been the same with a
// stretch factor of 0; if no items in a layout have non-zero
// stretch, the space is divided equally between members.)
}
// Make another hbox that will hold a left-justified row of buttons.
QBoxLayout *buttons2 = new QHBoxLayout( topLayout );
QPushButton* but = new QPushButton( "Button five", this );
buttons2->addWidget( but );
but = new QPushButton( "Button 6", this );
buttons2->addWidget( but );
// Fill up the rest of the hbox with stretchable space, so that
// the buttons get their minimum width and are pushed to the left.
buttons2->addStretch( 10 );
// Make a big widget that will grab all space in the middle.
QMultiLineEdit *bigWidget = new QMultiLineEdit( this );
bigWidget->setText( "This widget will get all the remaining space" );
bigWidget->setFrameStyle( QFrame::Panel | QFrame::Plain );
// Set vertical stretch factor to 10 to let the bigWidget stretch
// vertically. It will stretch horizontally because there are no
// widgets beside it to take up horizontal stretch.
// topLayout->addWidget( bigWidget, 10 );
topLayout->addWidget( bigWidget );
// Make a grid that will hold a vertical table of QLabel/QLineEdit
// pairs next to a large QMultiLineEdit.
// Don't use hard-coded row/column numbers in QGridLayout, you'll
// regret it when you have to change the layout.
const int numRows = 3;
const int labelCol = 0;
const int linedCol = 1;
const int multiCol = 2;
// Let the grid-layout have a spacing of 10 pixels between
// widgets, overriding the default from topLayout.
QGridLayout *grid = new QGridLayout( topLayout, 0, 0, 10 );
int row;
for ( row = 0; row < numRows; row++ ) {
QLineEdit *ed = new QLineEdit( this );
// The line edit goes in the second column
grid->addWidget( ed, row, linedCol );
// Make a label that is a buddy of the line edit
QString s;
s.sprintf( "Line &%d", row+1 );
QLabel *label = new QLabel( ed, s, this );
// The label goes in the first column.
grid->addWidget( label, row, labelCol );
}
// The multiline edit will cover the entire vertical range of the
// grid (rows 0 to numRows) and stay in column 2.
QMultiLineEdit *med = new QMultiLineEdit( this );
grid->addMultiCellWidget( med, 0, -1, multiCol, multiCol );
// The labels will take the space they need. Let the remaining
// horizontal space be shared so that the multiline edit gets
// twice as much as the line edit.
grid->setColStretch( linedCol, 10 );
grid->setColStretch( multiCol, 20 );
// Add a widget at the bottom.
QLabel* sb = new QLabel( this );
sb->setText( "Let's pretend this is a status bar" );
sb->setFrameStyle( QFrame::Panel | QFrame::Sunken );
// This widget will use all horizontal space, and have a fixed height.
// we should have made a subclass and implemented sizePolicy there...
sb->setFixedHeight( sb->sizeHint().height() );
sb->setAlignment( AlignVCenter | AlignLeft );
topLayout->addWidget( sb );
topLayout->activate();
}
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->setToolTip("Undo the last action (not supported by all modules)");
redoAction = new QAction(QIcon::fromTheme("edit-redo",QIcon(":/org_mitk_icons/icons/tango/scalable/actions/edit-redo.svg"))
, "&Redo", nullptr);
redoAction->setToolTip("execute the last action that was undone again (not supported by all modules)");
}
// 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(this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.xnat.browser"))
{
openXnatEditorAction = new QmitkOpenXnatEditorAction(QIcon(":/org.mitk.gui.qt.ext/xnat-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(this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.xnat.browser"))
{
mainActionsToolBar->addAction(openXnatEditorAction);
}
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);
}
}
/* Konstruktor */
MainWindow::MainWindow(): tabWidget(new QTabWidget(this)) {
setWindowIcon(QIcon(":/icon.png"));
#ifdef ADMIN_VERSION
setWindowTitle(tr("Absencoid [správce]"));
#else
setWindowTitle(tr("Absencoid [uživatel]"));
#endif
/* Menu */
QMenuBar* menu = new QMenuBar();
/* Menu Soubor */
QMenu* fileMenu = menu->addMenu(tr("Soubor"));
QAction* quitAction = fileMenu->addAction(Style::style()->icon(Style::ExitIcon), tr("Ukončit"));
connect(quitAction, SIGNAL(triggered(bool)), this, SLOT(close()));
/* Menu Nápověda */
QMenu* helpMenu = menu->addMenu(tr("Nápověda"));
QAction* helpAction = helpMenu->addAction(Style::style()->icon(Style::HelpIcon), tr("Nápověda"));
helpAction->setDisabled(true);
QAction* aboutAction = helpMenu->addAction(QIcon(":/icon.png"), tr("O programu"));
helpMenu->addSeparator();
QAction* aboutQtAction = helpMenu->addAction(QIcon(":/qt.png"), tr("O Qt"));
connect(aboutAction, SIGNAL(triggered(bool)), this, SLOT(about()));
connect(aboutQtAction, SIGNAL(triggered(bool)), qApp, SLOT(aboutQt()));
setMenuBar(menu);
/* Taby */
tabWidget->setTabPosition(QTabWidget::South);
tabWidget->setUsesScrollButtons(false);
/* Učitelé */
TeachersTab* teachersTab = new TeachersTab(tabWidget);
tabWidget->addTab(teachersTab, Style::style()->icon(Style::TeachersTab), tr("Učitelé"));
/* Předměty */
ClassesTab* classesTab = new ClassesTab(teachersTab->getTeachersModel(), tabWidget);
tabWidget->addTab(classesTab, Style::style()->icon(Style::ClassesTab), tr("Předměty"));
/* Rozvrh hodin */
TimetableTab* timetableTab = new TimetableTab(classesTab->getClassesModel(), tabWidget);
tabWidget->addTab(timetableTab, Style::style()->icon(Style::TimetableTab), tr("Rozvrhy hodin"));
/* Změny */
ChangesTab* changesTab =
new ChangesTab(timetableTab->getTimetableModel(), classesTab->getClassesModel());
tabWidget->addTab(changesTab, Style::style()->icon(Style::ChangesTab), tr("Změny"));
/* Absence */
AbsencesTab* absencesTab = new AbsencesTab(teachersTab->getTeachersModel(), classesTab->getClassesModel(), timetableTab->getTimetableModel(), changesTab->getChangesModel());
tabWidget->addTab(absencesTab, Style::style()->icon(Style::AbsencesTab), tr("Absence"));
/* Souhrn - potřebuje data rozvrhu, ale absence potřebují jeho aktuální
rozvrh, proto je zde */
SummaryTab* summaryTab = new SummaryTab(teachersTab->getTeachersModel(), classesTab->getClassesModel(), timetableTab, changesTab->getChangesModel(), absencesTab->getAbsencesModel());
tabWidget->insertTab(0, summaryTab, Style::style()->icon(Style::SummaryTab), tr("Souhrn"));
tabWidget->setCurrentIndex(0);
/* Propojení signálu o aktualizaci databáze s reload funkcemi modelů.
Bacha, pořadí je důležité! ConfigurationModel potřebuje aktualizovaná
data z TimetableTab */
connect(summaryTab, SIGNAL(updated()), teachersTab->getTeachersModel(), SLOT(reload()));
connect(summaryTab, SIGNAL(updated()), classesTab->getClassesModel(), SLOT(reload()));
connect(summaryTab, SIGNAL(updated()), timetableTab->getTimetableModel(), SLOT(reload()));
connect(summaryTab, SIGNAL(updated()), changesTab->getChangesModel(), SLOT(reload()));
connect(summaryTab, SIGNAL(updated()), absencesTab->getAbsencesModel(), SLOT(reload()));
connect(summaryTab, SIGNAL(updated()), summaryTab, SLOT(reload()));
setCentralWidget(tabWidget);
/* Stavový řádek */
setStatusBar(new QStatusBar(this));
statusBar()->addWidget(new QLabel(tr("Absencoid k vašim službám.")), 1);
statusBar()->addWidget(new QLabel(tr("%1").arg(APP_VERSION_LONG)));
/* Změna velikosti na nejmenší možnou v poměru 16:10 */
resize(480*8/5, 480);
}
void MainWindow::createMenus()
{
QMenuBar *bar = this->menuBar();
QMenu *fileMenu = new QMenu(tr("&File"), bar);
fileMenu->addAction(newPostAct);
fileMenu->addAction(openPostAct);
fileMenu->addAction(closePostAct);
fileMenu->addSeparator();
fileMenu->addAction(savePostAct);
fileMenu->addAction(saveAsPostAct);
fileMenu->addSeparator();
fileMenu->addAction(exitAct);
bar->addMenu(fileMenu);
QMenu *editMenu = new QMenu(tr("&Edit"), bar);
editMenu->addAction(undoAct);
editMenu->addAction(redoAct);
editMenu->addSeparator();
editMenu->addAction(cutAct);
editMenu->addAction(copyAct);
editMenu->addAction(pasteAct);
bar->addMenu(editMenu);
QMenu *formatMenu = new QMenu(tr("F&ormat"), bar);
formatMenu->addAction(textFontAct);
formatMenu->addAction(textColorAct);
formatMenu->addAction(textBackgroundColorAct);
formatMenu->addSeparator();
QMenu *alignMenu = new QMenu(tr("Alignment"), formatMenu);
if(QApplication::isLeftToRight()) {
alignMenu->addAction(alignLeftAct);
alignMenu->addAction(alignCenterAct);
alignMenu->addAction(alignRightAct);
} else {
alignMenu->addAction(alignRightAct);
alignMenu->addAction(alignCenterAct);
alignMenu->addAction(alignLeftAct);
}
alignMenu->addAction(alignJustifyAct);
formatMenu->addMenu(alignMenu);
bar->addMenu(formatMenu);
QMenu *insertMenu = new QMenu(tr("&Insert"), bar);
QMenu *listMenu = new QMenu(tr("List"), insertMenu);
listMenu->addAction(bulletListAct);
listMenu->addAction(numberedListAct);
listMenu->addSeparator();
listMenu->addAction(indentMoreAct);
listMenu->addAction(indentLessAct);
insertMenu->addMenu(listMenu);
QMenu *tableMenu = createTableMenu(insertMenu);
insertMenu->addMenu(tableMenu);
bar->addMenu(insertMenu);
QMenu *toolMenu = new QMenu(tr("&Tools"), bar);
toolMenu->addAction(pluginAct);
bar->addMenu(toolMenu);
bar->addSeparator();
QMenu *helpMenu = new QMenu(tr("Help"), bar);
helpMenu->addAction(helpAct);
helpMenu->addAction(aboutAct);
bar->addMenu(helpMenu);
}
void NewGeneMainWindow::ShowHideTabs(int const checkState)
{
// From http://stackoverflow.com/a/31147349/368896 - there is no way to add/remove individual styles from a stylesheet,
// so we just build out the whole thing
// No availability of raw string literals in VS2013
QString tabStylesheetMain =
"#tabWidgetMain pane {border-top: 2px solid #C2C7CB; position: absolute; top: -0.5em;} #tabWidgetMain QTabBar::tab {background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #E1E1E1, stop: 0.4 #DDDDDD, stop: 0.5 #D8D8D8, stop: 1.0 #D3D3D3); border: 2px solid #C4C4C3; border-bottom-color: #C2C7CB; border-top-left-radius: 4px; border-top-right-radius: 4px; min-width: 8ex; padding: 2px;} #tabWidgetMain QTabBar::tab:selected, QTabBar::tab:hover { background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #fafafa, stop: 0.4 #f4f4f4, stop: 0.5 #e7e7e7, stop: 1.0 #fafafa); } #tabWidgetMain QTabBar::tab:selected { border-color: #9B9B9B; border-bottom-color: #C2C7CB; /* same as pane color */ } #tabWidgetMain > QTabBar { margin: 20px; } ";
QString tabStylesheetSub;
QString overallStylesheet;
QString kadBoxStylesheet;
QString kadBoxInnerStylesheet;
QString checkboxSimpleModeStylesheet;
NewGeneTabWidget * highLevelTabWindow { findChild<NewGeneTabWidget *>("tabWidgetMain") };
NewGeneTabWidget * tabOutput { findChild<NewGeneTabWidget *>("tabWidgetOutput") };
QMenu * menuInput { findChild<QMenu *>("menuInput") };
QMenu * menuOutput { findChild<QMenu *>("menuOutput") };
QMenu * menuAbout { findChild<QMenu *>("menuAbout") };
QMenuBar * menuBar { findChild<QMenuBar *>("menuBar") };
NewGeneCreateOutput * CreateOutputPane { findChild<NewGeneCreateOutput *>("CreateOutputPane") };
// The following nesting is NOT NECESSARY to obtain pointers to the widgets.
// I did it to debug failure which turned out to be just using the class name as the ID in the 'findChild' function.
// But I left the code in place for convenience in case I want to access the intermediate levels in the future.
if (highLevelTabWindow && tabOutput && menuInput && menuOutput && menuAbout && menuBar && CreateOutputPane)
{
NewGeneSelectVariables * widgetSelectVariablesPane { CreateOutputPane->findChild<NewGeneSelectVariables *>("widgetSelectVariablesPane") };
if (widgetSelectVariablesPane)
{
KAdColumnSelectionBox * kadBox { widgetSelectVariablesPane->findChild<KAdColumnSelectionBox *>("frameKAdSelectionArea") };
if (kadBox)
{
QCheckBox * checkBoxSimpleMode { kadBox->findChild<QCheckBox *>("checkBoxSimpleMode") };
if (checkBoxSimpleMode /* && kadBoxInner */)
{
if (checkState == Qt::Checked)
{
highLevelTabWindow->setCurrentIndex(0);
tabOutput->setCurrentIndex(0);
tabOutput->setTabText(1, "");
overallStylesheet += "QTabBar {background-color: #FFFFE0;}";
setStyleSheet(overallStylesheet);
tabStylesheetMain +=
"#tabWidgetMain > pane { border: 0px; padding: 0px; height: 0px; } #tabWidgetMain > QTabBar::tab {margin: 0px; border: 0px; padding: 0px; height: 0px; } #tabWidgetMain > QTabBar::tab:selected, #tabWidgetMain > QTabBar::tab:hover { margin: 0px; border: 0px; padding: 0px; height: 0px; } #tabWidgetMain > QTabBar::tab:selected { margin: 0px; border: 0px; padding: 0px; height: 0px; } #tabWidgetMain > QTabBar { margin: 0px; border: 0px; padding: 0px; height: 0px; }";
tabStylesheetSub += "QTabBar::tab:middle {width: 0px; min-width: 0px; max-width: 0px; border: 0px; padding: 0px; margin: 0px;}";
highLevelTabWindow->setStyleSheet(tabStylesheetMain);
tabOutput->setStyleSheet(tabStylesheetSub);
kadBoxStylesheet += "QFrame#frameKAdSelectionArea {background-color: #DDEEDD;}";
kadBox->setStyleSheet(kadBoxStylesheet);
checkboxSimpleModeStylesheet += "QCheckBox#checkBoxSimpleMode {font: bold 11px; color: blue;}";
checkBoxSimpleMode->setStyleSheet(checkboxSimpleModeStylesheet);
menuInput->menuAction()->setVisible(false);
menuOutput->menuAction()->setVisible(false);
menuAbout->menuAction()->setVisible(false);
menuBar->setVisible(false);
}
else
{
highLevelTabWindow->setStyleSheet(tabStylesheetMain);
tabOutput->setStyleSheet(tabStylesheetSub);
tabOutput->setTabText(1, " Limit DMUs ");
setStyleSheet(overallStylesheet);
kadBox->setStyleSheet(kadBoxStylesheet);
checkBoxSimpleMode->setStyleSheet(checkboxSimpleModeStylesheet);
menuBar->setVisible(true);
menuAbout->menuAction()->setVisible(true);
menuOutput->menuAction()->setVisible(true);
menuInput->menuAction()->setVisible(true);
}
}
}
}
}
NewGeneVariablesToolboxWrapper * vgToolboxPane { CreateOutputPane->findChild<NewGeneVariablesToolboxWrapper *>("toolbox") };
if (vgToolboxPane && vgToolboxPane->newgeneToolBox)
{
vgToolboxPane->newgeneToolBox->resetAllBarColors();
}
}
int main(int argc, char** argv)
{
bool timeit = FALSE;
QApplication app(argc,argv);
bool scrollbars=FALSE;
for (int arg=1; arg<argc; arg++) {
if (0==strcmp(argv[arg],"-bounce")) {
bouncers=atoi(argv[++arg]);
} else if (0==strcmp(argv[arg],"-help") ||
0==strcmp(argv[arg],"--help")) {
showtext=FALSE;
} else if (0==strcmp(argv[arg],"-redraws")) {
showredraws=TRUE;
} else if (0==strcmp(argv[arg],"-lines")) {
showlines=TRUE;
} else if (0==strcmp(argv[arg],"-btext")) {
btext=FALSE;
} else if (0==strcmp(argv[arg],"-dsprite")) {
dsprite=FALSE;
} else if (0==strcmp(argv[arg],"-dpoly")) {
dpoly=!dpoly;
} else if (0==strcmp(argv[arg],"-delay")) {
refresh_delay=atoi(argv[++arg]);
} else if (0==strcmp(argv[arg],"-sb")) {
scrollbars=TRUE;
} else if (0==strcmp(argv[arg],"-noopt")) {
QPixmap::setDefaultOptimization( QPixmap::NoOptim );
} else if (0==strcmp(argv[arg],"-bestopt")) {
QPixmap::setDefaultOptimization( QPixmap::BestOptim );
#ifdef _WS_WIN_
} else if (0==strcmp(argv[arg],"-bsm")) {
extern bool qt_bitblt_bsm;
qt_bitblt_bsm=TRUE;
#endif
} else if (0==strcmp(argv[arg],"-iter")) {
iterations=atoi(argv[++arg]);
timeit = TRUE;
} else {
warning("Bad param %s", argv[arg]);
}
}
QMainWindow m;
MySpriteField field(IMG_BACKGROUND,scrollbars ? WIDTH*3 : WIDTH,
scrollbars ? HEIGHT*3 : HEIGHT);
Example example(scrollbars,field,&m);
QMenuBar* menu = m.menuBar();
QPopupMenu* file = new QPopupMenu;
file->insertItem("New view", &example, SLOT(makeSlave()), CTRL+Key_N);
file->insertSeparator();
file->insertItem("Quit", qApp, SLOT(quit()), CTRL+Key_Q);
menu->insertItem("&File", file);
QPopupMenu* edit = new QPopupMenu;
edit->insertItem("New polygon", &example, SLOT(makePolygon()));
edit->insertItem("New ellipse", &example, SLOT(makeEllipse()));
edit->insertItem("New rectangle", &example, SLOT(makeRectangle()));
menu->insertItem("&Edit", edit);
MyPopupMenu* options = new MyPopupMenu;
options->insertCheckItem("Show help text", &showtext, CTRL+Key_H);
options->insertCheckItem("Show bouncing text", &btext, CTRL+Key_T);
options->insertCheckItem("Show polygon", &dpoly, CTRL+Key_P);
options->insertCheckItem("Show drawn sprite", &dsprite, CTRL+Key_D);
options->insertCheckItem("Show redraw areas", &showredraws, CTRL+Key_A);
options->insertCheckItem("Show foreground lines", &showlines, CTRL+Key_L);
options->insertSeparator();
options->insertRadioItem("1 bouncer", &bouncers, 1);
options->insertRadioItem("3 bouncers", &bouncers, 3);
options->insertRadioItem("10 bouncers", &bouncers, 10);
options->insertRadioItem("30 bouncers", &bouncers, 30);
options->insertRadioItem("100 bouncers", &bouncers, 100);
options->insertRadioItem("1000 bouncers", &bouncers, 1000);
options->insertSeparator();
options->insertRadioItem("No delay", &refresh_delay, 0);
options->insertRadioItem("500 fps", &refresh_delay, 2);
options->insertRadioItem("100 fps", &refresh_delay, 10);
options->insertRadioItem("72 fps", &refresh_delay, 14);
options->insertRadioItem("30 fps", &refresh_delay, 33);
options->insertRadioItem("10 fps", &refresh_delay, 100);
options->insertRadioItem("5 fps", &refresh_delay, 200);
options->insertSeparator();
options->insertRadioItem("1/10 speed", &speed, 2);
options->insertRadioItem("1/2 speed", &speed, 10);
options->insertRadioItem("1x speed", &speed, 20);
options->insertRadioItem("2x speed", &speed, 40);
options->insertRadioItem("5x speed", &speed, 100);
menu->insertItem("&Options",options);
m.statusBar();
QObject::connect(options, SIGNAL(variableChanged(bool*)), &example, SLOT(refresh()));
QObject::connect(options, SIGNAL(variableChanged(int*)), &example, SLOT(refresh()));
QObject::connect(&example, SIGNAL(status(const char*)), m.statusBar(), SLOT(message(const char*)));
m.setCentralWidget(&example);
app.setMainWidget(&m);
m.show();
QTime t;
t.start();
app.exec();
if ( timeit )
debug("%dms",t.elapsed());
return 0;
}
void AbstractTableTabAction::buildMenus(BeanTableFrame* f)
{
TabbedTableItem* item = tabbedTableArray.at(dataTabs->currentIndex());
QMenuBar* menuBar = f->menuBar();
QMenu* fileMenu = new QMenu(tr("File"));
menuBar->addMenu(fileMenu);
// QAction* newItem = new QAction("New Window", this);
// fileMenu->addAction(newItem);
// newItem.addActionListener(new ActionListener() {
// public void actionPerformed(ActionEvent e) {
// actionList.openNewTableWindow(list.getSelectedIndex());
// }
// });
fileMenu->addMenu(new SaveMenu());
QAction* printItem = new QAction(tr("Print Table"), this );
fileMenu->addAction(printItem);
// printItem.addActionListener(new ActionListener() {
// public void actionPerformed(ActionEvent e) {
// try {
// // MessageFormat headerFormat = new MessageFormat(getTitle()); // not used below
// MessageFormat footerFormat = new MessageFormat(getTitle() + " page {0,number}");
// if (item.getStandardTableModel()) {
// item.getDataTable().print(JTable.PrintMode.FIT_WIDTH, NULL, footerFormat);
// } else {
// item.getAAClass().print(JTable.PrintMode.FIT_WIDTH, NULL, footerFormat);
// }
// } catch (java.awt.print.PrinterException e1) {
// log.warn("error printing: " + e1, e1);
// } catch (NullPointerException ex) {
// log.error("Trying to print returned a NPE error");
// }
// }
// });
connect(printItem, SIGNAL(triggered()), this, SLOT(On_printAction_triggered()));
QMenu* viewMenu = new QMenu("View");
menuBar->addMenu(viewMenu);
// for (int i = 0; i < TabbedTableItemListArrayArray.size(); i++) {
// final TabbedTableItemListArray itemList = TabbedTableItemListArrayArray.get(i);
// JMenuItem viewItem = new JMenuItem(itemList.getItemString());
// viewMenu.add(viewItem);
// viewItem.addActionListener(new ActionListener() {
// public void actionPerformed(ActionEvent e) {
// gotoListItem(itemList.getClassAsString());
// }
// });
// }
//f->setMenuBar(menuBar);
try
{
item->getAAClass()->setMenuBar(f);
f->addHelpMenu(item->getAAClass()->helpTarget(), true);
}
catch (Exception ex)
{
log->error("Error when trying to set menu bar for " + /*item->getClassAsString()*/ QString(item->metaObject()->className())+ "\n" + ex.getMessage());
}
// this.revalidate();
}
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 MainWindow::initUI()
{
// Build menu and tool bars
setToolBarsMovable( false );
m_menuBar.setHorizontalStretchable( true );
QMenuBar *mb = new QMenuBar( &m_menuBar );
mb->setMargin( 0 );
// Find toolbar
addToolBar( &m_findBar, QMainWindow::Top, true );
m_findBar.setHorizontalStretchable( true );
m_findEdit = new QLineEdit( &m_findBar );
QWhatsThis::add( m_findEdit, tr( "Type the text to search for here." ) );
m_findBar.setStretchableWidget( m_findEdit );
connect( m_findEdit, SIGNAL(textChanged(const QString&)), this, SLOT(slotFindChanged(const QString&)) );
// Packages menu
QPopupMenu *popup = new QPopupMenu( this );
QAction *a = new QAction( tr( "Update lists" ), Opie::Core::OResource::loadPixmap( "packagemanager/update",
Opie::Core::OResource::SmallIcon ), QString::null, 0, this, 0 );
a->setWhatsThis( tr( "Tap here to update package lists from servers." ) );
connect( a, SIGNAL(activated()), this, SLOT(slotUpdate()) );
a->addTo( popup );
a->addTo( &m_toolBar );
QAction *actionUpgrade = new QAction( tr( "Upgrade" ), Opie::Core::OResource::loadPixmap( "packagemanager/upgrade",
Opie::Core::OResource::SmallIcon ), QString::null, 0, this, 0 );
actionUpgrade->setWhatsThis( tr( "Tap here to upgrade all installed packages if a newer version is available." ) );
connect( actionUpgrade, SIGNAL(activated()), this, SLOT(slotUpgrade()) );
actionUpgrade->addTo( popup );
actionUpgrade->addTo( &m_toolBar );
QPixmap iconDownload = Opie::Core::OResource::loadPixmap( "packagemanager/download", Opie::Core::OResource::SmallIcon );
QPixmap iconRemove = Opie::Core::OResource::loadPixmap( "packagemanager/remove", Opie::Core::OResource::SmallIcon );
QAction *actionDownload = new QAction( tr( "Download" ), iconDownload, QString::null, 0, this, 0 );
actionDownload->setWhatsThis( tr( "Tap here to download the currently selected package(s)." ) );
connect( actionDownload, SIGNAL(activated()), this, SLOT(slotDownload()) );
#ifndef USE_LIBOPKG
actionDownload->addTo( popup );
actionDownload->addTo( &m_toolBar );
#endif
a = new QAction( tr( "Apply changes" ), Opie::Core::OResource::loadPixmap( "packagemanager/apply",
Opie::Core::OResource::SmallIcon ), QString::null, 0, this, 0 );
a->setWhatsThis( tr( "Tap here to install, remove or upgrade currently selected package(s)." ) );
connect( a, SIGNAL(activated()), this, SLOT(slotApply()) );
a->addTo( popup );
a->addTo( &m_toolBar );
a = new QAction( tr( "Install local package" ), Opie::Core::OResource::loadPixmap( "folder",
Opie::Core::OResource::SmallIcon ), QString::null, 0, this, 0 );
a->setWhatsThis( tr( "Tap here to install a package file located on device." ) );
connect( a, SIGNAL(activated()), this, SLOT(slotInstallLocal()) );
a->addTo( popup );
//a->addTo( &m_toolBar );
popup->insertSeparator();
a = new QAction( tr( "Configure" ), Opie::Core::OResource::loadPixmap( "SettingsIcon",
Opie::Core::OResource::SmallIcon ), QString::null, 0, this, 0 );
a->setWhatsThis( tr( "Tap here to configure this application." ) );
connect( a, SIGNAL(activated()), this, SLOT(slotConfigure()) );
a->addTo( popup );
mb->insertItem( tr( "Actions" ), popup );
// View menu
popup = new QPopupMenu( this );
m_actionShowNotInstalled = new QAction( tr( "Show packages not installed" ), QString::null, 0, this, 0 );
m_actionShowNotInstalled->setToggleAction( true );
m_actionShowNotInstalled->setWhatsThis( tr( "Tap here to show packages available which have not been installed." ) );
connect( m_actionShowNotInstalled, SIGNAL(activated()), this, SLOT(slotShowNotInstalled()) );
m_actionShowNotInstalled->addTo( popup );
m_actionShowInstalled = new QAction( tr( "Show installed packages" ), QString::null, 0, this, 0 );
m_actionShowInstalled->setToggleAction( true );
m_actionShowInstalled->setWhatsThis( tr( "Tap here to show packages currently installed on this device." ) );
connect( m_actionShowInstalled, SIGNAL(activated()), this, SLOT(slotShowInstalled()) );
m_actionShowInstalled->addTo( popup );
m_actionShowUpdated = new QAction( tr( "Show updated packages" ), QString::null, 0, this, 0 );
m_actionShowUpdated->setToggleAction( true );
m_actionShowUpdated->setWhatsThis( tr( "Tap here to show packages currently installed on this device which have a newer version available." ) );
connect( m_actionShowUpdated, SIGNAL(activated()), this, SLOT(slotShowUpdated()) );
m_actionShowUpdated->addTo( popup );
popup->insertSeparator();
m_actionFilter = new QAction( tr( "Filter" ), Opie::Core::OResource::loadPixmap( "packagemanager/filter",
Opie::Core::OResource::SmallIcon ), QString::null, 0, this, 0 );
m_actionFilter->setToggleAction( true );
m_actionFilter->setWhatsThis( tr( "Tap here to apply current filter." ) );
connect( m_actionFilter, SIGNAL(toggled(bool)), this, SLOT(slotFilter(bool)) );
m_actionFilter->addTo( popup );
a = new QAction( tr( "Filter settings" ), QString::null, 0, this, 0 );
a->setWhatsThis( tr( "Tap here to change the package filter criteria." ) );
connect( a, SIGNAL(activated()), this, SLOT(slotFilterChange()) );
a->addTo( popup );
popup->insertSeparator();
a = new QAction( tr( "Find" ), Opie::Core::OResource::loadPixmap( "find", Opie::Core::OResource::SmallIcon ),
QString::null, 0, this, 0 );
a->setWhatsThis( tr( "Tap here to search for text in package names." ) );
connect( a, SIGNAL(activated()), this, SLOT(slotFindShowToolbar()) );
a->addTo( popup );
m_actionFindNext = new QAction( tr( "Find next" ), Opie::Core::OResource::loadPixmap( "next",
Opie::Core::OResource::SmallIcon ), QString::null, 0, this, 0 );
m_actionFindNext->setEnabled( false );
m_actionFindNext->setWhatsThis( tr( "Tap here to find the next package name containing the text you are searching for." ) );
connect( m_actionFindNext, SIGNAL(activated()), this, SLOT(slotFindNext()) );
m_actionFindNext->addTo( popup );
m_actionFindNext->addTo( &m_findBar );
mb->insertItem( tr( "View" ), popup );
// Finish find toolbar creation
a = new QAction( QString::null, Opie::Core::OResource::loadPixmap( "close", Opie::Core::OResource::SmallIcon ),
QString::null, 0, this, 0 );
a->setWhatsThis( tr( "Tap here to hide the find toolbar." ) );
connect( a, SIGNAL(activated()), this, SLOT(slotFindHideToolbar()) );
a->addTo( &m_findBar );
m_findBar.hide();
}
SharedPainter::SharedPainter(CSharedPainterScene *canvas, QWidget *parent, Qt::WFlags flags)
: QMainWindow(parent, flags), canvas_(canvas), currPaintItemId_(1), currPacketId_(-1), resizeFreezingFlag_(false), screenShotMode_(false), wroteProgressBar_(NULL)
{
ui.setupUi(this);
ui.painterView->setScene( canvas );
canvas_->setEvent( this );
SharePaintManagerPtr()->registerObserver( this );
SharePaintManagerPtr()->setCanvas( canvas_ );
QMenuBar *menuBar = ui.menuBar;
// Create Menu bar item
{
// File Menu
QMenu* file = new QMenu( "&File", menuBar );
file->addAction( "&Connect", this, SLOT(actionConnect()), Qt::CTRL+Qt::Key_N );
file->addAction( "&Broadcast Channel", this, SLOT(actionBroadcastChannel()), Qt::CTRL+Qt::Key_H );
QMenu* broadCastTypeMenu = file->addMenu( "BroadCast Type" );
broadCastTypeMenu->addAction( "&Server", this, SLOT(actionServerType()), Qt::CTRL+Qt::Key_1 );
broadCastTypeMenu->addAction( "&Client", this, SLOT(actionClientType()), Qt::CTRL+Qt::Key_2 );
file->addSeparator();
file->addAction( "E&xit", this, SLOT(actionExit()), Qt::CTRL+Qt::Key_Q );
menuBar->addMenu( file );
// Edit Menu
QMenu* edit = new QMenu( "&Edit", menuBar );
QMenu* penMenu = edit->addMenu( "Pen Setting" );
penMenu->addAction( "Pen &Width", this, SLOT(actionPenWidth()), Qt::CTRL+Qt::Key_V );
penMenu->addAction( "Pen &Color", this, SLOT(actionPenColor()), Qt::CTRL+Qt::Key_C );
penModeAction_ = edit->addAction( "Pen Mode", this, SLOT(actionPenMode()), Qt::CTRL+Qt::Key_A );
penModeAction_->setCheckable( true );
edit->addAction( "&Text", this, SLOT(actionAddText()), Qt::Key_Enter|Qt::Key_Return );
edit->addAction( "&Screen Shot", this, SLOT(actionScreenShot()), Qt::CTRL+Qt::Key_S );
edit->addSeparator();
edit->addAction( "Clear &Background Image", this, SLOT(actionClearBGImage()), Qt::CTRL+Qt::Key_B );
edit->addAction( "Cl&ear Screen", this, SLOT(actionClearScreen()), Qt::CTRL+Qt::Key_X );
edit->addSeparator();
edit->addAction( "&Undo", this, SLOT(actionUndo()), Qt::CTRL+Qt::Key_Z );
menuBar->addMenu( edit );
}
// create status bar
{
statusBarLabel_ = new QLabel();
broadCastTypeLabel_ = new QLabel();
joinerCountLabel_ = new QLabel();
wroteProgressBar_ = new QProgressBar();
ui.statusBar->addPermanentWidget( broadCastTypeLabel_ );
ui.statusBar->addPermanentWidget( joinerCountLabel_, 1 );
ui.statusBar->addPermanentWidget( wroteProgressBar_ );
ui.statusBar->addPermanentWidget( statusBarLabel_ );
setStatusBar_Network( tr("Not Connected") );
setStatusBar_BroadCastType( tr("None Type") );
setStatusBar_JoinerCnt( 1 ); // my self
}
ui.painterView->setHorizontalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
ui.painterView->setVerticalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
setCursor( Qt::ArrowCursor );
// Pen mode activated..
penModeAction_->setChecked( true );
actionPenMode();
// Key Hooking Timer
keyHookTimer_ = new QTimer(this);
keyHookTimer_->start(20);
connect(keyHookTimer_, SIGNAL(timeout()),this, SLOT(onTimer()));
installEventFilter(this);
// Title
QString orgTitle = windowTitle();
QString newTitle = orgTitle;
newTitle += " Ver ";
newTitle += VERSION_TEXT;
newTitle += ", ";
newTitle += AUTHOR_TEXT;
setWindowTitle( newTitle );
}
BlitzMainWindow::BlitzMainWindow()
: QMainWindow()
{
setWindowTitle(tr("Blitz Effect Test"));
QScrollArea *sa = new QScrollArea(this);
lbl = new QLabel;
sa->setWidget(lbl);
setCentralWidget(sa);
QToolBar *tBar = addToolBar(tr("Effect Options"));
QAction *openAct = tBar->addAction(tr("Open"), this, SLOT(slotOpen()));
QAction *revertAct = tBar->addAction(tr("Revert"), this, SLOT(slotRevert()));
qualityCB = new QCheckBox(tr("High Quality"), tBar);
qualityCB->setChecked(true);
tBar->addWidget(qualityCB);
QMenuBar *mBar = menuBar();
QMenu *fileMnu = mBar->addMenu(tr("File"));
fileMnu->addAction(openAct);
fileMnu->addAction(revertAct);
fileMnu->addSeparator();
fileMnu->addAction(tr("Close"), this, SLOT(close()));
QMenu *effectMnu = mBar->addMenu(tr("Effects"));
effectMnu->addAction(tr("Grayscale (MMX)"), this, SLOT(slotGrayscale()));
effectMnu->addAction(tr("Invert (MMX)"), this, SLOT(slotInvert()));
QMenu *subMnu = effectMnu->addMenu(tr("Threshold"));
subMnu->addAction(tr("Threshold (Default)"), this, SLOT(slotThreshold()));
subMnu->addAction(tr("Threshold (Red)"), this, SLOT(slotThresholdRed()));
subMnu->addAction(tr("Threshold (Green)"), this, SLOT(slotThresholdGreen()));
subMnu->addAction(tr("Threshold (Blue)"), this, SLOT(slotThresholdBlue()));
subMnu->addAction(tr("Threshold (Alpha)"), this, SLOT(slotThresholdAlpha()));
subMnu = effectMnu->addMenu(tr("Intensity (MMX)"));
subMnu->addAction(tr("Increment Intensity"), this, SLOT(slotIncIntensity()));
subMnu->addAction(tr("Decrement Intensity"), this, SLOT(slotDecIntensity()));
subMnu->addSeparator();
subMnu->addAction(tr("Increment Red Intensity"), this, SLOT(slotIncRedIntensity()));
subMnu->addAction(tr("Decrement Red Intensity"), this, SLOT(slotDecRedIntensity()));
subMnu->addAction(tr("Increment Green Intensity"), this, SLOT(slotIncGreenIntensity()));
subMnu->addAction(tr("Decrement Green Intensity"), this, SLOT(slotDecGreenIntensity()));
subMnu->addAction(tr("Increment Blue Intensity"), this, SLOT(slotIncBlueIntensity()));
subMnu->addAction(tr("Decrement Blue Intensity"), this, SLOT(slotDecBlueIntensity()));
effectMnu->addSeparator();
effectMnu->addAction(tr("Spiff"), this, SLOT(slotSpiff()));
effectMnu->addAction(tr("Dull"), this, SLOT(slotDull()));
effectMnu->addSeparator();
effectMnu->addAction(tr("Desaturate"), this, SLOT(slotDesaturate()));
effectMnu->addAction(tr("Fade"), this, SLOT(slotFade()));
effectMnu->addAction(tr("Flatten"), this, SLOT(slotFlatten()));
effectMnu->addSeparator();
effectMnu->addAction(tr("Sharpen"), this, SLOT(slotSharpen()));
effectMnu->addAction(tr("Blur"), this, SLOT(slotBlur()));
effectMnu->addAction(tr("Gaussian Sharpen (MMX)"), this, SLOT(slotGaussianSharpen()));
effectMnu->addAction(tr("Gaussian Blur (MMX)"), this, SLOT(slotGaussianBlur()));
effectMnu->addSeparator();
effectMnu->addAction(tr("Sobel Edge (MMX)"), this, SLOT(slotEdge()));
effectMnu->addAction(tr("Convolve Edge (MMX)"), this, SLOT(slotConvolveEdge()));
effectMnu->addSeparator();
effectMnu->addAction(tr("Equalize"), this, SLOT(slotEqualize()));
effectMnu->addAction(tr("Normalize"), this, SLOT(slotNormalize()));
effectMnu->addAction(tr("Despeckle"), this, SLOT(slotDespeckle()));
effectMnu->addSeparator();
effectMnu->addAction(tr("Charcoal"), this, SLOT(slotCharcoal()));
effectMnu->addAction(tr("Swirl"), this, SLOT(slotSwirl()));
effectMnu->addAction(tr("Implode"), this, SLOT(slotImplode()));
effectMnu->addAction(tr("Wave"), this, SLOT(slotWave()));
effectMnu->addAction(tr("Oil Paint"), this, SLOT(slotOilpaint()));
effectMnu->addAction(tr("Emboss"), this, SLOT(slotEmboss()));
effectMnu->addSeparator();
effectMnu->addAction(tr("Smoothscale Filtered..."), this, SLOT(slotSmoothscaleFiltered()));
effectMnu->addSeparator();
effectMnu->addAction(tr("Modulate..."), this, SLOT(slotModulate()));
effectMnu->addSeparator();
effectMnu->addAction(tr("Gradient..."), this, SLOT(slotGradient()));
effectMnu->addAction(tr("Unbalanced Gradient..."), this, SLOT(slotUnbalancedGradient()));
effectMnu->addAction(tr("8bpp Gradient..."), this, SLOT(slotGrayscaleGradient()));
effectMnu->addAction(tr("8bpp Unbalanced Gradient..."), this, SLOT(slotGrayscaleUnbalancedGradient()));
resize(sizeHint());
}
/*private*/ void ImageIndexEditor::init(Editor* /*editor*/) {
QMenuBar* menuBar = new QMenuBar();
QMenu* findIcon = new QMenu(tr("File"));
menuBar->addMenu(findIcon);
QAction* storeItem = new QAction(tr("Store Image Index"),this);
findIcon->addAction(storeItem);
// storeItem.addActionListener(new ActionListener() {
// /*public*/ void actionPerformed(ActionEvent event) {
// storeImageIndex();
// }
// });
connect(storeItem, SIGNAL(triggered()), this, SLOT(storeImageIndex()));
findIcon->addSeparator();
QAction* openItem = new QAction(tr("Open a File System Directory"), this);
// openItem.addActionListener(new ActionListener() {
// /*public*/ void actionPerformed(ActionEvent e) {
// DirectorySearcher.instance().openDirectory(false);
// }
// });
findIcon->addAction(openItem);
connect(openItem, SIGNAL(triggered()), this, SLOT(openItem_triggered()));
QMenu* editMenu = new QMenu(tr("Edit"));
menuBar->addMenu(editMenu);
QAction* addItem = new QAction(tr("Add Node"),this);
// addItem.addActionListener (new ActionListener () {
// /*public*/ void actionPerformed(ActionEvent e) {
// addNode();
// }
// });
connect(addItem, SIGNAL(triggered()), this, SLOT(addNode()));
editMenu->addAction(addItem);
QAction* renameItem = new QAction(tr("Rename Node"), this);
// renameItem.addActionListener (new ActionListener () {
// /*public*/ void actionPerformed(ActionEvent e) {
// renameNode();
// }
// });
editMenu->addAction(renameItem);
connect(renameItem, SIGNAL(triggered()), this, SLOT(renameNode()));
QAction* deleteItem = new QAction(tr("Delete Node"), this);
// deleteItem.addActionListener (new ActionListener () {
// /*public*/ void actionPerformed(ActionEvent e) {
// deleteNode();
// }
// });
connect(deleteItem, SIGNAL(triggered()), this, SLOT(deleteNode()));
editMenu->addAction(deleteItem);
setMenuBar(menuBar);
addHelpMenu("package.jmri.jmrit.catalog->ImageIndex", true);
QWidget* mainPanel = new QWidget();
mainPanel->setLayout(new QVBoxLayout(mainPanel/*, BoxLayout.Y_AXIS*/));
QWidget* labelPanel = new QWidget();
labelPanel->setLayout(new QHBoxLayout());
// QString msg = java.text.MessageFormat.format(
// tr("dragIcons"),
// new Object[] {tr("defaultCatalog"), tr("ImageIndex")});
QString msg = tr("Drag icons from the %1 viewing panel to nodes in the %2 tree.").arg("Default Catalogues:").arg("Image Index:");
labelPanel->layout()->addWidget(new QLabel(msg/*, SwingConstants.LEFT*/));
mainPanel->layout()->addWidget(labelPanel);
QWidget* catalogsPanel = new QWidget();
catalogsPanel->setLayout(new QHBoxLayout(catalogsPanel/*, BoxLayout.X_AXIS*/));
catalogsPanel->layout()->addWidget(makeCatalogPanel());
// catalogsPanel->layout()->addWidget(new JSeparator(SwingConstants.VERTICAL));
QFrame* line = new QFrame(/*centralwidget()*/this);
line->setObjectName(QString::fromUtf8("line"));
line->setFrameShape(QFrame::HLine);
line->setFrameShadow(QFrame::Sunken);
catalogsPanel->layout()->addWidget(line);
catalogsPanel->layout()->addWidget(makeIndexPanel());
mainPanel->layout()->addWidget(catalogsPanel);
if(centralWidget()== NULL)
{
QWidget* centralWidget = new QWidget();
centralWidget->setLayout(new QVBoxLayout());
setCentralWidget(centralWidget);
}
centralWidget()->layout()->addWidget(mainPanel);
// when this window closes, check for saving
// addWindowListener(new java.awt.event.WindowAdapter() {
// /*public*/ void windowClosing(java.awt.event.WindowEvent e) {
// DirectorySearcher.instance().close();
// checkImageIndex();
// }
// });
addWindowListener(new IIEWindowListener(this));
//setLocation(10, 200);
pack();
setVisible(true);
}
GLObjectWindow::GLObjectWindow( QWidget* parent, const char* name )
: QWidget( parent, name )
{
// Create a menu
file = new QPopupMenu( this );
file->setCheckable( TRUE );
file->insertItem( "Grab Frame Buffer", this, SLOT(grabFrameBuffer()) );
file->insertItem( "Render Pixmap", this, SLOT(makePixmap()) );
file->insertItem( "Render Pixmap Hidden", this, SLOT(makePixmapHidden()) );
file->insertSeparator();
fixMenuItemId = file->insertItem( "Use Fixed Pixmap Size", this,
SLOT(useFixedPixmapSize()) );
file->insertSeparator();
insertMenuItemId = file->insertItem( "Insert Pixmap Here", this,
SLOT(makePixmapForMenu()) );
file->insertSeparator();
file->insertItem( "Exit", qApp, SLOT(quit()), CTRL+Key_Q );
// Create a menu bar
QMenuBar *m = new QMenuBar( this );
m->setSeparator( QMenuBar::InWindowsStyle );
m->insertItem("&File", file );
// Create nice frames to put around the OpenGL widgets
QFrame* f1 = new QFrame( this, "frame1" );
f1->setFrameStyle( QFrame::Sunken | QFrame::Panel );
f1->setLineWidth( 2 );
// Create an OpenGL widget
c1 = new GLBox( f1, "glbox1");
// Create a label that can display the pixmap
lb = new QLabel( this, "pixlabel" );
lb->setFrameStyle( QFrame::Sunken | QFrame::Panel );
lb->setLineWidth( 2 );
lb->setAlignment( AlignCenter );
lb->setMargin( 0 );
lb->setIndent( 0 );
// Create the three sliders; one for each rotation axis
QSlider* x = new QSlider ( 0, 360, 60, 0, QSlider::Vertical, this, "xsl" );
x->setTickmarks( QSlider::Left );
connect( x, SIGNAL(valueChanged(int)), c1, SLOT(setXRotation(int)) );
QSlider* y = new QSlider ( 0, 360, 60, 0, QSlider::Vertical, this, "ysl" );
y->setTickmarks( QSlider::Left );
connect( y, SIGNAL(valueChanged(int)), c1, SLOT(setYRotation(int)) );
QSlider* z = new QSlider ( 0, 360, 60, 0, QSlider::Vertical, this, "zsl" );
z->setTickmarks( QSlider::Left );
connect( z, SIGNAL(valueChanged(int)), c1, SLOT(setZRotation(int)) );
// Now that we have all the widgets, put them into a nice layout
// Put the sliders on top of each other
QVBoxLayout* vlayout = new QVBoxLayout( 20, "vlayout");
vlayout->addWidget( x );
vlayout->addWidget( y );
vlayout->addWidget( z );
// Put the GL widget inside the frame
QHBoxLayout* flayout1 = new QHBoxLayout( f1, 2, 2, "flayout1");
flayout1->addWidget( c1, 1 );
// Top level layout, puts the sliders to the left of the frame/GL widget
QHBoxLayout* hlayout = new QHBoxLayout( this, 20, 20, "hlayout");
hlayout->setMenuBar( m );
hlayout->addLayout( vlayout );
hlayout->addWidget( f1, 1 );
hlayout->addWidget( lb, 1 );
}
MainWindow::MainWindow(QUrl url) :
GwtWindow(false, false, url, NULL),
menuCallback_(this),
gwtCallback_(this, this),
pSessionLauncher_(NULL),
pCurrentSessionProcess_(NULL)
{
quitConfirmed_ = false;
pToolbar_->setVisible(false);
// initialize zoom levels
zoomLevels_.push_back(1.0);
zoomLevels_.push_back(1.1);
zoomLevels_.push_back(1.20);
zoomLevels_.push_back(1.30);
zoomLevels_.push_back(1.40);
zoomLevels_.push_back(1.50);
zoomLevels_.push_back(1.75);
zoomLevels_.push_back(2.00);
// Dummy menu bar to deal with the fact that
// the real menu bar isn't ready until well
// after startup.
QMenuBar* pMainMenuStub = new QMenuBar(this);
pMainMenuStub->addMenu(QString::fromUtf8("File"));
pMainMenuStub->addMenu(QString::fromUtf8("Edit"));
pMainMenuStub->addMenu(QString::fromUtf8("Code"));
pMainMenuStub->addMenu(QString::fromUtf8("View"));
pMainMenuStub->addMenu(QString::fromUtf8("Plots"));
pMainMenuStub->addMenu(QString::fromUtf8("Session"));
pMainMenuStub->addMenu(QString::fromUtf8("Build"));
pMainMenuStub->addMenu(QString::fromUtf8("Debug"));
pMainMenuStub->addMenu(QString::fromUtf8("Tools"));
pMainMenuStub->addMenu(QString::fromUtf8("Help"));
setMenuBar(pMainMenuStub);
connect(&menuCallback_, SIGNAL(menuBarCompleted(QMenuBar*)),
this, SLOT(setMenuBar(QMenuBar*)));
connect(&menuCallback_, SIGNAL(commandInvoked(QString)),
this, SLOT(invokeCommand(QString)));
connect(&menuCallback_, SIGNAL(manageCommand(QString,QAction*)),
this, SLOT(manageCommand(QString,QAction*)));
connect(&menuCallback_, SIGNAL(zoomIn()), this, SLOT(zoomIn()));
connect(&menuCallback_, SIGNAL(zoomOut()), this, SLOT(zoomOut()));
connect(&gwtCallback_, SIGNAL(workbenchInitialized()),
this, SIGNAL(firstWorkbenchInitialized()));
connect(&gwtCallback_, SIGNAL(workbenchInitialized()),
this, SLOT(onWorkbenchInitialized()));
connect(webView(), SIGNAL(onCloseWindowShortcut()),
this, SLOT(onCloseWindowShortcut()));
connect(qApp, SIGNAL(commitDataRequest(QSessionManager&)),
this, SLOT(commitDataRequest(QSessionManager&)),
Qt::DirectConnection);
setWindowIcon(QIcon(QString::fromAscii(":/icons/RStudio.ico")));
setWindowTitle(QString::fromAscii("RStudio"));
#ifdef Q_OS_MAC
QMenuBar* pDefaultMenu = new QMenuBar();
pDefaultMenu->addMenu(new WindowMenu());
#endif
desktop::enableFullscreenMode(this, true);
//setContentsMargins(10000, 0, -10000, 0);
setStyleSheet(QString::fromAscii("QMainWindow { background: #e1e2e5; }"));
}
//==============================================================================
// Create MainWindow
//==============================================================================
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow),
bgColor (QColor(255,255,255)),
logoPath(logoDefaultPath),
usbPath (usbDefaultPath),
rdPath (rdDefaultPath)
{
ui->setupUi(this);
setAttribute(Qt::WA_DeleteOnClose);
setWindowTitle("BootLogo Changer for Maemo 5");
shell = 0;
rdShow = false;
QMenuBar *menu = menuBar();
enableAnySizes = new QAction("Allow any image sizes", this);
enableAnySizes->setCheckable(true);
connect(enableAnySizes, SIGNAL(triggered(bool)),
this, SLOT(changeImageLimit(bool)));
menu->addAction(enableAnySizes);
menu->addAction("About", this, SLOT(showAbout()));
menu->addAction("About Qt", qApp, SLOT(aboutQt()));
ui->stack->setCurrentWidget(ui->centralPage);
// Central/Left/Right layouts
ui->rightTopLayout->setContentsMargins(sizeInc, 0, 0, 0);
// Right buttons
// Background button
ui->bgButton->setFixedWidth(ui->bgButton->sizeHint().width() + sizeStep);
connect(ui->bgButton, SIGNAL(clicked()), this, SLOT(bgBtnClicked()));
ui->bgButton->installEventFilter(this);
ui->rightTopLayout->setAlignment(ui->bgButton, Qt::AlignVCenter | Qt::AlignRight);
// Logo button
ui->logoButton->setFixedWidth(ui->bgButton->sizeHint().width() + sizeStep);
connect(ui->logoButton, SIGNAL(clicked()), this, SLOT(logoBtnClicked()));
ui->logoButton->installEventFilter(this);
ui->rightTopLayout->setAlignment(ui->logoButton, Qt::AlignVCenter | Qt::AlignRight);
// USB button
ui->usbButton->setFixedWidth(ui->bgButton->sizeHint().width() + sizeStep);
connect(ui->usbButton, SIGNAL(clicked()), this, SLOT(usbBtnClicked()));
ui->usbButton->installEventFilter(this);
ui->rightTopLayout->setAlignment(ui->usbButton, Qt::AlignVCenter | Qt::AlignRight);
// RD button
ui->rdButton->setFixedWidth(ui->bgButton->sizeHint().width() + sizeStep);
connect(ui->rdButton, SIGNAL(clicked()), this, SLOT(rdBtnClicked()));
ui->rdButton->installEventFilter(this);
ui->rightTopLayout->setAlignment(ui->rdButton, Qt::AlignVCenter | Qt::AlignRight);
// Preview button
connect(ui->previewButton, SIGNAL(clicked()), this, SLOT(showPreview()));
// Apply button
connect(ui->applyButton, SIGNAL(clicked()), this, SLOT(applyBtnClicked()));
// Create info widgets for buttons
// Create Background info widget
createBgInfo();
// Create Logo info widget
createLogoInfo();
// Create USB info widget
createUsbInfo();
// Create RD info widget
createRdInfo();
// Create Preview widget
createPreview();
// Create Apply widget
createApply();
}
void MainWindow::run()
{
// Allow the user to enable or disable debugging
// We handle this before the other parameters, as it may affect some
// early debug messages
QLoggingCategory::defaultCategory()->setEnabled(QtDebugMsg, parser->isSet("debug"));
readSettings();
setAttribute(Qt::WA_DeleteOnClose, true);
// menu structure
QMenuBar *menuBar = QMainWindow::menuBar();
collection = new KActionCollection(this);
QMenu *menu = new QMenu(i18n("&File"), this);
menuBar->addMenu(menu);
QAction *action = KStandardAction::open(this, SLOT(open()), collection);
menu->addAction(collection->addAction(QLatin1String("file_open"), action));
action = new QAction(QIcon::fromTheme(QLatin1String("text-html"), QIcon(":text-html")),
i18nc("@action:inmenu", "Open URL..."), collection);
action->setShortcut(Qt::CTRL | Qt::Key_U);
connect(action, SIGNAL(triggered(bool)), this, SLOT(openUrl()));
menu->addAction(collection->addAction(QLatin1String("file_open_url"), action));
actionOpenRecent = KStandardAction::openRecent(this, SLOT(openUrl(QUrl)), collection);
actionOpenRecent->loadEntries(KSharedConfig::openConfig()->group("Recent Files"));
menu->addAction(collection->addAction(QLatin1String("file_open_recent"), actionOpenRecent));
menu->addSeparator();
action = new QAction(QIcon::fromTheme(QLatin1String("media-optical-audio"), QIcon(":media-optical-audio")), i18n("Play Audio CD"), collection);
connect(action, SIGNAL(triggered(bool)), this, SLOT(openAudioCd()));
menu->addAction(collection->addAction(QLatin1String("file_play_audiocd"), action));
action = new QAction(QIcon::fromTheme(QLatin1String("media-optical"), QIcon(":media-optical")), i18n("Play Video CD"), collection);
connect(action, SIGNAL(triggered(bool)), this, SLOT(openVideoCd()));
menu->addAction(collection->addAction(QLatin1String("file_play_videocd"), action));
action = new QAction(QIcon::fromTheme(QLatin1String("media-optical"), QIcon(":media-optical")), i18n("Play DVD"), collection);
connect(action, SIGNAL(triggered(bool)), this, SLOT(openDvd()));
menu->addAction(collection->addAction(QLatin1String("file_play_dvd"), action));
action = new QAction(QIcon::fromTheme(QLatin1String("media-optical"), QIcon(":media-optical")), i18nc("@action:inmenu", "Play DVD Folder"),
collection);
connect(action, SIGNAL(triggered()), this, SLOT(playDvdFolder()));
menu->addAction(collection->addAction(QLatin1String("file_play_dvd_folder"), action));
menu->addSeparator();
action = KStandardAction::quit(this, SLOT(close()), collection);
menu->addAction(collection->addAction(QLatin1String("file_quit"), action));
QMenu *playerMenu = new QMenu(i18n("&Playback"), this);
menuBar->addMenu(playerMenu);
QMenu *playlistMenu = new QMenu(i18nc("menu bar", "Play&list"), this);
menuBar->addMenu(playlistMenu);
#if HAVE_DVB == 1
QMenu *dvbMenu = new QMenu(i18n("&Television"), this);
menuBar->addMenu(dvbMenu);
#endif /* HAVE_DVB == 1 */
menu = new QMenu(i18n("&Settings"), this);
menuBar->addMenu(menu);
action = KStandardAction::keyBindings(this, SLOT(configureKeys()), collection);
menu->addAction(collection->addAction(QLatin1String("settings_keys"), action));
action = KStandardAction::preferences(this, SLOT(configureKaffeine()), collection);
menu->addAction(collection->addAction(QLatin1String("settings_kaffeine"), action));
menuBar->addSeparator();
KHelpMenu *helpMenu = new KHelpMenu(this, *aboutData);
menuBar->addMenu(helpMenu->menu());
// navigation bar - keep in sync with TabIndex enum!
navigationBar = new QToolBar(QLatin1String("navigation_bar"));
this->addToolBar(Qt::LeftToolBarArea, navigationBar);
connect(navigationBar, SIGNAL(orientationChanged(Qt::Orientation)),
this, SLOT(navigationBarOrientationChanged(Qt::Orientation)));
tabBar = new QTabBar(navigationBar);
tabBar->addTab(QIcon::fromTheme(QLatin1String("start-here-kde"), QIcon(":start-here-kde")), i18n("Start"));
tabBar->addTab(QIcon::fromTheme(QLatin1String("kaffeine"), QIcon(":kaffeine")), i18n("Playback"));
tabBar->addTab(QIcon::fromTheme(QLatin1String("view-media-playlist"), QIcon(":view-media-playlist")), i18n("Playlist"));
#if HAVE_DVB == 1
tabBar->addTab(QIcon::fromTheme(QLatin1String("video-television"), QIcon(":video-television")), i18n("Television"));
#endif /* HAVE_DVB == 1 */
tabBar->setShape(QTabBar::RoundedWest);
tabBar->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
connect(tabBar, SIGNAL(currentChanged(int)), this, SLOT(activateTab(int)));
navigationBar->addWidget(tabBar);
// control bar
controlBar = new QToolBar(QLatin1String("control_bar"));
this->addToolBar(Qt::BottomToolBarArea, controlBar);
controlBar->setToolButtonStyle(Qt::ToolButtonIconOnly);
autoHideControlBar = false;
cursorHideTimer = new QTimer(this);
cursorHideTimer->setInterval(1500);
cursorHideTimer->setSingleShot(true);
connect(cursorHideTimer, SIGNAL(timeout()), this, SLOT(hideCursor()));
// main area
QWidget *widget = new QWidget(this);
stackedLayout = new StackedLayout(widget);
setCentralWidget(widget);
mediaWidget = new MediaWidget(playerMenu, controlBar, collection, widget);
connect(mediaWidget, SIGNAL(displayModeChanged()), this, SLOT(displayModeChanged()));
connect(mediaWidget, SIGNAL(changeCaption(QString)), this, SLOT(setWindowTitle(QString)));
connect(mediaWidget, SIGNAL(resizeToVideo(MediaWidget::ResizeFactor)),
this, SLOT(resizeToVideo(MediaWidget::ResizeFactor)));
// tabs - keep in sync with TabIndex enum!
TabBase *startTab = new StartTab(this);
tabs.append(startTab);
stackedLayout->addWidget(startTab);
playerTab = new PlayerTab(mediaWidget);
playerTab->activate();
tabs.append(playerTab);
stackedLayout->addWidget(playerTab);
playlistTab = new PlaylistTab(playlistMenu, collection, mediaWidget);
tabs.append(playlistTab);
stackedLayout->addWidget(playlistTab);
#if HAVE_DVB == 1
dvbTab = new DvbTab(dvbMenu, collection, mediaWidget);
connect(this, SIGNAL(mayCloseApplication(bool*,QWidget*)),
dvbTab, SLOT(mayCloseApplication(bool*,QWidget*)));
tabs.append(dvbTab);
stackedLayout->addWidget(dvbTab);
#endif /* HAVE_DVB == 1 */
currentTabIndex = StartTabId;
// actions also have to work if the menu bar is hidden (fullscreen)
collection->addAssociatedWidget(this);
// restore custom key bindings
collection->readSettings();
// Tray menu
menu = new QMenu(i18n("Kaffeine"), this);
action = new QAction(i18n("Play &File"), this);
connect(action, SIGNAL(triggered(bool)), this, SLOT(open()));
menu->addAction(action);
action = new QAction(i18n("Play &Audio CD"), this);
connect(action, SIGNAL(triggered(bool)), this, SLOT(openAudioCd()));
menu->addAction(action);
action = new QAction(i18n("Play &Video CD"), this);
connect(action, SIGNAL(triggered(bool)), this, SLOT(openVideoCd()));
menu->addAction(action);
action = new QAction(i18n("Play &DVD"), this);
connect(action, SIGNAL(triggered(bool)), this, SLOT(openDvd()));
menu->addAction(action);
#if HAVE_DVB == 1
action = new QAction(i18n("&Watch Digital TV"), this);
connect(action, SIGNAL(triggered(bool)), this, SLOT(playDvb()));
menu->addAction(action);
#endif
action = new QAction(i18n("&Quit"), this);
connect(action, SIGNAL(triggered(bool)), this, SLOT(close()));
menu->addAction(action);
// Tray Icon and its menu
QMenu *trayMenu = new QMenu(this);
trayIcon = new QSystemTrayIcon(this);
trayIcon->setContextMenu(trayMenu);
trayIcon->setIcon(QIcon::fromTheme(QLatin1String("kaffeine"), QIcon(":kaffeine")));
trayIcon->setToolTip(i18n("Kaffeine"));
trayIcon->setContextMenu(menu);
// make sure that the bars are visible (fullscreen -> quit -> restore -> hidden)
menuBar->show();
navigationBar->show();
controlBar->show();
trayIcon->show();
// workaround setAutoSaveSettings() which doesn't accept "IconOnly" as initial state
controlBar->setToolButtonStyle(Qt::ToolButtonIconOnly);
// initialize random number generator
qsrand(QTime(0, 0, 0).msecsTo(QTime::currentTime()));
// initialize dbus objects
QDBusConnection::sessionBus().registerObject(QLatin1String("/"), new MprisRootObject(this),
QDBusConnection::ExportAllContents);
QDBusConnection::sessionBus().registerObject(QLatin1String("/Player"),
new MprisPlayerObject(this, mediaWidget, playlistTab, this),
QDBusConnection::ExportAllContents);
QDBusConnection::sessionBus().registerObject(QLatin1String("/TrackList"),
new MprisTrackListObject(playlistTab, this), QDBusConnection::ExportAllContents);
#if HAVE_DVB == 1
QDBusConnection::sessionBus().registerObject(QLatin1String("/Television"),
new DBusTelevisionObject(dvbTab, this), QDBusConnection::ExportAllContents);
#endif /* HAVE_DVB == 1 */
QDBusConnection::sessionBus().registerService(QLatin1String("org.mpris.kaffeine"));
show();
// set display mode
switch (Configuration::instance()->getStartupDisplayMode()) {
case Configuration::StartupNormalMode:
// nothing to do
break;
case Configuration::StartupMinimalMode:
mediaWidget->setDisplayMode(MediaWidget::MinimalMode);
break;
case Configuration::StartupFullScreenMode:
mediaWidget->setDisplayMode(MediaWidget::FullScreenMode);
break;
case Configuration::StartupRememberLastSetting: {
int value = KSharedConfig::openConfig()->group("MainWindow").readEntry("DisplayMode", 0);
switch (value) {
case 0:
// nothing to do
break;
case 1:
mediaWidget->setDisplayMode(MediaWidget::MinimalMode);
break;
case 2:
mediaWidget->setDisplayMode(MediaWidget::FullScreenMode);
break;
}
break;
}
}
parseArgs();
}
ViewerWindow::ViewerWindow(QWidget* parent, Qt::WindowFlags flags)
: QMainWindow(parent, flags)
, gameData(nullptr)
, gameWorld(nullptr)
, renderer(nullptr)
{
setMinimumSize(640, 480);
QMenuBar* mb = this->menuBar();
QMenu* file = mb->addMenu("&File");
file->addAction("Open &Game", this, SLOT(loadGame()));
file->addSeparator();
for(int i = 0; i < MaxRecentGames; ++i) {
QAction* r = file->addAction("");
recentGames.append(r);
connect(r, SIGNAL(triggered()), SLOT(openRecent()));
}
recentSep = file->addSeparator();
auto ex = file->addAction("E&xit");
ex->setShortcut(QKeySequence::Quit);
connect(ex, SIGNAL(triggered()), QApplication::instance(), SLOT(closeAllWindows()));
//----------------------- View Mode setup
viewerWidget = new ViewerWidget;
viewerWidget->context()->makeCurrent();
connect(this, SIGNAL(loadedData(GameWorld*)), viewerWidget, SLOT(dataLoaded(GameWorld*)));
//------------- Object Viewer
m_views[ViewMode::Object] = new ObjectViewer(viewerWidget);
m_viewNames[ViewMode::Object] = "Objects";
//------------- Model Viewer
m_views[ViewMode::Model] = new ModelViewer(viewerWidget);
m_viewNames[ViewMode::Model] = "Model";
//------------- World Viewer
m_views[ViewMode::World] = new WorldViewer(viewerWidget);
m_viewNames[ViewMode::World] = "World";
//------------- display mode switching
viewSwitcher = new QStackedWidget;
auto signalMapper = new QSignalMapper(this);
auto switchPanel = new QVBoxLayout();
int i = 0;
for(auto viewer : m_views) {
viewSwitcher->addWidget(viewer);
connect(this, SIGNAL(loadedData(GameWorld*)), viewer, SLOT(showData(GameWorld*)));
auto viewerButton = new QPushButton(m_viewNames[i].c_str());
signalMapper->setMapping(m_views[i], i);
signalMapper->setMapping(viewerButton, i);
connect(viewerButton, SIGNAL(clicked()), signalMapper, SLOT(map()));
switchPanel->addWidget(viewerButton);
i++;
}
// Map world viewer loading placements to switch to the world viewer
connect(m_views[ViewMode::World], SIGNAL(placementsLoaded(QString)), signalMapper, SLOT(map()));
switchView(ViewMode::Object);
connect(m_views[ViewMode::Object], SIGNAL(showObjectModel(uint16_t)), this, SLOT(showObjectModel(uint16_t)));
connect(m_views[ViewMode::Object], SIGNAL(showObjectModel(uint16_t)), m_views[ViewMode::Model], SLOT(showObject(uint16_t)));
connect(this, SIGNAL(loadAnimations(QString)), m_views[ViewMode::Model], SLOT(loadAnimations(QString)));
connect(signalMapper, SIGNAL(mapped(int)), this, SLOT(switchView(int)));
connect(signalMapper, SIGNAL(mapped(int)), viewSwitcher, SLOT(setCurrentIndex(int)));
switchPanel->addStretch();
auto mainlayout = new QHBoxLayout();
mainlayout->addLayout(switchPanel);
mainlayout->addWidget(viewSwitcher);
auto mainwidget = new QWidget();
mainwidget->setLayout(mainlayout);
QMenu* data = mb->addMenu("&Data");
//data->addAction("Export &Model", objectViewer, SLOT(exportModel()));
QMenu* anim = mb->addMenu("&Animation");
anim->addAction("Load &Animations", this, SLOT(openAnimations()));
QMenu* map = mb->addMenu("&Map");
map->addAction("Load IPL", m_views[ViewMode::World], SLOT(loadPlacements()));
this->setCentralWidget(mainwidget);
updateRecentGames();
}