Attachments::Attachments( TagWorld *w, Item* i ) :
world( w ), item( i )
{
attList = new QListWidget();
QToolBar *tools = new QToolBar();
actions = new QActionGroup(this);
addAction = actions->addAction( "+" );
rmAction = actions->addAction( "-" );
editAction = actions->addAction( "Edit" );
openAction = actions->addAction( "Open" );
tools->addActions(actions->actions());
QVBoxLayout *box = new QVBoxLayout();
box->addWidget(tools);
box->addWidget(attList);
box->setContentsMargins(0,0,0,0);
box->setSpacing(0);
setLayout( box );
attList->setContextMenuPolicy( Qt::CustomContextMenu );
setWindowTitle( "New attachment" );
connect(addAction, SIGNAL(triggered()), this, SLOT(add()));
connect(rmAction, SIGNAL(triggered()), this, SLOT(remove()));
connect(editAction, SIGNAL(triggered()), this, SLOT(edit()));
connect(attList, SIGNAL(itemDoubleClicked(QListWidgetItem*)),
this, SLOT(edit()));
connect(attList, SIGNAL(customContextMenuRequested(const QPoint &)),
this, SLOT(contextMenu(const QPoint &)));
setItem( i );
}
void IdealController::addView(Qt::DockWidgetArea area, View* view)
{
IdealDockWidget *dock = new IdealDockWidget(this, m_mainWindow);
// dock object name is used to store toolview settings
QString dockObjectName = view->document()->title();
// support different configuration for same docks opened in different areas
if (m_mainWindow->area())
dockObjectName += '_' + m_mainWindow->area()->objectName();
dock->setObjectName(dockObjectName);
KAcceleratorManager::setNoAccel(dock);
QWidget *w = view->widget(dock);
if (w->parent() == 0)
{
/* Could happen when we're moving the widget from
one IdealDockWidget to another. See moveView below.
In this case, we need to reparent the widget. */
w->setParent(dock);
}
QList<QAction *> toolBarActions = view->toolBarActions();
if (toolBarActions.isEmpty()) {
dock->setWidget(w);
} else {
QMainWindow *toolView = new QMainWindow();
QToolBar *toolBar = new QToolBar(toolView);
int iconSize = m_mainWindow->style()->pixelMetric(QStyle::PM_SmallIconSize);
toolBar->setIconSize(QSize(iconSize, iconSize));
toolBar->setToolButtonStyle(Qt::ToolButtonIconOnly);
toolBar->setWindowTitle(i18n("%1 Tool Bar", w->windowTitle()));
toolBar->setFloatable(false);
toolBar->setMovable(false);
toolBar->addActions(toolBarActions);
toolView->setCentralWidget(w);
toolView->addToolBar(toolBar);
dock->setWidget(toolView);
}
dock->setWindowTitle(view->widget()->windowTitle());
dock->setWindowIcon(view->widget()->windowIcon());
dock->setFocusProxy(dock->widget());
if (IdealButtonBarWidget* bar = barForDockArea(area)) {
QAction* action = bar->addWidget(
view->document()->title(), dock,
static_cast<MainWindow*>(parent())->area(), view);
m_dockwidget_to_action[dock] = m_view_to_action[view] = action;
m_docks->addAction(action);
connect(dock, &IdealDockWidget::closeRequested, action, &QAction::toggle);
}
connect(dock, &IdealDockWidget::dockLocationChanged, this, &IdealController::dockLocationChanged);
dock->hide();
docks.insert(dock);
}
iscore::GUIElements ApplicationPlugin::makeGUIElements()
{
GUIElements e;
QToolBar* bar = new QToolBar;
bar->addActions({m_move, m_scale, m_rotate});
e.toolbars.emplace_back(bar, StringKey<iscore::Toolbar>("Space"), 0, 5);
return e;
}
NavigationWidget::NavigationWidget(QWidget* parent) :
BaseWidget(parent, "NavigationWidget", "Navigation Properties"),
mVerticalLayout(new QVBoxLayout(this)),
mCameraGroupBox(new QGroupBox(tr("Camera Style"), this)),
mCameraGroupLayout(new QVBoxLayout())
{
this->setToolTip("Camera follow style");
//camera setttings
mCameraGroupBox->setLayout(mCameraGroupLayout);
QToolBar* toolBar = new QToolBar(this);
mCameraGroupLayout->addWidget(toolBar);
toolBar->addActions(viewService()->createInteractorStyleActionGroup()->actions());
QWidget* toolOffsetWidget = new SliderGroupWidget(this, DoublePropertyActiveToolOffset::create());
//layout
this->setLayout(mVerticalLayout);
mVerticalLayout->addWidget(mCameraGroupBox);
mVerticalLayout->addWidget(toolOffsetWidget);
mVerticalLayout->addStretch();
}
void TextEdit::setupTextActions()
{
QToolBar *tb = new QToolBar(this);
tb->setWindowTitle(tr("Format Actions"));
addToolBar(tb);
QMenu *menu = new QMenu(tr("F&ormat"), this);
menuBar()->addMenu(menu);
actionTextBold = new QAction(QIcon::fromTheme("format-text-bold", QIcon(rsrcPath + "/textbold.png")),
tr("&Bold"), this);
actionTextBold->setShortcut(Qt::CTRL + Qt::Key_B);
actionTextBold->setPriority(QAction::LowPriority);
QFont bold;
bold.setBold(true);
actionTextBold->setFont(bold);
connect(actionTextBold, SIGNAL(triggered()), this, SLOT(textBold()));
tb->addAction(actionTextBold);
menu->addAction(actionTextBold);
actionTextBold->setCheckable(true);
actionTextItalic = new QAction(QIcon::fromTheme("format-text-italic", QIcon(rsrcPath + "/textitalic.png")),
tr("&Italic"), this);
actionTextItalic->setPriority(QAction::LowPriority);
actionTextItalic->setShortcut(Qt::CTRL + Qt::Key_I);
QFont italic;
italic.setItalic(true);
actionTextItalic->setFont(italic);
connect(actionTextItalic, SIGNAL(triggered()), this, SLOT(textItalic()));
tb->addAction(actionTextItalic);
menu->addAction(actionTextItalic);
actionTextItalic->setCheckable(true);
actionTextUnderline = new QAction(QIcon::fromTheme("format-text-underline", QIcon(rsrcPath + "/textunder.png")),
tr("&Underline"), this);
actionTextUnderline->setShortcut(Qt::CTRL + Qt::Key_U);
actionTextUnderline->setPriority(QAction::LowPriority);
QFont underline;
underline.setUnderline(true);
actionTextUnderline->setFont(underline);
connect(actionTextUnderline, SIGNAL(triggered()), this, SLOT(textUnderline()));
tb->addAction(actionTextUnderline);
menu->addAction(actionTextUnderline);
actionTextUnderline->setCheckable(true);
menu->addSeparator();
QActionGroup *grp = new QActionGroup(this);
connect(grp, SIGNAL(triggered(QAction*)), this, SLOT(textAlign(QAction*)));
// Make sure the alignLeft is always left of the alignRight
if (QApplication::isLeftToRight()) {
actionAlignLeft = new QAction(QIcon::fromTheme("format-justify-left", QIcon(rsrcPath + "/textleft.png")),
tr("&Left"), grp);
actionAlignCenter = new QAction(QIcon::fromTheme("format-justify-center", QIcon(rsrcPath + "/textcenter.png")), tr("C&enter"), grp);
actionAlignRight = new QAction(QIcon::fromTheme("format-justify-right", QIcon(rsrcPath + "/textright.png")), tr("&Right"), grp);
} else {
actionAlignRight = new QAction(QIcon::fromTheme("format-justify-right", QIcon(rsrcPath + "/textright.png")), tr("&Right"), grp);
actionAlignCenter = new QAction(QIcon::fromTheme("format-justify-center", QIcon(rsrcPath + "/textcenter.png")), tr("C&enter"), grp);
actionAlignLeft = new QAction(QIcon::fromTheme("format-justify-left", QIcon(rsrcPath + "/textleft.png")), tr("&Left"), grp);
}
actionAlignJustify = new QAction(QIcon::fromTheme("format-justify-fill", QIcon(rsrcPath + "/textjustify.png")), tr("&Justify"), grp);
actionAlignLeft->setShortcut(Qt::CTRL + Qt::Key_L);
actionAlignLeft->setCheckable(true);
actionAlignLeft->setPriority(QAction::LowPriority);
actionAlignCenter->setShortcut(Qt::CTRL + Qt::Key_E);
actionAlignCenter->setCheckable(true);
actionAlignCenter->setPriority(QAction::LowPriority);
actionAlignRight->setShortcut(Qt::CTRL + Qt::Key_R);
actionAlignRight->setCheckable(true);
actionAlignRight->setPriority(QAction::LowPriority);
actionAlignJustify->setShortcut(Qt::CTRL + Qt::Key_J);
actionAlignJustify->setCheckable(true);
actionAlignJustify->setPriority(QAction::LowPriority);
tb->addActions(grp->actions());
menu->addActions(grp->actions());
menu->addSeparator();
QPixmap pix(24, 24);
pix.fill(Qt::black);
actionTextColor = new QAction(QIcon::fromTheme("text-color", QIcon(rsrcPath + "/textcolor.png")),
tr("&Text Color..."), this);
connect(actionTextColor, SIGNAL(triggered()), this, SLOT(textColor()));
tb->addAction(actionTextColor);
menu->addAction(actionTextColor);
pix.fill(Qt::green);
actionHighlightedTextColor = new QAction(QIcon::fromTheme("text-highlight-color", QIcon(rsrcPath + "/texthighlight.png")),
tr("&Text Highlight Color..."), this);
connect(actionHighlightedTextColor, SIGNAL(triggered()), this, SLOT(HighlightedText()));
tb->addAction(actionHighlightedTextColor);
menu->addAction(actionHighlightedTextColor);
//pix.fill(Qt::white);
actionBackgroundColor = new QAction(QIcon::fromTheme("bg-color", QIcon(rsrcPath + "/bgfill.png")),
tr("&Background Color..."), this);
connect(actionBackgroundColor, SIGNAL(triggered()), this, SLOT(backgroundColor()));
tb->addAction(actionBackgroundColor);
menu->addAction(actionBackgroundColor);
tb = new QToolBar(this);
tb->setAllowedAreas(Qt::TopToolBarArea | Qt::BottomToolBarArea);
tb->setWindowTitle(tr("Format Actions"));
addToolBarBreak(Qt::TopToolBarArea);
addToolBar(tb);
comboStyle = new QComboBox(tb);
tb->addWidget(comboStyle);
comboStyle->addItem("Standard");
comboStyle->addItem("Bullet List (Disc)");
comboStyle->addItem("Bullet List (Circle)");
comboStyle->addItem("Bullet List (Square)");
comboStyle->addItem("Ordered List (Decimal)");
comboStyle->addItem("Ordered List (Alpha lower)");
comboStyle->addItem("Ordered List (Alpha upper)");
comboStyle->addItem("Ordered List (Roman lower)");
comboStyle->addItem("Ordered List (Roman upper)");
connect(comboStyle, SIGNAL(activated(int)),
this, SLOT(textStyle(int)));
comboFont = new QFontComboBox(tb);
tb->addWidget(comboFont);
connect(comboFont, SIGNAL(activated(QString)),
this, SLOT(textFamily(QString)));
comboSize = new QComboBox(tb);
comboSize->setObjectName("comboSize");
tb->addWidget(comboSize);
comboSize->setEditable(true);
QFontDatabase db;
foreach(int size, db.standardSizes())
comboSize->addItem(QString::number(size));
connect(comboSize, SIGNAL(activated(QString)),
this, SLOT(textSize(QString)));
comboSize->setCurrentIndex(comboSize->findText(QString::number(QApplication::font()
.pointSize())));
}
QToolBar* specActionLibrary::toolBar(QWidget* target)
{
QToolBar* bar = new QToolBar(target) ;
bar->setContentsMargins(0, 0, 0, 0) ;
bar->setIconSize(QSize(20, 20)) ;
specView* view = dynamic_cast<specView*>(target) ;
specDataView* dataView = dynamic_cast<specDataView*>(target) ;
specMetaView* metaView = dynamic_cast<specMetaView*>(target) ;
specLogView* logView = dynamic_cast<specLogView*>(target) ;
specPlot* plot = dynamic_cast<specPlot*>(target) ;
specPlotWidget* plotWidget = dynamic_cast<specPlotWidget*>(target) ;
if(view && view->model())
{
addParent(view) ;
addParent(view->model()) ;
addNewAction(bar, new specAddFolderAction(target)) ;
if(metaView)
addNewAction(bar, new specNewMetaItemAction(target));
else
{
addNewAction(bar, new specImportSpecAction(target)) ;
addNewAction(bar, new specTreeAction(target)) ;
addNewAction(bar, new specFlattenTreeAction(target)) ;
}
if(dataView || metaView)
addNewAction(bar, new specAddSVGItemAction(target)) ;
addNewAction(bar, new genericExportAction(target)) ;
bar->addSeparator() ;
addNewAction(bar, new specCopyAction(target)) ;
if(dataView || metaView)
addNewAction(bar, new matrixExportAction(target)) ;
addNewAction(bar, new specCutAction(target)) ;
addNewAction(bar, new specPasteAction(target)) ;
addNewAction(bar, new specDeleteAction(target)) ;
bar->addSeparator() ;
if(metaView || logView)
{
bar->addAction(undoAction(view)) ;
bar->addAction(redoAction(view)) ;
bar->addSeparator() ;
}
if(dataView)
{
addNewAction(bar, new toggle3DPlotAction(target)) ;
addNewAction(bar, new specMergeAction(target)) ;
addNewAction(bar, new specTiltMatrixAction(target)) ;
addNewAction(bar, new specDescriptorEditAction(target)) ;
bar->addSeparator() ;
addNewAction(bar, new specRemoveDataAction(target)) ;
addNewAction(bar, new specAverageDataAction(target)) ;
addNewAction(bar, new specSpectrumCalculatorAction(target)) ;
addNewAction(bar, new specNormalizeAction(target)) ;
}
addNewAction(bar, new specItemPropertiesAction(target)) ;
addNewAction(bar, new specSetMultilineAction(target)) ;
if(metaView)
{
addNewAction(bar, new specAddConnectionsAction(target)) ;
addNewAction(bar, new specSelectConnectedAction(target)) ;
addNewAction(bar, new specAddFitAction(target)) ;
addNewAction(bar, new specRemoveFitAction(target)) ;
addNewAction(bar, new specToggleFitStyleAction(target));
addNewAction(bar, new specConductFitAction(target)) ;
}
if(logView)
addNewAction(bar, new specDescriptorEditAction(target)) ;
bar->addSeparator() ;
if(dataView || metaView)
addNewAction(bar, new changePlotStyleAction(target)) ;
bar->setWindowTitle(tr("Items toolbar"));
}
if(plot)
{
addParent(plot);
addNewAction(bar, new specTitleAction(target)) ;
addNewAction(bar, new specXLabelAction(target)) ;
addNewAction(bar, new specYLabelAction(target)) ;
bar->addActions(plot->actions());
bar->setWindowTitle(tr("Plot toolbar"));
}
if(plotWidget)
{
delete bar ;
bar = plotWidget->createToolbar() ;
bar-> addSeparator() ;
bar-> addAction(purgeUndoAction) ;
bar-> addSeparator() ;
bar-> addAction(undoAction(this)) ;
bar-> addAction(redoAction(this)) ;
bar->setWindowTitle(tr("Main toolbar"));
}
return bar ;
}
TextTools::TextTools(QWidget* parent)
: QDockWidget(parent)
{
_textElement = 0;
setObjectName("text-tools");
setWindowTitle(tr("Text Tools"));
setAllowedAreas(Qt::DockWidgetAreas(Qt::TopDockWidgetArea | Qt::BottomDockWidgetArea));
QToolBar* tb = new QToolBar(tr("Text Edit"));
tb->setIconSize(QSize(preferences.iconWidth, preferences.iconHeight));
textStyles = new QComboBox;
tb->addWidget(textStyles);
showKeyboard = getAction("show-keys");
showKeyboard->setCheckable(true);
tb->addAction(showKeyboard);
typefaceBold = tb->addAction(*icons[textBold_ICON], "");
typefaceBold->setToolTip(tr("bold"));
typefaceBold->setCheckable(true);
typefaceItalic = tb->addAction(*icons[textItalic_ICON], "");
typefaceItalic->setToolTip(tr("italic"));
typefaceItalic->setCheckable(true);
typefaceUnderline = tb->addAction(*icons[textUnderline_ICON], "");
typefaceUnderline->setToolTip(tr("underline"));
typefaceUnderline->setCheckable(true);
tb->addSeparator();
QActionGroup* ha = new QActionGroup(tb);
leftAlign = new QAction(*icons[textLeft_ICON], "", ha);
leftAlign->setToolTip(tr("align left"));
leftAlign->setCheckable(true);
leftAlign->setData(ALIGN_LEFT);
hcenterAlign = new QAction(*icons[textCenter_ICON], "", ha);
hcenterAlign->setToolTip(tr("align horizontal center"));
hcenterAlign->setCheckable(true);
hcenterAlign->setData(ALIGN_HCENTER);
rightAlign = new QAction(*icons[textRight_ICON], "", ha);
rightAlign->setToolTip(tr("align right"));
rightAlign->setCheckable(true);
rightAlign->setData(ALIGN_RIGHT);
tb->addActions(ha->actions());
QActionGroup* va = new QActionGroup(tb);
topAlign = new QAction(*icons[textTop_ICON], "", va);
topAlign->setToolTip(tr("align top"));
topAlign->setCheckable(true);
topAlign->setData(ALIGN_TOP);
bottomAlign = new QAction(*icons[textBottom_ICON], "", va);
bottomAlign->setToolTip(tr("align bottom"));
bottomAlign->setCheckable(true);
bottomAlign->setData(ALIGN_BOTTOM);
baselineAlign = new QAction(*icons[textBaseline_ICON], "", va);
baselineAlign->setToolTip(tr("align vertical baseline"));
baselineAlign->setCheckable(true);
baselineAlign->setData(ALIGN_BASELINE);
vcenterAlign = new QAction(*icons[textVCenter_ICON], "", va);
vcenterAlign->setToolTip(tr("align vertical center"));
vcenterAlign->setCheckable(true);
vcenterAlign->setData(ALIGN_VCENTER);
tb->addActions(va->actions());
typefaceSubscript = tb->addAction(*icons[textSub_ICON], "");
typefaceSubscript->setToolTip(tr("subscript"));
typefaceSubscript->setCheckable(true);
typefaceSuperscript = tb->addAction(*icons[textSuper_ICON], "");
typefaceSuperscript->setToolTip(tr("superscript"));
typefaceSuperscript->setCheckable(true);
unorderedList = tb->addAction(*icons[formatListUnordered_ICON], "");
unorderedList->setToolTip(tr("unordered list"));
orderedList = tb->addAction(*icons[formatListOrdered_ICON], "");
orderedList->setToolTip(tr("ordered list"));
indentMore = tb->addAction(*icons[formatIndentMore_ICON], "");
indentMore->setToolTip(tr("indent more"));
indentLess = tb->addAction(*icons[formatIndentLess_ICON], "");
indentLess->setToolTip(tr("indent less"));
tb->addSeparator();
typefaceFamily = new QFontComboBox(this);
tb->addWidget(typefaceFamily);
typefaceSize = new QDoubleSpinBox(this);
tb->addWidget(typefaceSize);
setWidget(tb);
QWidget* w = new QWidget(this);
setTitleBarWidget(w);
titleBarWidget()->hide();
connect(typefaceSize, SIGNAL(valueChanged(double)), SLOT(sizeChanged(double)));
connect(typefaceFamily, SIGNAL(currentFontChanged(const QFont&)), SLOT(fontChanged(const QFont&)));
connect(typefaceBold, SIGNAL(triggered(bool)), SLOT(boldClicked(bool)));
connect(typefaceItalic, SIGNAL(triggered(bool)), SLOT(italicClicked(bool)));
connect(typefaceUnderline, SIGNAL(triggered(bool)), SLOT(underlineClicked(bool)));
connect(typefaceSubscript, SIGNAL(triggered(bool)), SLOT(subscriptClicked(bool)));
connect(typefaceSuperscript, SIGNAL(triggered(bool)), SLOT(superscriptClicked(bool)));
connect(typefaceFamily, SIGNAL(currentFontChanged(const QFont&)), SLOT(fontChanged(const QFont&)));
connect(ha, SIGNAL(triggered(QAction*)), SLOT(setHalign(QAction*)));
connect(va, SIGNAL(triggered(QAction*)), SLOT(setValign(QAction*)));
connect(showKeyboard, SIGNAL(triggered(bool)), SLOT(showKeyboardClicked(bool)));
connect(textStyles, SIGNAL(currentIndexChanged(int)), SLOT(styleChanged(int)));
connect(unorderedList, SIGNAL(triggered()), SLOT(unorderedListClicked()));
connect(orderedList, SIGNAL(triggered()), SLOT(orderedListClicked()));
connect(indentLess, SIGNAL(triggered()), SLOT(indentLessClicked()));
connect(indentMore, SIGNAL(triggered()), SLOT(indentMoreClicked()));
}
void QmitkExtWorkbenchWindowAdvisor::PostWindowCreate()
{
QmitkCommonWorkbenchWindowAdvisor::PostWindowCreate();
// very bad hack...
berry::IWorkbenchWindow::Pointer window =
this->GetWindowConfigurer()->GetWindow();
QMainWindow* mainWindow =
static_cast<QMainWindow*> (window->GetShell()->GetControl());
if (!windowIcon.empty())
{
mainWindow->setWindowIcon(QIcon(QString::fromStdString(windowIcon)));
}
mainWindow->setContextMenuPolicy(Qt::PreventContextMenu);
/*mainWindow->setStyleSheet("color: white;"
"background-color: #808080;"
"selection-color: #659EC7;"
"selection-background-color: #808080;"
" QMenuBar {"
"background-color: #808080; }");*/
// ==== Application menu ============================
QMenuBar* menuBar = mainWindow->menuBar();
menuBar->setContextMenuPolicy(Qt::PreventContextMenu);
QMenu* fileMenu = menuBar->addMenu("&File");
fileMenu->setObjectName("FileMenu");
QAction* fileOpenAction = new QmitkExtFileOpenAction(QIcon(":/org.mitk.gui.qt.ext/Load_48.png"), window);
fileMenu->addAction(fileOpenAction);
fileSaveProjectAction = new QmitkExtFileSaveProjectAction(window);
fileSaveProjectAction->setIcon(QIcon(":/org.mitk.gui.qt.ext/Save_48.png"));
fileMenu->addAction(fileSaveProjectAction);
closeProjectAction = new QmitkCloseProjectAction(window);
closeProjectAction->setIcon(QIcon(":/org.mitk.gui.qt.ext/Remove_48.png"));
fileMenu->addAction(closeProjectAction);
fileMenu->addSeparator();
QAction* fileExitAction = new QmitkFileExitAction(window);
fileExitAction->setObjectName("QmitkFileExitAction");
fileMenu->addAction(fileExitAction);
berry::IViewRegistry* viewRegistry =
berry::PlatformUI::GetWorkbench()->GetViewRegistry();
const std::vector<berry::IViewDescriptor::Pointer>& viewDescriptors =
viewRegistry->GetViews();
// another bad hack to get an edit/undo menu...
QMenu* editMenu = menuBar->addMenu("&Edit");
undoAction = editMenu->addAction(QIcon(":/org.mitk.gui.qt.ext/Undo_48.png"),
"&Undo",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onUndo()),
QKeySequence("CTRL+Z"));
undoAction->setToolTip("Undo the last action (not supported by all modules)");
redoAction = editMenu->addAction(QIcon(":/org.mitk.gui.qt.ext/Redo_48.png")
, "&Redo",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onRedo()),
QKeySequence("CTRL+Y"));
redoAction->setToolTip("execute the last action that was undone again (not supported by all modules)");
imageNavigatorAction = new QAction(QIcon(":/org.mitk.gui.qt.ext/Slider.png"), "&Image Navigator", NULL);
bool imageNavigatorViewFound = window->GetWorkbench()->GetViewRegistry()->Find("org.mitk.views.imagenavigator");
if (imageNavigatorViewFound)
{
QObject::connect(imageNavigatorAction, SIGNAL(triggered(bool)), QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onImageNavigator()));
imageNavigatorAction->setCheckable(true);
// add part listener for image navigator
imageNavigatorPartListener = new PartListenerForImageNavigator(imageNavigatorAction);
window->GetPartService()->AddPartListener(imageNavigatorPartListener);
berry::IViewPart::Pointer imageNavigatorView =
window->GetActivePage()->FindView("org.mitk.views.imagenavigator");
imageNavigatorAction->setChecked(false);
if (imageNavigatorView)
{
bool isImageNavigatorVisible = window->GetActivePage()->IsPartVisible(imageNavigatorView);
if (isImageNavigatorVisible)
imageNavigatorAction->setChecked(true);
}
imageNavigatorAction->setToolTip("Open image navigator for navigating through image");
}
// toolbar for showing file open, undo, redo and other main actions
QToolBar* mainActionsToolBar = new QToolBar;
mainActionsToolBar->setContextMenuPolicy(Qt::PreventContextMenu);
#ifdef __APPLE__
mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextUnderIcon );
#else
mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextBesideIcon );
#endif
mainActionsToolBar->addAction(fileOpenAction);
mainActionsToolBar->addAction(fileSaveProjectAction);
mainActionsToolBar->addAction(closeProjectAction);
mainActionsToolBar->addAction(undoAction);
mainActionsToolBar->addAction(redoAction);
if (imageNavigatorViewFound)
{
mainActionsToolBar->addAction(imageNavigatorAction);
}
mainWindow->addToolBar(mainActionsToolBar);
#ifdef __APPLE__
mainWindow->setUnifiedTitleAndToolBarOnMac(true);
#endif
// ==== Window Menu ==========================
QMenu* windowMenu = menuBar->addMenu("Window");
if (showNewWindowMenuItem)
{
windowMenu->addAction("&New Window", QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onNewWindow()));
windowMenu->addSeparator();
}
QMenu* perspMenu = windowMenu->addMenu("&Open Perspective");
QMenu* viewMenu;
if (showViewMenuItem)
{
viewMenu = windowMenu->addMenu("Show &View");
viewMenu->setObjectName("Show View");
}
windowMenu->addSeparator();
resetPerspAction = windowMenu->addAction("&Reset Perspective",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onResetPerspective()));
if(showClosePerspectiveMenuItem)
closePerspAction = windowMenu->addAction("&Close Perspective", QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onClosePerspective()));
windowMenu->addSeparator();
windowMenu->addAction("&Preferences...",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onEditPreferences()),
QKeySequence("CTRL+P"));
// fill perspective menu
berry::IPerspectiveRegistry* perspRegistry =
window->GetWorkbench()->GetPerspectiveRegistry();
QActionGroup* perspGroup = new QActionGroup(menuBar);
std::vector<berry::IPerspectiveDescriptor::Pointer> perspectives(
perspRegistry->GetPerspectives());
bool skip = false;
for (std::vector<berry::IPerspectiveDescriptor::Pointer>::iterator perspIt =
perspectives.begin(); perspIt != perspectives.end(); ++perspIt)
{
// if perspectiveExcludeList is set, it contains the id-strings of perspectives, which
// should not appear as an menu-entry in the perspective menu
if (perspectiveExcludeList.size() > 0)
{
for (unsigned int i=0; i<perspectiveExcludeList.size(); i++)
{
if (perspectiveExcludeList.at(i) == (*perspIt)->GetId())
{
skip = true;
break;
}
}
if (skip)
{
skip = false;
continue;
}
}
QAction* perspAction = new berry::QtOpenPerspectiveAction(window,
*perspIt, perspGroup);
mapPerspIdToAction.insert(std::make_pair((*perspIt)->GetId(), perspAction));
}
perspMenu->addActions(perspGroup->actions());
// sort elements (converting vector to map...)
std::vector<berry::IViewDescriptor::Pointer>::const_iterator iter;
std::map<std::string, berry::IViewDescriptor::Pointer> VDMap;
skip = false;
for (iter = viewDescriptors.begin(); iter != viewDescriptors.end(); ++iter)
{
// if viewExcludeList is set, it contains the id-strings of view, which
// should not appear as an menu-entry in the menu
if (viewExcludeList.size() > 0)
{
for (unsigned int i=0; i<viewExcludeList.size(); i++)
{
if (viewExcludeList.at(i) == (*iter)->GetId())
{
skip = true;
break;
}
}
if (skip)
{
skip = false;
continue;
}
}
if ((*iter)->GetId() == "org.blueberry.ui.internal.introview")
continue;
if ((*iter)->GetId() == "org.mitk.views.imagenavigator")
continue;
std::pair<std::string, berry::IViewDescriptor::Pointer> p(
(*iter)->GetLabel(), (*iter));
VDMap.insert(p);
}
// ==================================================
// ==== Perspective Toolbar ==================================
QToolBar* qPerspectiveToolbar = new QToolBar;
if (showPerspectiveToolbar)
{
qPerspectiveToolbar->addActions(perspGroup->actions());
mainWindow->addToolBar(qPerspectiveToolbar);
}
else
delete qPerspectiveToolbar;
// ==== View Toolbar ==================================
QToolBar* qToolbar = new QToolBar;
std::map<std::string, berry::IViewDescriptor::Pointer>::const_iterator
MapIter;
for (MapIter = VDMap.begin(); MapIter != VDMap.end(); ++MapIter)
{
berry::QtShowViewAction* viewAction = new berry::QtShowViewAction(window,
(*MapIter).second);
viewActions.push_back(viewAction);
if(showViewMenuItem)
viewMenu->addAction(viewAction);
if (showViewToolbar)
{
qToolbar->addAction(viewAction);
}
}
if (showViewToolbar)
{
mainWindow->addToolBar(qToolbar);
}
else
delete qToolbar;
QSettings settings(GetQSettingsFile(), QSettings::IniFormat);
mainWindow->restoreState(settings.value("ToolbarPosition").toByteArray());
// ====================================================
// ===== Help menu ====================================
QMenu* helpMenu = menuBar->addMenu("Help");
helpMenu->addAction("&Welcome",this, SLOT(onIntro()));
helpMenu->addAction("&Help Contents",this, SLOT(onHelp()), QKeySequence("F1"));
helpMenu->addAction("&About",this, SLOT(onAbout()));
// =====================================================
QStatusBar* qStatusBar = new QStatusBar();
//creating a QmitkStatusBar for Output on the QStatusBar and connecting it with the MainStatusBar
QmitkStatusBar *statusBar = new QmitkStatusBar(qStatusBar);
//disabling the SizeGrip in the lower right corner
statusBar->SetSizeGripEnabled(false);
QmitkProgressBar *progBar = new QmitkProgressBar();
qStatusBar->addPermanentWidget(progBar, 0);
progBar->hide();
// progBar->AddStepsToDo(2);
// progBar->Progress(1);
mainWindow->setStatusBar(qStatusBar);
QmitkMemoryUsageIndicatorView* memoryIndicator =
new QmitkMemoryUsageIndicatorView();
qStatusBar->addPermanentWidget(memoryIndicator, 0);
}
MainWindow::MainWindow()
: hotkeyID(1)
, previousPath(QDir::homePath())
{
// Install a native event filter to handle the hotkeys
this->nativeEventFilter = new NativeEventFilter;
// Create the actions. they will be available in the main toolbar
this->actionNewList = new QAction(QIcon(":/icon64/NewList.png"), "", this);
this->actionNewList->setToolTip(tr("Create a new empty list"));
this->actionOpenList = new QAction(QIcon(":/icon64/OpenList.png"), "", this);
this->actionOpenList->setToolTip(tr("Open an existing list"));
this->actionSaveList = new QAction(QIcon(":/icon64/SaveList.png"), "", this);
this->actionSaveList->setToolTip(tr("Save the current list"));
this->actionNewTimer = new QAction(QIcon(":/icon64/NewTimer.png"), "", this);
this->actionNewTimer->setToolTip(tr("Create a new Timer for the current list"));
this->actionEditTimer = new QAction(QIcon(":/icon64/EditTimer.png"), "", this);
this->actionEditTimer->setToolTip(tr("Modify the currently selected Timer"));
this->actionRemoveTimer = new QAction(QIcon(":/icon64/RemoveTimer.png"), "", this);
this->actionRemoveTimer->setToolTip(tr("Remove the currently selected timer"));
this->actionMisc = new QAction(QIcon(":/icon64/Misc.png"), "", this);
this->actionMisc->setToolTip(tr("About, Help and Licenses"));
QAction* actionSeparator1 = new QAction(this);
QAction* actionSeparator2 = new QAction(this);
actionSeparator1->setSeparator(true);
actionSeparator2->setSeparator(true);
// Create the main toolbar and insert the actions
QList<QAction*> actionList;
actionList << actionNewList << actionOpenList << actionSaveList << actionSeparator1 << actionNewTimer << actionEditTimer << actionRemoveTimer
<< actionSeparator2 << actionMisc;
QSize iconSize(MAIN_TOOLBAR_ICON_WIDTH, MAIN_TOOLBAR_ICON_HEIGHT);
QToolBar* toolBar = new QToolBar(this);
toolBar->setIconSize(iconSize);
toolBar->addActions(actionList);
toolBar->setMovable(false);
this->addToolBar(toolBar);
// Create the main widget, a table which display the timers
// The table display three columns: sound name, period and hotkey
this->timerTable = new QTableWidget(0, COLUMN_COUNT, this);
// Table properties
this->timerTable->setShowGrid(true);
this->timerTable->setSortingEnabled(false);
this->timerTable->setAlternatingRowColors(true);
this->timerTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
this->timerTable->setSelectionMode(QAbstractItemView::SingleSelection);
this->timerTable->setSelectionBehavior(QAbstractItemView::SelectRows);
this->timerTable->horizontalHeader()->setStretchLastSection(true);
this->timerTable->verticalHeader()->setVisible(false);
// Set the columns header and size
QStringList labels;
labels << tr("Status") << tr("Sound name") << tr("Period") << tr("Hotkey");
this->timerTable->setHorizontalHeaderLabels(labels);
this->timerTable->setColumnWidth(COLUMN_STATUS, 60);
this->timerTable->setColumnWidth(COLUMN_NAME, 200);
this->timerTable->setColumnWidth(COLUMN_PERIOD, 100);
this->timerTable->setColumnWidth(COLUMN_HOTKEY, 150);
// Finally, install the table in the main window
setCentralWidget(this->timerTable);
// Main toolbar connections
connect(this->actionNewList, &QAction::triggered, this, &MainWindow::newListTriggerred);
connect(this->actionOpenList, &QAction::triggered, this, &MainWindow::openListTriggerred);
connect(this->actionSaveList, &QAction::triggered, [this] { promptForFilename() && save(); });
connect(this->actionNewTimer, &QAction::triggered, this, &MainWindow::newTimerTriggerred);
connect(this->actionEditTimer, &QAction::triggered, this, &MainWindow::editTimerTriggerred);
connect(this->actionRemoveTimer, &QAction::triggered, this, &MainWindow::removeTimerTriggerred);
connect(this->actionMisc, &QAction::triggered, [this] { DlgMisc::showDlgMisc(this); });
// Table connections
connect(this->timerTable, &QTableWidget::itemSelectionChanged, this, &MainWindow::timerSelectionChanged);
connect(this->timerTable, &QTableWidget::itemDoubleClicked, this, &MainWindow::editTimerTriggerred);
// Interface update
connect(&this->modified, &Modified::changed, this, &MainWindow::updateUI);
// Trigger some slots to have a consistent interface
timerSelectionChanged();
updateUI();
adjustSize();
}
void MainWindow::createGui()
{
// Menus
fileMenu = menuBar()->addMenu(tr("Файл"));
fileMenu->addAction(action_file_newdatabase);
fileMenu->addAction(action_file_open);
fileMenu->addSeparator();
fileMenu->addAction(action_file_save);
fileMenu->addAction(action_file_saveas);
fileMenu->addAction(action_file_export);
fileMenu->addSeparator();
fileMenu->addAction(action_file_properties);
fileMenu->addAction(action_file_print);
fileMenu->addSeparator();
fileMenu->addAction(action_file_exit);
editMenu = menuBar()->addMenu(tr("Правка"));
editMenu->addAction(action_edit_undo);
editMenu->addAction(action_edit_redo);
editMenu->addSeparator();
editMenu->addAction(action_edit_cut);
editMenu->addAction(action_edit_copy);
editMenu->addAction(action_edit_paste);
editMenu->addSeparator();
editMenu->addAction(action_edit_find);
editMenu->addAction(action_edit_selectall);
editMenu->addSeparator();
editMenu->addAction(action_edit_delete);
viewMenu = menuBar()->addMenu(tr("Вид"));
viewMenu->addAction(action_view_tree);
taskMenu = menuBar()->addMenu(tr("Инструменты"));
taskMenu->addAction(action_task_info);
taskMenu->addAction(action_task_calendar);
taskMenu->addAction(action_task_strat);
taskMenu->addAction(action_task_plan);
taskMenu->addAction(action_task_artifact);
taskMenu->addSeparator();
taskMenu->addAction(action_task_settings);
helpMenu = menuBar()->addMenu(tr("Справка"));
helpMenu->addAction(action_help_activation);
helpMenu->addSeparator();
helpMenu->addAction(action_help_about);
// Tool Bar
QToolBar *toolBar = new QToolBar;
toolBar->addActions(actions_toolbar);
addToolBar(Qt::TopToolBarArea, toolBar);
toolBar->setContextMenuPolicy(Qt::PreventContextMenu);
// Status Bar
statusBar()->showMessage(tr(" "));
// Central widget
centralWidget = new CentralWidget(this);
QWidget *w = new QWidget;
QVBoxLayout *mainLayout = new QVBoxLayout;
mainLayout->addWidget(centralWidget);
//mainLayout->addWidget(console);
w->setLayout(mainLayout);
setCentralWidget(w);
// ObjectsTree dock
dock = new QDockWidget(this);
objectsTree = new ArchObjectsTree;
objectsTree->setupActions(actions_tasks);
dock->setWidget(objectsTree);
addDockWidget(Qt::LeftDockWidgetArea, dock);
dock->setWindowTitle(tr("Дерево объектов"));
// MainWindow
setWindowIcon(QIcon(":/images/logo.png"));
}
Window::Window(QWidget* parent) :
QMainWindow(parent)
{
setObjectName("ChatWindow");
Settings::getInstance().load();
connect(&Settings::getInstance(), &Settings::dataChanged, this, &Window::applySettings);
QToolBar* toolbar = new QToolBar(this);
toolbar->setIconSize(QSize(24, 24));
toolbar->setFloatable(false);
toolbar->setContextMenuPolicy(Qt::PreventContextMenu);
addToolBar(toolbar);
//QAction* refreshAction = toolbar->addAction(QIcon(":/icons/refresh.png"), "refresh");
//connect(refreshAction, SIGNAL(triggered()), this, SLOT(refreshPlanets()));
QDockWidget* inputDock = new QDockWidget(this);
inputDock->setObjectName("Input dock");
inputDock->setFeatures(QDockWidget::NoDockWidgetFeatures);
inputDock->setTitleBarWidget(new QWidget(inputDock));
inputDock->setContextMenuPolicy(Qt::PreventContextMenu);
addDockWidget(Qt::BottomDockWidgetArea, inputDock);
QWidget* inputDockWidget = new QWidget(inputDock);
QHBoxLayout* inputDockWidgetLayout = new QHBoxLayout(inputDockWidget);
nickLabel = new QLabel(inputDockWidget);
nickLabel->hide();
inputLine = new QLineEdit(inputDockWidget);
connect(inputLine, &QLineEdit::returnPressed, this, &Window::sendMessage);
inputDockWidgetLayout->addWidget(nickLabel);
inputDockWidgetLayout->addWidget(inputLine);
inputDockWidgetLayout->setContentsMargins(2, 2, 2, 6);
inputDockWidget->setLayout(inputDockWidgetLayout);
inputDock->setFixedHeight(inputDock->height());
inputDock->setWidget(inputDockWidget);
QDockWidget* tabDock = new QDockWidget(this);
tabDock->setObjectName("Tab dock");
tabDock->setFeatures(QDockWidget::NoDockWidgetFeatures);
tabDock->setTitleBarWidget(new QWidget(tabDock));
tabDock->setContextMenuPolicy(Qt::PreventContextMenu);
addDockWidget(Qt::LeftDockWidgetArea, tabDock);
setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);
setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea);
tabTree = new TabTree(tabDock, 100);
tabTree->setHeaderLabel("Chats");
tabTree->setIndentation(8);
tabTree->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
tabTree->setMinimumWidth(1);
tabTree->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
tabDock->setWidget(tabTree);
tabTree->setContextMenuPolicy(Qt::CustomContextMenu);
connect(tabTree, &QTreeWidget::itemSelectionChanged, this, &Window::tabSelected);
connect(tabTree, &QTreeWidget::customContextMenuRequested, this, &Window::showTabTreeContextMenu);
QAction* connectAction = new QAction(QIcon(":/icons/connect.png"), "Connect", toolbar);
QAction* disconnectAction = new QAction(QIcon(":/icons/disconnect.png"), "Disconnect", toolbar);
QAction* settingsAction = toolbar->addAction(QIcon(":/icons/settings.png"), "Settings");
connect(connectAction, &QAction::triggered, this, &Window::connectToServer);
connect(disconnectAction, &QAction::triggered, this, &Window::disconnectFromServer);
connect(settingsAction, &QAction::triggered, this, &Window::showSettingsDialog);
toolbar->addActions(QList<QAction*>() << connectAction << disconnectAction << settingsAction);
serverTab = new QTreeWidgetItem(tabTree, QStringList() << "IRC Server");
tabTree->addTopLevelItem(serverTab);
userDock = new QDockWidget(this);
userDock->setObjectName("User dock");
userDock->setFeatures(QDockWidget::NoDockWidgetFeatures);
userDock->setTitleBarWidget(new QWidget(userDock));
userDock->setContextMenuPolicy(Qt::PreventContextMenu);
addDockWidget(Qt::RightDockWidgetArea, userDock);
setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea);
setCorner(Qt::TopRightCorner, Qt::RightDockWidgetArea);
userTree = new UserTree(userDock, 100);
userTree->setItemsExpandable(false);
userTree->setIndentation(8);
userTree->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
userTree->setMinimumWidth(1);
userTree->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
userDock->setWidget(userTree);
connect(userTree, &UserTree::privateActionTriggered, this, &Window::startPrivate);
topicDock = new QDockWidget(this);
topicDock->setObjectName("Topic dock");
topicDock->setFeatures(QDockWidget::NoDockWidgetFeatures);
topicDock->setTitleBarWidget(new QWidget(topicDock));
topicDock->setContextMenuPolicy(Qt::PreventContextMenu);
addDockWidget(Qt::TopDockWidgetArea, topicDock);
topicLine = new TopicLabel(topicDock);
topicDock->setWidget(topicLine);
QMainWindow* pagesWindow = new QMainWindow(0);
pages = new QStackedWidget(pagesWindow);
serverPage = new ServerPage(serverTab, tabTree);
connect(serverPage, &ServerPage::connectActionTriggered, this, &Window::connectToServer);
connect(serverPage, &ServerPage::disconnectActionTriggered, this, &Window::disconnectFromServer);
pagesWindow->setCentralWidget(pages);
pages->addWidget(serverPage);
setCentralWidget(pagesWindow);
tabTree->setItemSelected(serverTab, true);
autojoinTimer = new QTimer(this);
autojoinTimer->setSingleShot(true);
connect(autojoinTimer, &QTimer::timeout, this, &Window::joinChannels);
applySettings();
ircClient->setVersion(QString("%1 %2 by %3; build date: %4").arg(MainWindow::name).arg(MainWindow::version).arg(MainWindow::author).arg(MainWindow::buildDate));
connect(ircClient, &IrcClient::IrcClient::notice, serverPage, &ServerPage::notice);
connect(ircClient, &IrcClient::IrcClient::serverResponse, serverPage, &ServerPage::serverResponse);
connect(ircClient, &IrcClient::IrcClient::ctcpRequest, serverPage, &ServerPage::ctcpRequest);
connect(ircClient, &IrcClient::IrcClient::ctcpReply, serverPage, &ServerPage::ctcpReply);
connect(ircClient, &IrcClient::IrcClient::quit, serverPage, &ServerPage::quit);
connect(ircClient, &IrcClient::IrcClient::connecting, serverPage, &ServerPage::connecting);
connect(ircClient, &IrcClient::IrcClient::disconnected, serverPage, &ServerPage::disconnected);
connect(ircClient, &IrcClient::IrcClient::userModeChanged, serverPage, &ServerPage::userModeChanged);
connect(ircClient, &IrcClient::IrcClient::join, this, &Window::joinedChannel);
connect(ircClient, &IrcClient::IrcClient::connected, this, &Window::connected);
connect(ircClient, &IrcClient::IrcClient::privateMessage, this, &Window::routePrivateMessage);
connect(ircClient, &IrcClient::IrcClient::action, this, &Window::routePrivateAction);
connect(ircClient, &IrcClient::IrcClient::nickChange, nickLabel, &QLabel::setText);
connect(ircClient, &IrcClient::IrcClient::connected, nickLabel, &QLabel::show);
connect(ircClient, &IrcClient::IrcClient::disconnected, nickLabel, &QLabel::hide);
if (Settings::getInstance().getAutoConnect()) {
connectToServer();
}
::Settings::loadWindow(this);
}
void GraphicTextDialog::setupTextActions()
{
QToolBar *tb = toolBar;
QString rsrcPath = Qucs::bitmapDirectory();
actionTextBold = new QAction(QIcon(rsrcPath + "textbold.png"), tr("&Bold"), this);
actionTextBold->setShortcut(Qt::CTRL + Qt::Key_B);
QFont bold;
bold.setBold(true);
actionTextBold->setFont(bold);
connect(actionTextBold, SIGNAL(triggered()), this, SLOT(textBold()));
tb->addAction(actionTextBold);
actionTextBold->setCheckable(true);
actionTextItalic = new QAction(QIcon(rsrcPath + "textitalic.png"), tr("&Italic"), this);
actionTextItalic->setShortcut(Qt::CTRL + Qt::Key_I);
QFont italic;
italic.setItalic(true);
actionTextItalic->setFont(italic);
connect(actionTextItalic, SIGNAL(triggered()), this, SLOT(textItalic()));
tb->addAction(actionTextItalic);
actionTextItalic->setCheckable(true);
actionTextUnderline = new QAction(QIcon(rsrcPath + "textunder.png"), tr("&Underline"), this);
actionTextUnderline->setShortcut(Qt::CTRL + Qt::Key_U);
QFont underline;
underline.setUnderline(true);
actionTextUnderline->setFont(underline);
connect(actionTextUnderline, SIGNAL(triggered()), this, SLOT(textUnderline()));
tb->addAction(actionTextUnderline);
actionTextUnderline->setCheckable(true);
QActionGroup *grp = new QActionGroup(this);
connect(grp, SIGNAL(triggered(QAction *)), this, SLOT(textAlign(QAction *)));
actionAlignLeft = new QAction(QIcon(rsrcPath + "textleft.png"), tr("&Left"), grp);
actionAlignLeft->setShortcut(Qt::CTRL + Qt::Key_L);
actionAlignLeft->setCheckable(true);
actionAlignCenter = new QAction(QIcon(rsrcPath + "textcenter.png"), tr("C&enter"), grp);
actionAlignCenter->setShortcut(Qt::CTRL + Qt::Key_E);
actionAlignCenter->setCheckable(true);
actionAlignRight = new QAction(QIcon(rsrcPath + "textright.png"), tr("&Right"), grp);
actionAlignRight->setShortcut(Qt::CTRL + Qt::Key_R);
actionAlignRight->setCheckable(true);
actionAlignJustify = new QAction(QIcon(rsrcPath + "textjustify.png"), tr("&Justify"), grp);
actionAlignJustify->setShortcut(Qt::CTRL + Qt::Key_J);
actionAlignJustify->setCheckable(true);
tb->addActions(grp->actions());
tb->addSeparator();
QPixmap pix(16, 16);
pix.fill(Qt::black);
actionTextColor = new QAction(pix, tr("&Color..."), this);
connect(actionTextColor, SIGNAL(triggered()), this, SLOT(textColor()));
tb->addAction(actionTextColor);
tb = new QToolBar(this);
tb->setIconSize(QSize(16, 16));
mainLayout->insertWidget(2, tb);
comboStyle = new QComboBox(tb);
tb->addWidget(comboStyle);
comboStyle->addItem("Standard");
comboStyle->addItem("Bullet List (Disc)");
comboStyle->addItem("Bullet List (Circle)");
comboStyle->addItem("Bullet List (Square)");
comboStyle->addItem("Ordered List (Decimal)");
comboStyle->addItem("Ordered List (Alpha lower)");
comboStyle->addItem("Ordered List (Alpha upper)");
connect(comboStyle, SIGNAL(activated(int)),
this, SLOT(textStyle(int)));
comboFont = new QFontComboBox(tb);
tb->addWidget(comboFont);
connect(comboFont, SIGNAL(activated(const QString &)),
this, SLOT(textFamily(const QString &)));
comboFont->setCurrentFont(font());
comboSize = new QComboBox(tb);
comboSize->setObjectName("comboSize");
tb->addWidget(comboSize);
comboSize->setEditable(true);
QFontDatabase db;
foreach(int size, db.standardSizes()) {
comboSize->addItem(QString::number(size));
}
connect(comboSize, SIGNAL(activated(const QString &)),
this, SLOT(textSize(const QString &)));
comboSize->setCurrentIndex(comboSize->findText(QString::number(QApplication::font()
.pointSize())));
tb->addSeparator();
grp = new QActionGroup(this);
connect(grp, SIGNAL(triggered(QAction *)), this, SLOT(textAlignSubSuperScript(QAction *)));
actionAlignSubscript = new QAction(QIcon(rsrcPath + "sub.png"), tr("Subscript"), grp);
actionAlignSubscript->setCheckable(true);
actionAlignSupersript = new QAction(QIcon(rsrcPath + "super.png"), tr("Superscript"), grp);
actionAlignSupersript->setCheckable(true);
actionAlignNormalscript = new QAction(QIcon(rsrcPath + "text.png"), tr("Normal"), grp);
actionAlignNormalscript->setCheckable(true);
tb->addActions(grp->actions());
}
void TextEdit::setupTextActions()
{
QToolBar *tb = new QToolBar(this);
tb->setWindowTitle(tr("Format Actions"));
toolBar1.addWidget(tb);
actionTextBold = new QAction(QIcon(rsrcPath + "/textbold.png"), tr("&Bold"), this);
actionTextBold->setShortcut(Qt::CTRL + Qt::Key_B);
QFont bold;
bold.setBold(true);
actionTextBold->setFont(bold);
connect(actionTextBold, SIGNAL(triggered()), this, SLOT(textBold()));
tb->addAction(actionTextBold);
actionTextBold->setCheckable(true);
actionTextItalic = new QAction(QIcon(rsrcPath + "/textitalic.png"), tr("&Italic"), this);
actionTextItalic->setShortcut(Qt::CTRL + Qt::Key_I);
QFont italic;
italic.setItalic(true);
actionTextItalic->setFont(italic);
connect(actionTextItalic, SIGNAL(triggered()), this, SLOT(textItalic()));
tb->addAction(actionTextItalic);
actionTextItalic->setCheckable(true);
actionTextUnderline = new QAction(QIcon(rsrcPath + "/textunder.png"), tr("&Underline"), this);
actionTextUnderline->setShortcut(Qt::CTRL + Qt::Key_U);
QFont underline;
underline.setUnderline(true);
actionTextUnderline->setFont(underline);
connect(actionTextUnderline, SIGNAL(triggered()), this, SLOT(textUnderline()));
tb->addAction(actionTextUnderline);
actionTextUnderline->setCheckable(true);
QActionGroup *grp = new QActionGroup(this);
connect(grp, SIGNAL(triggered(QAction *)), this, SLOT(textAlign(QAction *)));
// Make sure the alignLeft is always left of the alignRight
if (QApplication::isLeftToRight()) {
actionAlignLeft = new QAction(QIcon(rsrcPath + "/textleft.png"), tr("&Left"), grp);
actionAlignCenter = new QAction(QIcon(rsrcPath + "/textcenter.png"), tr("C&enter"), grp);
actionAlignRight = new QAction(QIcon(rsrcPath + "/textright.png"), tr("&Right"), grp);
} else {
actionAlignRight = new QAction(QIcon(rsrcPath + "/textright.png"), tr("&Right"), grp);
actionAlignCenter = new QAction(QIcon(rsrcPath + "/textcenter.png"), tr("C&enter"), grp);
actionAlignLeft = new QAction(QIcon(rsrcPath + "/textleft.png"), tr("&Left"), grp);
}
actionAlignJustify = new QAction(QIcon(rsrcPath + "/textjustify.png"), tr("&Justify"), grp);
actionAlignLeft->setShortcut(Qt::CTRL + Qt::Key_L);
actionAlignLeft->setCheckable(true);
actionAlignCenter->setShortcut(Qt::CTRL + Qt::Key_E);
actionAlignCenter->setCheckable(true);
actionAlignRight->setShortcut(Qt::CTRL + Qt::Key_R);
actionAlignRight->setCheckable(true);
actionAlignJustify->setShortcut(Qt::CTRL + Qt::Key_J);
actionAlignJustify->setCheckable(true);
tb->addActions(grp->actions());
QPixmap pix(16, 16);
pix.fill(Qt::black);
actionTextColor = new QAction(pix, tr("&Color..."), this);
connect(actionTextColor, SIGNAL(triggered()), this, SLOT(textColor()));
tb->addAction(actionTextColor);
tb = new QToolBar(this);
tb->setAllowedAreas(Qt::TopToolBarArea | Qt::BottomToolBarArea);
tb->setWindowTitle(tr("Format Actions"));
toolBar2.addWidget(tb);
comboStyle = new QComboBox(tb);
tb->addWidget(comboStyle);
comboStyle->addItem("Standard");
comboStyle->addItem("Bullet List (Disc)");
comboStyle->addItem("Bullet List (Circle)");
comboStyle->addItem("Bullet List (Square)");
comboStyle->addItem("Ordered List (Decimal)");
comboStyle->addItem("Ordered List (Alpha lower)");
comboStyle->addItem("Ordered List (Alpha upper)");
connect(comboStyle, SIGNAL(activated(int)),
this, SLOT(textStyle(int)));
comboFont = new QFontComboBox(tb);
tb->addWidget(comboFont);
connect(comboFont, SIGNAL(activated(const QString &)),
this, SLOT(textFamily(const QString &)));
comboSize = new QComboBox(tb);
comboSize->setObjectName("comboSize");
tb->addWidget(comboSize);
comboSize->setEditable(true);
QFontDatabase db;
foreach(int size, db.standardSizes())
comboSize->addItem(QString::number(size));
connect(comboSize, SIGNAL(activated(const QString &)),
this, SLOT(textSize(const QString &)));
comboSize->setCurrentIndex(comboSize->findText(QString::number(QApplication::font()
.pointSize())));
}
HelpWindow::HelpWindow(QWidget *parent) :
QMainWindow(parent),
mActionGoMainPage(new QAction(tr("Home"), this)),
mActionBackward(new QAction(tr("Backward"), this)),
mActionForward(new QAction(tr("Forward"), this)),
mHelpEngine(new QHelpEngine(settingsObj.getPath(MSUSettings::PATH_SHARE_HELP) + "msuproj-qt.qhc", this)),
mPageWidget(new HelpBrowser(mHelpEngine, this))
{
QByteArray geom(settingsObj.getGeometry(MSUSettings::HELPWINDOW));
if (geom.size() > 0)
{
this->restoreGeometry(geom);
this->restoreState(settingsObj.getState(MSUSettings::HELPWINDOW));
}
else
this->resize(900, 600);
this->setContentsMargins(5, 0, 5, 5);
this->setCentralWidget(mPageWidget);
bool errorLoadingHelp = true;
if (mHelpEngine->setupData())
{
locale = settingsObj.getLocale();
if (!mHelpEngine->filterAttributes().contains(locale) ||
!QFile(mHelpEngine->documentationFileName("amigos.msuproj-qt." + locale)).exists())
locale = "en";
if(QFile(mHelpEngine->documentationFileName("amigos.msuproj-qt." + locale)).exists())
{
errorLoadingHelp = false;
mHelpEngine->setCurrentFilter(locale);
QToolBar *navigationBar = new QToolBar(tr("Navigation"), this);
navigationBar->setObjectName("HelpWindowNavBar");
navigationBar->addActions({mActionGoMainPage, mActionBackward, mActionForward});
this->addToolBar(navigationBar);
QDockWidget *contentsDockWidget = new QDockWidget(tr("Contents"), this);
contentsDockWidget->setObjectName("HelpWindowContentsDock");
contentsDockWidget->setFeatures(QDockWidget::NoDockWidgetFeatures);
this->addDockWidget(Qt::LeftDockWidgetArea, contentsDockWidget);
QHelpContentWidget *contentWidget = mHelpEngine->contentWidget();
contentsDockWidget->setWidget(contentWidget);
connect(contentWidget, &QHelpContentWidget::clicked, this, &HelpWindow::setPage);
connect(this, &HelpWindow::contentChange, mPageWidget, &HelpBrowser::setSource);
connect(mPageWidget, &HelpBrowser::backwardAvailable, mActionBackward, &QAction::setEnabled);
connect(mActionBackward, &QAction::triggered, mPageWidget, &HelpBrowser::backward);
connect(mPageWidget, &HelpBrowser::forwardAvailable, mActionForward, &QAction::setEnabled);
connect(mActionForward, &QAction::triggered, mPageWidget, &HelpBrowser::forward);
connect(mActionGoMainPage, &QAction::triggered, this, &HelpWindow::goMainPage);
connect(mPageWidget, &HelpBrowser::anchorClicked, this, &HelpWindow::setCurrentContentIndex);
connect(mActionBackward, &QAction::triggered, this, &HelpWindow::setCurrentContentIndex);
connect(mActionForward, &QAction::triggered, this, &HelpWindow::setCurrentContentIndex);
this->goMainPage();
}
}
if (errorLoadingHelp)
mPageWidget->setHtml(QString("<html><head/><body><p align=\"center\"><span style=\" font-size:16pt; font-weight:600;\">%1</span></p>"
"<p align=\"center\">%2</p></body></html>")
.arg(tr("Error loading help files."),
tr("Could not load help files. Have You installed the MSUProj-Qt Help package?")));
}
OLD_MAIN(QWidget* pParent = nullptr)
: QMainWindow(pParent)
{
Q_INIT_RESOURCE(Resources);
// Settings persistence
ReadSettings();
// Appearance LUT
PlayerApperances appearances;
// Build player table model from file
PlayerTableModel* playerTableModel = new PlayerTableModel(this);
playerTableModel->LoadHittingProjections(appearances);
playerTableModel->LoadPitchingProjections(appearances);
playerTableModel->CalculateHittingScores();
playerTableModel->CalculatePitchingScores();
playerTableModel->InitializeTargetValues();
// Draft delegate
DraftDelegate* draftDelegate = new DraftDelegate(playerTableModel);
LinkDelegate* linkDelegate = new LinkDelegate(this);
TagDelegate* tagDelegate = new TagDelegate(this);
// Hitter sort-model
PlayerSortFilterProxyModel* hitterSortFilterProxyModel = new PlayerSortFilterProxyModel(Player::Hitter);
hitterSortFilterProxyModel->setSourceModel(playerTableModel);
hitterSortFilterProxyModel->setSortRole(PlayerTableModel::RawDataRole);
// Hitter table view
QTableView* hitterTableView = MakeTableView(hitterSortFilterProxyModel, true, PlayerTableModel::COLUMN_Z);
hitterTableView->setItemDelegateForColumn(FindColumn(hitterSortFilterProxyModel, PlayerTableModel::COLUMN_DRAFT_BUTTON), draftDelegate);
hitterTableView->setItemDelegateForColumn(FindColumn(hitterSortFilterProxyModel, PlayerTableModel::COLUMN_ID_LINK), linkDelegate);
hitterTableView->setItemDelegateForColumn(FindColumn(hitterSortFilterProxyModel, PlayerTableModel::COLUMN_FLAG), tagDelegate);
hitterTableView->setEditTriggers(QAbstractItemView::DoubleClicked | QAbstractItemView::SelectedClicked);
// Context menu
QMenu* contextMenu = new QMenu();
contextMenu->addAction("&Remove Player");
// Apply to hitter table view
hitterTableView->setContextMenuPolicy(Qt::CustomContextMenu);
connect(hitterTableView, &QWidget::customContextMenuRequested, [=](const QPoint& pos) {
QPoint globalPos = hitterTableView->mapToGlobal(pos);
QAction* selectedItem = contextMenu->exec(globalPos);
if (selectedItem) {
auto proxyIndex = hitterTableView->indexAt(pos);
auto srcIndex = hitterSortFilterProxyModel->mapToSource(proxyIndex);
playerTableModel->RemovePlayer(srcIndex.row());
}
});
// Pitcher sort-model
PlayerSortFilterProxyModel* pitcherSortFilterProxyModel = new PlayerSortFilterProxyModel(Player::Pitcher);
pitcherSortFilterProxyModel->setSourceModel(playerTableModel);
pitcherSortFilterProxyModel->setSortRole(PlayerTableModel::RawDataRole);
// Pitcher table view
QTableView* pitcherTableView = MakeTableView(pitcherSortFilterProxyModel, true, PlayerTableModel::COLUMN_Z);
pitcherTableView->setItemDelegateForColumn(FindColumn(pitcherSortFilterProxyModel, PlayerTableModel::COLUMN_DRAFT_BUTTON), draftDelegate);
pitcherTableView->setItemDelegateForColumn(FindColumn(pitcherSortFilterProxyModel, PlayerTableModel::COLUMN_ID_LINK), linkDelegate);
pitcherTableView->setItemDelegateForColumn(FindColumn(pitcherSortFilterProxyModel, PlayerTableModel::COLUMN_FLAG), tagDelegate);
pitcherTableView->setEditTriggers(QAbstractItemView::DoubleClicked | QAbstractItemView::SelectedClicked);
// Top/Bottom splitter
QSplitter* topBottomSplitter = new QSplitter(Qt::Vertical);
topBottomSplitter->setContentsMargins(5, 5, 5, 5);
// Hitter/Pitcher tab View
enum PlayerTableTabs { Hitters, Pitchers, Unknown };
QTabWidget* hitterPitcherTabs = new QTabWidget(this);
hitterPitcherTabs->insertTab(PlayerTableTabs::Hitters, hitterTableView, "Hitters");
hitterPitcherTabs->insertTab(PlayerTableTabs::Pitchers, pitcherTableView, "Pitchers");
topBottomSplitter->addWidget(hitterPitcherTabs);
// Tab lookup helper
auto CaterogyToTab = [](uint32_t catergory)
{
switch (catergory)
{
case Player::Hitter:
return PlayerTableTabs::Hitters;
case Player::Pitcher:
return PlayerTableTabs::Pitchers;
default:
return PlayerTableTabs::Unknown;
}
};
// Drafted filter action
QAction* filterDrafted = new QAction(this);
connect(filterDrafted, &QAction::toggled, hitterSortFilterProxyModel, &PlayerSortFilterProxyModel::OnFilterDrafted);
connect(filterDrafted, &QAction::toggled, pitcherSortFilterProxyModel, &PlayerSortFilterProxyModel::OnFilterDrafted);
filterDrafted->setText(tr("Drafted"));
filterDrafted->setToolTip("Toggle Drafted Players");
filterDrafted->setCheckable(true);
filterDrafted->toggle();
QAction* filterReplacement = new QAction(this);
connect(filterReplacement, &QAction::toggled, hitterSortFilterProxyModel, &PlayerSortFilterProxyModel::OnFilterReplacement);
connect(filterReplacement, &QAction::toggled, pitcherSortFilterProxyModel, &PlayerSortFilterProxyModel::OnFilterReplacement);
filterReplacement->setText(tr("($1)"));
filterReplacement->setToolTip("Toggle replacements players with value under $1");
filterReplacement->setCheckable(true);
filterReplacement->toggle();
// NL filter action
QAction* filterNL = new QAction(this);
connect(filterNL, &QAction::toggled, hitterSortFilterProxyModel, &PlayerSortFilterProxyModel::OnFilterNL);
connect(filterNL, &QAction::toggled, pitcherSortFilterProxyModel, &PlayerSortFilterProxyModel::OnFilterNL);
filterNL->setText(tr("NL"));
filterNL->setToolTip("Toggle National Leauge");
filterNL->setCheckable(true);
filterNL->toggle();
// AL filter action
QAction* filterAL = new QAction(this);
connect(filterAL, &QAction::toggled, hitterSortFilterProxyModel, &PlayerSortFilterProxyModel::OnFilterAL);
connect(filterAL, &QAction::toggled, pitcherSortFilterProxyModel, &PlayerSortFilterProxyModel::OnFilterAL);
filterAL->setText(tr("AL"));
filterAL->setToolTip("Toggle American Leauge");
filterAL->setCheckable(true);
filterAL->toggle();
// FA filter action
QAction* filterFA = new QAction(this);
connect(filterFA, &QAction::toggled, hitterSortFilterProxyModel, &PlayerSortFilterProxyModel::OnFilterFA);
connect(filterFA, &QAction::toggled, pitcherSortFilterProxyModel, &PlayerSortFilterProxyModel::OnFilterFA);
filterFA->setText(tr("FA"));
filterFA->setToolTip("Toggle Free Agents");
filterFA->setCheckable(true);
filterAL->toggle();
filterAL->toggle();
// General filter group
QActionGroup* generalFilters = new QActionGroup(this);
generalFilters->addAction(filterAL);
generalFilters->addAction(filterNL);
generalFilters->addAction(filterFA);
generalFilters->setExclusive(false);
// Starter filter action
QAction* filterStarter = new QAction(this);
connect(filterStarter, &QAction::toggled, pitcherSortFilterProxyModel, &PlayerSortFilterProxyModel::OnFilterSP);
filterStarter->setText(tr("SP"));
filterStarter->setToolTip("Toggle Starting Pitchers");
filterStarter->setCheckable(true);
filterStarter->toggle();
// Relief filter action
QAction* filterRelief = new QAction(this);
connect(filterRelief, &QAction::toggled, pitcherSortFilterProxyModel, &PlayerSortFilterProxyModel::OnFilterRP);
filterRelief->setText(tr("RP"));
filterRelief->setToolTip("Toggle Relief Pitchers");
filterRelief->setCheckable(true);
filterRelief->toggle();
// Pitching filter group
QActionGroup* pitchingFilters = new QActionGroup(this);
pitchingFilters->addAction(filterStarter);
pitchingFilters->addAction(filterRelief);
pitchingFilters->setExclusive(false);
// Hitting filter group
QActionGroup* hittingFilters = new QActionGroup(this);
hittingFilters->setExclusive(false);
// Filter helper
auto MakeHitterFilter = [=](QString text, QString toolTip, const auto& onFilterFn) -> QAction*
{
QAction* action = new QAction(this);
connect(action, &QAction::toggled, hitterSortFilterProxyModel, onFilterFn);
action->setText(text);
action->setToolTip(toolTip);
action->setCheckable(true);
action->toggle();
hittingFilters->addAction(action);
return action;
};
// Hitter filters
QAction* filterC = MakeHitterFilter("C", "Filter Catchers", &PlayerSortFilterProxyModel::OnFilterC);
QAction* filter1B = MakeHitterFilter("1B", "Filter 1B", &PlayerSortFilterProxyModel::OnFilter1B);
QAction* filter2B = MakeHitterFilter("2B", "Filter 2B", &PlayerSortFilterProxyModel::OnFilter2B);
QAction* filterSS = MakeHitterFilter("SS", "Filter SS", &PlayerSortFilterProxyModel::OnFilterSS);
QAction* filter3B = MakeHitterFilter("3B", "Filter 3B", &PlayerSortFilterProxyModel::OnFilter3B);
QAction* filterOF = MakeHitterFilter("OF", "Filter Outfielders", &PlayerSortFilterProxyModel::OnFilterOF);
QAction* filterCI = MakeHitterFilter("CI", "Filter Corner Infielders", &PlayerSortFilterProxyModel::OnFilterCI);
QAction* filterMI = MakeHitterFilter("MI", "Filter Middle Infielders", &PlayerSortFilterProxyModel::OnFilterMI);
QAction* filterDH = MakeHitterFilter("DH", "Filter Designated Hitters", &PlayerSortFilterProxyModel::OnFilterDH);
QAction* filterU = MakeHitterFilter("U", "Filter Utility", &PlayerSortFilterProxyModel::OnFilterU);
// Menu spacer
QWidget* spacer = new QWidget(this);
spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
// Completion Widget
QCompleter* completer = new QCompleter(this);
completer->setModel(playerTableModel);
completer->setCompletionColumn(PlayerTableModel::COLUMN_NAME);
completer->setFilterMode(Qt::MatchContains);
completer->setCaseSensitivity(Qt::CaseInsensitive);
// Select
auto HighlightPlayerInTable = [=](const QModelIndex& srcIdx)
{
// Lookup catergory
auto catergoryIdx = srcIdx.model()->index(srcIdx.row(), PlayerTableModel::COLUMN_CATERGORY);
auto catergory = srcIdx.model()->data(catergoryIdx).toUInt();
// Change to tab
hitterPitcherTabs->setCurrentIndex(CaterogyToTab(catergory));
// Select row
if (catergory == Player::Catergory::Hitter) {
auto proxyModel = dynamic_cast<QSortFilterProxyModel*>(hitterTableView->model());
auto proxyIdx = proxyModel->mapFromSource(srcIdx);
hitterTableView->selectRow(proxyIdx.row());
hitterTableView->setFocus();
} else if (catergory == Player::Catergory::Pitcher) {
auto proxyModel = dynamic_cast<QSortFilterProxyModel*>(pitcherTableView->model());
auto proxyIdx = proxyModel->mapFromSource(srcIdx);
pitcherTableView->selectRow(proxyIdx.row());
pitcherTableView->setFocus();
}
};
// Select the target
connect(completer, static_cast<void (QCompleter::*)(const QModelIndex&)>(&QCompleter::activated), [=](const QModelIndex& index) {
// Get player index
QAbstractProxyModel* proxyModel = dynamic_cast<QAbstractProxyModel*>(completer->completionModel());
auto srcIdx = proxyModel->mapToSource(index);
// Highlight this player
HighlightPlayerInTable(srcIdx);
});
// Search widget
QLineEdit* playerSearch = new QLineEdit(this);
playerSearch->setCompleter(completer);
// Main toolbar
QToolBar* toolbar = new QToolBar("Toolbar");
toolbar->addWidget(new QLabel(" Status: ", this));
toolbar->addActions(QList<QAction*>{filterDrafted, filterReplacement});
toolbar->addSeparator();
toolbar->addWidget(new QLabel(" Leagues: ", this));
toolbar->addActions(QList<QAction*>{filterAL, filterNL, filterFA});
toolbar->addSeparator();
toolbar->addWidget(new QLabel(" Positions: ", this));
toolbar->addActions(QList<QAction*>{filterStarter, filterRelief});
toolbar->addActions(QList<QAction*>{filterC, filter1B, filter2B, filterSS, filter3B, filterOF, filterCI, filterMI, filterDH, filterU});
toolbar->addWidget(spacer);
toolbar->addWidget(new QLabel("Player Search: ", this));
toolbar->addWidget(playerSearch);
toolbar->setFloatable(false);
toolbar->setMovable(false);
QMainWindow::addToolBar(toolbar);
// Helper to adjust filters
auto ToggleFilterGroups = [=](int index)
{
switch (index)
{
case uint32_t(PlayerTableTabs::Hitters):
pitchingFilters->setVisible(false);
hittingFilters->setVisible(true);
break;
case uint32_t(PlayerTableTabs::Pitchers):
pitchingFilters->setVisible(true);
hittingFilters->setVisible(false);
break;
default:
break;
}
};
// Set default filter group
ToggleFilterGroups(hitterPitcherTabs->currentIndex());
//---------------------------------------------------------------------
// Bottom Section
//---------------------------------------------------------------------
// Owner widget
QHBoxLayout* ownersLayout = new QHBoxLayout(this);
ownersLayout->setSizeConstraint(QLayout::SetNoConstraint);
// Owner models
std::vector<OwnerSortFilterProxyModel*> vecOwnerSortFilterProxyModels;
// Owner labels
QList<QLabel*>* pVecOwnerLabels;
pVecOwnerLabels = new QList<QLabel*>();
pVecOwnerLabels->append(new QLabel("--"));
for (auto i = 1u; i <= DraftSettings::Get().OwnerCount; i++) {
pVecOwnerLabels->append(new QLabel(DraftSettings::Get().OwnerNames[i]));
}
// Update label helper
auto UpdateOwnerLabels = [=]() {
for (auto i = 1u; i <= DraftSettings::Get().OwnerCount; i++) {
pVecOwnerLabels->at(i)->setText(DraftSettings::Get().OwnerNames[i]);
}
};
// Initialize
UpdateOwnerLabels();
// Loop owners
for (uint32_t ownerId = 1; ownerId <= DraftSettings::Get().OwnerCount; ownerId++) {
// V-Layout per owner
QVBoxLayout* perOwnerLayout = new QVBoxLayout(this);
ownersLayout->addLayout(perOwnerLayout);
perOwnerLayout->setSizeConstraint(QLayout::SetNoConstraint);
// Proxy model for this owner
OwnerSortFilterProxyModel* ownerSortFilterProxyModel = new OwnerSortFilterProxyModel(ownerId, playerTableModel, this);
vecOwnerSortFilterProxyModels.push_back(ownerSortFilterProxyModel);
// Owner name label
pVecOwnerLabels->at(ownerId)->setAlignment(Qt::AlignCenter);
perOwnerLayout->addWidget(pVecOwnerLabels->at(ownerId));
// Per-owner roster table view
const uint32_t tableWidth = 225;
QTableView* ownerRosterTableView = MakeTableView(ownerSortFilterProxyModel, true, 0);
ownerRosterTableView->setMinimumSize(tableWidth, 65);
ownerRosterTableView->setMaximumSize(tableWidth, 4096);
ownerRosterTableView->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding);
perOwnerLayout->addWidget(ownerRosterTableView);
// XXX: This should be a form layout...
QGridLayout* ownerSummaryGridLayout = new QGridLayout(this);
ownerSummaryGridLayout->setSpacing(0);
ownerSummaryGridLayout->addWidget(MakeLabel("Budget: "), 0, 0);
ownerSummaryGridLayout->addWidget(MakeLabel("# Hitters: "), 1, 0);
ownerSummaryGridLayout->addWidget(MakeLabel("# Pitchers: "), 2, 0);
ownerSummaryGridLayout->addWidget(MakeLabel("Max Bid: "), 3, 0);
QLabel* budgetLabel = MakeLabel();
QLabel* numHittersLabel = MakeLabel();
QLabel* numPitchersLabel = MakeLabel();
QLabel* maxBidLabel = MakeLabel();
// Helper
auto UpdateLabels = [=]()
{
budgetLabel->setText(QString("$%1").arg(ownerSortFilterProxyModel->GetRemainingBudget()));
numHittersLabel->setText(QString("%1 / %2").arg(ownerSortFilterProxyModel->Count(Player::Hitter)).arg(DraftSettings::Get().HitterCount));
numPitchersLabel->setText(QString("%1 / %2").arg(ownerSortFilterProxyModel->Count(Player::Pitcher)).arg(DraftSettings::Get().PitcherCount));
maxBidLabel->setText(QString("$%1").arg(ownerSortFilterProxyModel->GetMaxBid()));
};
// Update labels when a draft event happens
connect(playerTableModel, &PlayerTableModel::DraftedEnd, [=]() {
UpdateLabels();
});
UpdateLabels();
ownerSummaryGridLayout->addWidget(budgetLabel, 0, 1);
ownerSummaryGridLayout->addWidget(numHittersLabel, 1, 1);
ownerSummaryGridLayout->addWidget(numPitchersLabel, 2, 1);
ownerSummaryGridLayout->addWidget(maxBidLabel, 3, 1);
QSpacerItem* spacer = new QSpacerItem(1, 1, QSizePolicy::Preferred, QSizePolicy::Preferred);
ownerSummaryGridLayout->addItem(spacer, 0, 2);
ownerSummaryGridLayout->addItem(spacer, 1, 2);
ownerSummaryGridLayout->addItem(spacer, 2, 2);
ownerSummaryGridLayout->addItem(spacer, 3, 2);
perOwnerLayout->addLayout(ownerSummaryGridLayout);
perOwnerLayout->addSpacerItem(spacer);
}
// Owner widget
QWidget* scrollAreaWidgetContents = new QWidget(this);
scrollAreaWidgetContents->setLayout(ownersLayout);
scrollAreaWidgetContents->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
// Owner scroll area
QScrollArea* ownerScrollArea = new QScrollArea(this);
ownerScrollArea->setWidget(scrollAreaWidgetContents);
ownerScrollArea->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Preferred);
ownerScrollArea->setBackgroundRole(QPalette::Light);
ownerScrollArea->setFrameShape(QFrame::NoFrame);
ownerScrollArea->setWidgetResizable(true);
// Target value widget
QWidget* targetValueWidget = new QWidget(this);
QFormLayout* targetValueLayout = new QFormLayout(this);
targetValueWidget->setLayout(targetValueLayout);
auto values = {
PlayerTableModel::COLUMN_AVG,
PlayerTableModel::COLUMN_HR,
PlayerTableModel::COLUMN_R,
PlayerTableModel::COLUMN_RBI,
PlayerTableModel::COLUMN_SB,
PlayerTableModel::COLUMN_SO,
PlayerTableModel::COLUMN_ERA,
PlayerTableModel::COLUMN_WHIP,
PlayerTableModel::COLUMN_W,
PlayerTableModel::COLUMN_SV,
};
for (auto value : values) {
auto name = playerTableModel->headerData(value, Qt::Horizontal, Qt::DisplayRole).toString();
auto target = QString::number(playerTableModel->GetTargetValue(value), 'f', 3);
targetValueLayout->addRow(name, new QLabel(target));
}
// Player scatter plot
PlayerScatterPlotChart* chartView = new PlayerScatterPlotChart(playerTableModel, hitterSortFilterProxyModel, this);
connect(hitterSortFilterProxyModel, &QSortFilterProxyModel::layoutChanged, chartView, &PlayerScatterPlotChart::Update);
connect(pitcherSortFilterProxyModel, &QSortFilterProxyModel::layoutChanged, chartView, &PlayerScatterPlotChart::Update);
connect(playerTableModel, &QAbstractItemModel::dataChanged, chartView, &PlayerScatterPlotChart::Update);
// Summary view
SummaryWidget* summary = new SummaryWidget(playerTableModel, vecOwnerSortFilterProxyModels, this);
// Bottom tabs
enum BottomSectionTabs { Rosters, Summary, Targets, ChartView, Log };
QTabWidget* bottomTabs = new QTabWidget(this);
topBottomSplitter->addWidget(bottomTabs);
bottomTabs->insertTab(BottomSectionTabs::Rosters, ownerScrollArea, "Rosters");
bottomTabs->insertTab(BottomSectionTabs::Summary, summary, "Summary");
bottomTabs->insertTab(BottomSectionTabs::Targets, targetValueWidget, "Targets");
bottomTabs->insertTab(BottomSectionTabs::ChartView, chartView, "Scatter Chart");
bottomTabs->insertTab(BottomSectionTabs::Log, GlobalLogger::Get(), "Log");
// Make top section 3x the size of the bottom
topBottomSplitter->setStretchFactor(0, 3);
topBottomSplitter->setStretchFactor(1, 1);
//----------------------------------------------------------------------
// Connections
//----------------------------------------------------------------------
// Connect tab filters
connect(hitterPitcherTabs, &QTabWidget::currentChanged, this, [=](int index) {
// Update filters
ToggleFilterGroups(index);
// Update chart view
switch (index)
{
case PlayerTableTabs::Hitters:
chartView->SetProxyModel(hitterSortFilterProxyModel);
break;
case PlayerTableTabs::Pitchers:
chartView->SetProxyModel(pitcherSortFilterProxyModel);
break;
default:
break;
}
});
// Connect chart click
connect(chartView, &PlayerScatterPlotChart::PlayerClicked, this, [=](const QModelIndex& index) {
HighlightPlayerInTable(index);
});
// Connect summary model
connect(playerTableModel, &PlayerTableModel::DraftedEnd, summary, &SummaryWidget::OnDraftedEnd);
//----------------------------------------------------------------------
// Main
//----------------------------------------------------------------------
// Set as main window
QMainWindow::setCentralWidget(topBottomSplitter);
// Create main menu bar
QMenuBar* mainMenuBar = new QMenuBar();
QMainWindow::setMenuBar(mainMenuBar);
// Main Menu > File menu
QMenu* fileMenu = mainMenuBar->addMenu("&File");
// File dialog helper
auto GetFileDialog = [&](QFileDialog::AcceptMode mode) -> QFileDialog*
{
QFileDialog* dialog = new QFileDialog(this);
dialog->setWindowModality(Qt::WindowModal);
dialog->setAcceptMode(mode);
dialog->setNameFilter("CSV files (*.csv)");
return dialog;
};
// Ask for the save location
auto SetSaveAsFile = [=]()
{
QStringList files;
auto dialog = GetFileDialog(QFileDialog::AcceptSave);
if (dialog->exec()) {
files = dialog->selectedFiles();
} else {
return false;
}
m_currentFile = files.at(0);
return true;
};
// Update title bar
auto UpdateApplicationName = [this]()
{
auto name = QString("fbb -- %1").arg(QFileInfo(m_currentFile).fileName());
QCoreApplication::setApplicationName(name);
setWindowTitle(name);
};
// Main Menu > File menu > Save action
QAction* saveResultsAction = new QAction("&Save Results", this);
connect(saveResultsAction, &QAction::triggered, [=](bool checked) {
if (m_currentFile.isEmpty()) {
SetSaveAsFile();
}
GlobalLogger::AppendMessage(QString("Saving file: %1...").arg(m_currentFile));
UpdateApplicationName();
return playerTableModel->SaveDraftStatus(m_currentFile);
});
fileMenu->addAction(saveResultsAction);
// Main Menu > File menu > Save As action
QAction* saveResultsAsAction = new QAction("Save Results &As...", this);
connect(saveResultsAsAction, &QAction::triggered, [=](bool checked) {
SetSaveAsFile();
GlobalLogger::AppendMessage(QString("Saving file: %1...").arg(m_currentFile));
UpdateApplicationName();
return playerTableModel->SaveDraftStatus(m_currentFile);
});
fileMenu->addAction(saveResultsAsAction);
// Main Menu > File menu > Load action
QAction* loadResultsAction = new QAction("&Load Results...", this);
connect(loadResultsAction, &QAction::triggered, [=](bool checked) {
auto dialog = GetFileDialog(QFileDialog::AcceptOpen);
QStringList files;
if (dialog->exec()) {
files = dialog->selectedFiles();
} else {
return false;
}
m_currentFile = files.at(0);
GlobalLogger::AppendMessage(QString("Loading file: %1...").arg(m_currentFile));
UpdateApplicationName();
return playerTableModel->LoadDraftStatus(m_currentFile);
});
fileMenu->addAction(loadResultsAction);
// Main Menu > File menu
QMenu* settingsMenu = mainMenuBar->addMenu("&Settings");
// Main Menu > Settings menu > Options action
QAction* settingsAction = new QAction("&Settings...", this);
connect(settingsAction, &QAction::triggered, [=](bool checked) {
DraftSettingsDialog draftSettingsDialog;
if (draftSettingsDialog.exec()) {
UpdateOwnerLabels();
}
});
settingsMenu->addAction(settingsAction);
// Main Menu > Settings menu > Options action
QAction* demoDataAction = new QAction("&DemoData...", this);
connect(demoDataAction, &QAction::triggered, [=](bool checked) {
playerTableModel->DraftRandom();
});
settingsMenu->addAction(demoDataAction);
// show me
QMainWindow::show();
}
MDIClass::MDIClass( QWidget* parent )
: MDIChild( parent )
{
setObjectName( "MDIClass" );
setType( ctClass );
setWindowIcon( QIcon( ":/Icons/Icons/projectshowfile.png" ) );
//
QVBoxLayout* vboxLayout = new QVBoxLayout( this );
vboxLayout->setObjectName( "vboxLayout" );
vboxLayout->setSpacing( 0 );
vboxLayout->setMargin( 0 );
// Toolbar
QToolBar* tb = new QToolBar( tr( "Files" ), this );
tb->setFixedHeight( tb->height() );
tb->setIconSize( QSize(16, 16 ) );
// Action Group
aGroup = new QActionGroup( this );
aGroup->setObjectName( "aGroup" );
// Actions
actionForm = new QAction( QIcon( ":/Icons/Icons/form.png" ), tr( "Form" ), this );
actionForm->setCheckable( true );
aGroup->addAction( actionForm );
actionHeader = new QAction( QIcon( ":/Icons/Icons/h.png" ), tr( "Header" ), this );
actionHeader->setCheckable( true );
aGroup->addAction( actionHeader );
actionSource = new QAction( QIcon( ":/Icons/Icons/cpp.png" ), tr( "Source" ), this );
actionSource->setCheckable( true );
aGroup->addAction( actionSource );
tb->addActions( aGroup->actions() );
vboxLayout->addWidget( tb );
// Workspace
wSpace = new QWorkspace( this );
wSpace->setObjectName( "wSpace" );
vboxLayout->addWidget( wSpace );
// Form
// Header
teHeader = new TextEditor( this );
teHeader->setObjectName( "teHeader" );
teHeader->setFrameShape( QFrame::NoFrame );
teHeader->setFrameShadow( QFrame::Plain );
teHeader->setMidLineWidth( 1 );
teHeader->setDefaultComponents( true );
teHeader->setWindowIcon( actionHeader->icon() );
setSettings( teHeader );
connect( teHeader, SIGNAL( replaceDialogRequested() ), this, SIGNAL( replaceDialogRequested() ) );
connect( teHeader->completion(), SIGNAL( beforeCompletionShow() ), this, SLOT( beforeCompletionShow() ) );
connect( teHeader->document(), SIGNAL( modificationChanged( bool ) ), this, SIGNAL( modified( bool ) ) );
connect( teHeader, SIGNAL( fileOpen( bool ) ), this, SLOT( fileOpened( bool ) ) );
connect( teHeader, SIGNAL( completionRequested( Completion*, TextEditor* ) ), this, SLOT( completionRequested( Completion*, TextEditor* ) ) );
wSpace->addWindow( teHeader, Qt::WindowTitleHint );
// Source
teSource = new TextEditor( this );
teSource->setObjectName( "teSource" );
teSource->setFrameShape( QFrame::NoFrame );
teSource->setFrameShadow( QFrame::Plain );
teSource->setMidLineWidth( 1 );
teSource->setDefaultComponents( true );
teSource->setWindowIcon( actionSource->icon() );
setSettings( teSource );
connect( teSource, SIGNAL( replaceDialogRequested() ), this, SIGNAL( replaceDialogRequested() ) );
connect( teSource, SIGNAL( beforeCompletionShow() ), this, SLOT( beforeCompletionShow() ) );
connect( teSource->document(), SIGNAL( modificationChanged( bool ) ), this, SIGNAL( modified( bool ) ) );
connect( teSource, SIGNAL( fileOpen( bool ) ), this, SLOT( fileOpened( bool ) ) );
connect( teSource, SIGNAL( completionRequested( Completion*, TextEditor* ) ), this, SLOT( completionRequested( Completion*, TextEditor* ) ) );
wSpace->addWindow( teSource, Qt::WindowTitleHint );
// Connections
QMetaObject::connectSlotsByName( this );
}