MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
this->resize(800,680);
this->setWindowState(Qt::WindowMaximized);
ImageItem *image = new ImageItem();
//create ColorSelection
ColorSelection *CS1 = new ColorSelection(Qt::black);
ColorSelection *CS2 = new ColorSelection(Qt::white);
QObject::connect(CS1,SIGNAL(changeColor(QColor)),image,SLOT(setColor1(QColor)));
QObject::connect(image->getPipette(),SIGNAL(changeColor1(QColor)),CS1,SLOT(setColor(QColor)));
QObject::connect(CS2,SIGNAL(changeColor(QColor)),image,SLOT(setColor2(QColor)));
QObject::connect(image->getPipette(),SIGNAL(changeColor2(QColor)),CS2,SLOT(setColor(QColor)));
QHBoxLayout *Hlayout = new QHBoxLayout();
Hlayout->addStretch(5);
Hlayout->addWidget(CS1);
Hlayout->addWidget(CS2);
Hlayout->addStretch(5);
//Create slider
QSlider *slider = new QSlider(Qt::Horizontal);
slider->setMaximum(100);
slider->setMinimum(1);
slider->setValue(10);
QObject::connect(slider,SIGNAL(valueChanged(int)),image,SLOT(setSize(int)));
QVBoxLayout *Blayout = new QVBoxLayout();
Blayout->addWidget(slider);
Blayout->addLayout(Hlayout);
QWidget *wdg = new QWidget();
wdg->setLayout(Blayout);
// Create Dock
//
//
QDockWidget *dock = new QDockWidget(tr("Настройка"),this);
dock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
dock->setFeatures(QDockWidget::NoDockWidgetFeatures);
wdg->setFixedSize(200,100);
dock->setWidget(wdg);
dock->setMaximumHeight(300);
dock->setMaximumWidth(300);
addDockWidget(Qt::RightDockWidgetArea,dock);
QActionGroup *GP = new QActionGroup(this);
GP->addAction(ui->actionPencil);
GP->addAction(ui->actionEraser);
GP->addAction(ui->actionEllipse);
GP->addAction(ui->actionRectangle);
GP->addAction(ui->actionLine);
GP->addAction(ui->actionCurveLine);
GP->addAction(ui->actionFill);
GP->addAction(ui->actionPipette);
GP->addAction(ui->actionSelection);
GP->setExclusive(true);
//create tool bar
QToolBar *TB = new QToolBar();
TB->setAllowedAreas(Qt::TopToolBarArea | Qt::LeftToolBarArea);
TB->setFloatable(false);
TB->setMovable(true);
TB->insertAction(0,ui->actionSaveAs);
TB->insertAction(ui->actionSaveAs,ui->actionSave);
TB->insertAction(ui->actionSave,ui->actionOpen);
TB->insertAction(ui->actionOpen,ui->actionCreate);
TB->addSeparator();
TB->insertAction(0,ui->actionSelection);
TB->insertAction(ui->actionSelection,ui->actionPipette);
TB->insertAction(ui->actionPipette,ui->actionFill);
TB->insertAction(ui->actionFill,ui->actionCurveLine);
TB->insertAction(ui->actionCurveLine,ui->actionLine);
TB->insertAction(ui->actionLine,ui->actionRectangle);
TB->insertAction(ui->actionRectangle,ui->actionEllipse);
TB->insertAction(ui->actionEllipse,ui->actionEraser);
TB->insertAction(ui->actionEraser,ui->actionPencil);
addToolBar(Qt::TopToolBarArea, TB);
// create action connecting
QObject::connect(ui->actionOpen,SIGNAL(triggered(bool)),image,SLOT(open()));
QObject::connect(ui->actionSaveAs,SIGNAL(triggered(bool)),image,SLOT(saveAs()));
QObject::connect(ui->actionSave,SIGNAL(triggered(bool)),image,SLOT(save()));
QObject::connect(ui->actionPencil,SIGNAL(toggled(bool)),image,SLOT(setPencil(bool)));
QObject::connect(ui->actionEraser,SIGNAL(toggled(bool)),image,SLOT(setEraser(bool)));
QObject::connect(ui->actionEllipse,SIGNAL(toggled(bool)),image,SLOT(setEllipse(bool)));
QObject::connect(ui->actionRectangle,SIGNAL(toggled(bool)),image,SLOT(setRectangle(bool)));
QObject::connect(ui->actionLine,SIGNAL(toggled(bool)),image,SLOT(setLine(bool)));
QObject::connect(ui->actionCurveLine,SIGNAL(toggled(bool)),image,SLOT(setCurveLine(bool)));
QObject::connect(ui->actionFill,SIGNAL(toggled(bool)),image,SLOT(setFill(bool)));
QObject::connect(ui->actionPipette,SIGNAL(toggled(bool)),image,SLOT(setPipette(bool)));
QObject::connect(ui->actionSelection,SIGNAL(toggled(bool)),image,SLOT(setSelection(bool)));
//undo and redo
ui->actionUndo->setEnabled(false);
ui->actionRedo->setEnabled(false);
QObject::connect(image->getUndoStack(),SIGNAL(canUndo(bool)),ui->actionUndo,SLOT(setEnabled(bool)));
QObject::connect(ui->actionUndo,SIGNAL(triggered(bool)),image->getUndoStack(),SLOT(undo()));
QObject::connect(image->getUndoStack(),SIGNAL(canRedo(bool)),ui->actionRedo,SLOT(setEnabled(bool)));
QObject::connect(image->getUndoStack(),SIGNAL(canRedo(bool)),image,SLOT(setNewCurve(bool)));
QObject::connect(ui->actionRedo,SIGNAL(triggered(bool)),image->getUndoStack(),SLOT(redo()));
//copy and cut and put
ui->actionCopy->setEnabled(false);
ui->actionCut->setEnabled(false);
ui->actionPut->setEnabled(false);
QObject::connect(image->getSelection(),SIGNAL(canCopy(bool)),ui->actionCopy,SLOT(setEnabled(bool)));
QObject::connect(ui->actionCopy,SIGNAL(triggered(bool)),image,SLOT(makeCopy()));
QObject::connect(image->getSelection(),SIGNAL(canCopy(bool)),ui->actionCut,SLOT(setEnabled(bool)));
QObject::connect(ui->actionCut,SIGNAL(triggered(bool)),image,SLOT(makeCut()));
QObject::connect(image->getSelection(),SIGNAL(canPut(bool)),ui->actionPut,SLOT(setEnabled(bool)));
QObject::connect(ui->actionPut,SIGNAL(triggered(bool)),image,SLOT(makePut()));
QObject::connect(ui->actionSelection,SIGNAL(changed()),image,SLOT(clearSelection()));
ui->scrollArea->setBackgroundRole(QPalette :: Dark);
ui->scrollArea->setWidget(image);
}
MainUI::MainUI(bool debugmode) : QMainWindow(){
//Setup UI
DEBUG = debugmode;
AUTHCOMPLETE = false; //not performed yet
this->setWindowTitle(tr("AppCafe"));
//Need 1024 wide if possible
this->resize(1024,600);
this->setWindowIcon( QIcon(":icons/appcafe.png") );
if(this->centralWidget()==0){ this->setCentralWidget( new QWidget(this) ); }
this->centralWidget()->setLayout( new QVBoxLayout() );
this->centralWidget()->layout()->setContentsMargins(0,0,0,0);
this->setStatusBar(new QStatusBar());
//Setup the ToolBar
QToolBar *tb = this->addToolBar("");
tb->setMovable(false);
tb->setFloatable(false);
tb->setContextMenuPolicy(Qt::CustomContextMenu); //disable the built-in visibility context menu
backA = tb->addAction(QIcon(":icons/back.png"), tr("Back"), this, SLOT(GoBack()) );
forA = tb->addAction(QIcon(":icons/forward.png"), tr("Forward"), this, SLOT(GoForward()) );
refA = tb->addAction(QIcon(":icons/refresh.png"), tr("Refresh"), this, SLOT(GoRefresh()) );
stopA = tb->addAction(QIcon(":icons/stop.png"), tr("Stop"), this, SLOT(GoStop()) );
// - toolbar spacer
QWidget *spacer = new QWidget(this);
spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
tb->addWidget(spacer);
// - Progress bar
progressBar = new QProgressBar(this);
progressBar->setRange(0,100);
progA = tb->addWidget(progressBar); //add it to the end of the toolbar
progA->setVisible(false); //start off invisible
// - List Button
listB = new QToolButton(this);
listB->setIcon( QIcon(":icons/list.png") );
listB->setToolTip( tr("AppCafe Options") );
listB->setStyleSheet( "QToolButton::menu-indicator{ image: none; }" );
listB->setPopupMode(QToolButton::InstantPopup);
tb->addWidget(listB);
//Setup the menu for this button
listMenu = new QMenu();
listMenu->addAction(QIcon(":icons/configure.png"), tr("Configure"), this, SLOT(GoConfigure() ) );
listMenu->addAction(QIcon(":icons/list.png"), tr("Save Pkg List"), this, SLOT(Save_pkglist() ) );
listMenu->addSeparator();
listMenu->addAction(QIcon(":icons/search.png"), tr("Search For Text"), this, SLOT(openSearch() ) );
listMenu->addSeparator();
listMenu->addAction(QIcon(":icons/close.png"), tr("Close AppCafe"), this, SLOT(GoClose() ) );
listB->setMenu(listMenu);
//Setup the search options
group_search = new QFrame(this);
group_search->setLayout( new QHBoxLayout() );
group_search->layout()->setContentsMargins(2,2,2,2);
line_search = new QLineEdit(this);
group_search->layout()->addWidget(line_search);
tool_search = new QToolButton(this);
group_search->layout()->addWidget(tool_search);
tool_search->setIcon( QIcon(":icons/search.png") );
group_search->layout()->addItem(new QSpacerItem(0,0,QSizePolicy::Expanding, QSizePolicy::Minimum) );
//Setup the Main Interface
webview = new QWebView(this);
this->centralWidget()->layout()->addWidget(webview);
if(webview->page()==0){ webview->setPage(new QWebPage(webview)); }
webview->page()->setLinkDelegationPolicy(QWebPage::DelegateAllLinks);
this->centralWidget()->layout()->addWidget(group_search);
//Make sure the search bar is hidden to start with
group_search->setVisible(false);
//Create the special keyboard shortcuts
QKeySequence key(QKeySequence::Find);
ctrlF = new QShortcut( key, this );
key = QKeySequence(Qt::Key_Escape);
esc = new QShortcut( key, this );
//Connect signals/slots
connect(webview, SIGNAL(linkClicked(const QUrl&)), this, SLOT(LinkClicked(const QUrl&)) );
connect(webview, SIGNAL(loadStarted()), this, SLOT(PageStartLoading()) );
connect(webview, SIGNAL(loadProgress(int)), this, SLOT(PageLoadProgress(int)) );
connect(webview, SIGNAL(loadFinished(bool)), this, SLOT(PageDoneLoading(bool)) );
connect(webview->page()->networkAccessManager(), SIGNAL(sslErrors(QNetworkReply*, const QList<QSslError>&)), this, SLOT( authenticate(QNetworkReply*) ) );
connect(tool_search, SIGNAL(clicked()), this, SLOT(GoSearch()) );
connect(line_search, SIGNAL(returnPressed()), this, SLOT(GoSearch()) );
connect(ctrlF, SIGNAL(activated()), this, SLOT(openSearch()) );
connect(esc, SIGNAL(activated()), this, SLOT(closeSearch()) );
if(DEBUG){
//connect(webview, SIGNAL(statusBarMessage(const QString&)), this, SLOT(StatusTextChanged(const QString&)) );
connect(webview->page(), SIGNAL(linkHovered(const QString&, const QString&, const QString&)), this, SLOT(StatusTextChanged(const QString&)) );
}
this->statusBar()->setVisible(DEBUG);
loadHomePage();
webview->show();
}
ObjectsDock::ObjectsDock(QWidget *parent)
: QDockWidget(parent)
, mObjectsView(new ObjectsView)
, mMapDocument(nullptr)
{
setObjectName(QLatin1String("ObjectsDock"));
mActionObjectProperties = new QAction(this);
mActionObjectProperties->setIcon(QIcon(QLatin1String(":/images/16x16/document-properties.png")));
connect(mActionObjectProperties, SIGNAL(triggered()), SLOT(objectProperties()));
MapDocumentActionHandler *handler = MapDocumentActionHandler::instance();
QWidget *widget = new QWidget(this);
QVBoxLayout *layout = new QVBoxLayout(widget);
layout->setMargin(0);
layout->setSpacing(0);
layout->addWidget(mObjectsView);
mActionNewLayer = new QAction(this);
mActionNewLayer->setIcon(QIcon(QLatin1String(":/images/16x16/document-new.png")));
connect(mActionNewLayer, SIGNAL(triggered()),
handler->actionAddObjectGroup(), SIGNAL(triggered()));
mActionMoveToGroup = new QAction(this);
mActionMoveToGroup->setIcon(QIcon(QLatin1String(":/images/16x16/layer-object.png")));
mActionMoveUp = new QAction(this);
mActionMoveUp->setIcon(QIcon(QLatin1String(":/images/16x16/go-up.png")));
mActionMoveDown = new QAction(this);
mActionMoveDown->setIcon(QIcon(QLatin1String(":/images/16x16/go-down.png")));
Utils::setThemeIcon(mActionObjectProperties, "document-properties");
Utils::setThemeIcon(mActionMoveUp, "go-up");
Utils::setThemeIcon(mActionMoveDown, "go-down");
QToolBar *toolBar = new QToolBar;
toolBar->setFloatable(false);
toolBar->setMovable(false);
toolBar->setIconSize(QSize(16, 16));
toolBar->addAction(mActionNewLayer);
toolBar->addAction(handler->actionDuplicateObjects());
toolBar->addAction(handler->actionRemoveObjects());
toolBar->addAction(mActionMoveUp);
toolBar->addAction(mActionMoveDown);
toolBar->addAction(mActionMoveToGroup);
QToolButton *button;
button = dynamic_cast<QToolButton*>(toolBar->widgetForAction(mActionMoveToGroup));
mMoveToMenu = new QMenu(this);
button->setPopupMode(QToolButton::InstantPopup);
button->setMenu(mMoveToMenu);
connect(mMoveToMenu, SIGNAL(aboutToShow()), SLOT(aboutToShowMoveToMenu()));
connect(mMoveToMenu, SIGNAL(triggered(QAction*)),
SLOT(triggeredMoveToMenu(QAction*)));
toolBar->addAction(mActionObjectProperties);
layout->addWidget(toolBar);
setWidget(widget);
retranslateUi();
connect(DocumentManager::instance(), &DocumentManager::documentAboutToClose,
this, &ObjectsDock::documentAboutToClose);
connect(mActionMoveUp, &QAction::triggered, this, &ObjectsDock::moveObjectsUp);
connect(mActionMoveDown, &QAction::triggered, this, &ObjectsDock::moveObjectsDown);
}
TileStampsDock::TileStampsDock(TileStampManager *stampManager, QWidget *parent)
: QDockWidget(parent)
, mTileStampManager(stampManager)
, mTileStampModel(stampManager->tileStampModel())
, mProxyModel(new QSortFilterProxyModel(mTileStampModel))
, mFilterEdit(new FilterEdit(this))
, mNewStamp(new QAction(this))
, mAddVariation(new QAction(this))
, mDuplicate(new QAction(this))
, mDelete(new QAction(this))
, mChooseFolder(new QAction(this))
{
setObjectName(QLatin1String("TileStampsDock"));
mProxyModel->setSortLocaleAware(true);
mProxyModel->setSortCaseSensitivity(Qt::CaseInsensitive);
mProxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
mProxyModel->setSourceModel(mTileStampModel);
mProxyModel->sort(0);
mTileStampView = new TileStampView(this);
mTileStampView->setModel(mProxyModel);
mTileStampView->setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
mTileStampView->header()->setStretchLastSection(false);
mTileStampView->header()->setSectionResizeMode(0, QHeaderView::Stretch);
mTileStampView->header()->setSectionResizeMode(1, QHeaderView::ResizeToContents);
mTileStampView->setContextMenuPolicy(Qt::CustomContextMenu);
connect(mTileStampView, &QWidget::customContextMenuRequested,
this, &TileStampsDock::showContextMenu);
mNewStamp->setIcon(QIcon(QLatin1String(":images/16x16/document-new.png")));
mAddVariation->setIcon(QIcon(QLatin1String(":/images/16x16/add.png")));
mDuplicate->setIcon(QIcon(QLatin1String(":/images/16x16/stock-duplicate-16.png")));
mDelete->setIcon(QIcon(QLatin1String(":images/16x16/edit-delete.png")));
mChooseFolder->setIcon(QIcon(QLatin1String(":images/16x16/document-open.png")));
Utils::setThemeIcon(mNewStamp, "document-new");
Utils::setThemeIcon(mAddVariation, "add");
Utils::setThemeIcon(mDelete, "edit-delete");
Utils::setThemeIcon(mChooseFolder, "document-open");
mFilterEdit->setFilteredView(mTileStampView);
connect(mFilterEdit, &QLineEdit::textChanged,
mProxyModel, &QSortFilterProxyModel::setFilterFixedString);
connect(mTileStampModel, &TileStampModel::stampRenamed,
this, &TileStampsDock::ensureStampVisible);
connect(mNewStamp, &QAction::triggered, this, &TileStampsDock::newStamp);
connect(mAddVariation, &QAction::triggered, this, &TileStampsDock::addVariation);
connect(mDuplicate, &QAction::triggered, this, &TileStampsDock::duplicate);
connect(mDelete, &QAction::triggered, this, &TileStampsDock::delete_);
connect(mChooseFolder, &QAction::triggered, this, &TileStampsDock::chooseFolder);
mDuplicate->setEnabled(false);
mDelete->setEnabled(false);
mAddVariation->setEnabled(false);
QWidget *widget = new QWidget(this);
QVBoxLayout *layout = new QVBoxLayout(widget);
layout->setMargin(0);
QToolBar *buttonContainer = new QToolBar;
buttonContainer->setFloatable(false);
buttonContainer->setMovable(false);
buttonContainer->setIconSize(Utils::smallIconSize());
buttonContainer->addAction(mNewStamp);
buttonContainer->addAction(mAddVariation);
buttonContainer->addAction(mDuplicate);
buttonContainer->addAction(mDelete);
QWidget *stretch = new QWidget;
stretch->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
buttonContainer->addWidget(stretch);
buttonContainer->addAction(mChooseFolder);
QVBoxLayout *listAndToolBar = new QVBoxLayout;
listAndToolBar->setSpacing(0);
listAndToolBar->addWidget(mFilterEdit);
listAndToolBar->addWidget(mTileStampView);
listAndToolBar->addWidget(buttonContainer);
layout->addLayout(listAndToolBar);
QItemSelectionModel *selectionModel = mTileStampView->selectionModel();
connect(selectionModel, &QItemSelectionModel::currentRowChanged,
this, &TileStampsDock::currentRowChanged);
connect(mTileStampView, &QAbstractItemView::pressed,
this, &TileStampsDock::indexPressed);
setWidget(widget);
retranslateUi();
}
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();
}
MainUI::MainUI(bool debugmode, QString fileURL, QString title, QString iconpath) : QMainWindow(){
//Setup UI
DEBUG = debugmode;
baseURL = fileURL;
AUTHCOMPLETE = false; //not performed yet
if(title.isEmpty()){
if(baseURL.contains("://")){
this->setWindowTitle(baseURL);
}else{
this->setWindowTitle(baseURL.section("/",-1));
}
}else{
this->setWindowTitle(title);
}
this->resize(1024,600);
//Check the given icon
QIcon ico;
if(!iconpath.isEmpty()){
//qDebug() << "Checking icon:" << iconpath;
if(iconpath.startsWith("/") && QFile::exists(iconpath)){ico = QIcon(iconpath); }
else if( QFile::exists("/usr/local/share/pixmaps/"+iconpath)){ ico = QIcon("/usr/local/share/pixmaps/"+iconpath); }
else if( QFile::exists("/usr/local/share/pixmaps/"+iconpath+".png")){ ico = QIcon("/usr/local/share/pixmaps/"+iconpath+".png"); }
else{ ico = QIcon::fromTheme(iconpath); }
}
if(ico.isNull()){ico = QIcon(":icons/webview.png"); }
this->setWindowIcon( ico);
if(this->centralWidget()==0){ this->setCentralWidget( new QWidget(this) ); }
this->centralWidget()->setLayout( new QVBoxLayout() );
this->centralWidget()->layout()->setContentsMargins(0,0,0,0);
this->setStatusBar(new QStatusBar());
//Setup the ToolBar
QToolBar *tb = this->addToolBar("");
tb->setMovable(false);
tb->setFloatable(false);
backA = tb->addAction(QIcon(":icons/back.png"), tr("Back"), this, SLOT(GoBack()) );
forA = tb->addAction(QIcon(":icons/forward.png"), tr("Forward"), this, SLOT(GoForward()) );
refA = tb->addAction(QIcon(":icons/refresh.png"), tr("Refresh"), this, SLOT(GoRefresh()) );
stopA = tb->addAction(QIcon(":icons/stop.png"), tr("Stop"), this, SLOT(GoStop()) );
// - toolbar spacer
QWidget *spacer = new QWidget(this);
spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
tb->addWidget(spacer);
// - Progress bar
progressBar = new QProgressBar(this);
progressBar->setRange(0,100);
progA = tb->addWidget(progressBar); //add it to the end of the toolbar
progA->setVisible(false); //start off invisible
//Setup the search options
group_search = new QFrame(this);
group_search->setLayout( new QHBoxLayout() );
group_search->layout()->setContentsMargins(2,2,2,2);
line_search = new QLineEdit(this);
group_search->layout()->addWidget(line_search);
tool_search = new QToolButton(this);
group_search->layout()->addWidget(tool_search);
tool_search->setIcon( QIcon(":icons/search.png") );
group_search->layout()->addItem(new QSpacerItem(0,0,QSizePolicy::Expanding, QSizePolicy::Minimum) );
//Setup the Main Interface
webview = new QWebView(this);
this->centralWidget()->layout()->addWidget(webview);
if(webview->page()==0){ webview->setPage(new QWebPage(webview)); }
webview->page()->setLinkDelegationPolicy(QWebPage::DelegateAllLinks);
this->centralWidget()->layout()->addWidget(group_search);
//Make sure the search bar is hidden to start with
group_search->setVisible(false);
//Create the special keyboard shortcuts
QKeySequence key(QKeySequence::Find);
ctrlF = new QShortcut( key, this );
key = QKeySequence(Qt::Key_Escape);
esc = new QShortcut( key, this );
//Connect signals/slots
connect(webview, SIGNAL(linkClicked(const QUrl&)), this, SLOT(LinkClicked(const QUrl&)) );
connect(webview, SIGNAL(urlChanged(const QUrl&)), this, SLOT(LinkClicked(const QUrl&)) );
connect(webview, SIGNAL(loadStarted()), this, SLOT(PageStartLoading()) );
connect(webview, SIGNAL(loadProgress(int)), this, SLOT(PageLoadProgress(int)) );
connect(webview, SIGNAL(loadFinished(bool)), this, SLOT(PageDoneLoading(bool)) );
connect(webview->page()->networkAccessManager(), SIGNAL(sslErrors(QNetworkReply*, const QList<QSslError>&)), this, SLOT( authenticate(QNetworkReply*) ) );
connect(tool_search, SIGNAL(clicked()), this, SLOT(GoSearch()) );
connect(line_search, SIGNAL(returnPressed()), this, SLOT(GoSearch()) );
connect(ctrlF, SIGNAL(activated()), this, SLOT(openSearch()) );
connect(esc, SIGNAL(activated()), this, SLOT(closeSearch()) );
if(DEBUG){
//connect(webview, SIGNAL(statusBarMessage(const QString&)), this, SLOT(StatusTextChanged(const QString&)) );
connect(webview->page(), SIGNAL(linkHovered(const QString&, const QString&, const QString&)), this, SLOT(StatusTextChanged(const QString&)) );
}
this->statusBar()->setVisible(DEBUG);
loadHomePage();
webview->show();
}
LayerDock::LayerDock(QWidget *parent):
QDockWidget(parent),
mOpacityLabel(new QLabel),
mOpacitySlider(new QSlider(Qt::Horizontal)),
mLayerView(new LayerView),
mMapDocument(nullptr),
mUpdatingSlider(false),
mChangingLayerOpacity(false)
{
setObjectName(QLatin1String("layerDock"));
QWidget *widget = new QWidget(this);
QVBoxLayout *layout = new QVBoxLayout(widget);
layout->setMargin(0);
QHBoxLayout *opacityLayout = new QHBoxLayout;
mOpacitySlider->setRange(0, 100);
mOpacitySlider->setEnabled(false);
opacityLayout->addWidget(mOpacityLabel);
opacityLayout->addWidget(mOpacitySlider);
mOpacityLabel->setBuddy(mOpacitySlider);
MapDocumentActionHandler *handler = MapDocumentActionHandler::instance();
QMenu *newLayerMenu = new QMenu(this);
newLayerMenu->addAction(handler->actionAddTileLayer());
newLayerMenu->addAction(handler->actionAddObjectGroup());
newLayerMenu->addAction(handler->actionAddImageLayer());
const QIcon newIcon(QLatin1String(":/images/16x16/document-new.png"));
QToolButton *newLayerButton = new QToolButton;
newLayerButton->setPopupMode(QToolButton::InstantPopup);
newLayerButton->setMenu(newLayerMenu);
newLayerButton->setIcon(newIcon);
Utils::setThemeIcon(newLayerButton, "document-new");
QToolBar *buttonContainer = new QToolBar;
buttonContainer->setFloatable(false);
buttonContainer->setMovable(false);
buttonContainer->setIconSize(QSize(16, 16));
buttonContainer->addWidget(newLayerButton);
buttonContainer->addAction(handler->actionMoveLayerUp());
buttonContainer->addAction(handler->actionMoveLayerDown());
buttonContainer->addAction(handler->actionDuplicateLayer());
buttonContainer->addAction(handler->actionRemoveLayer());
buttonContainer->addSeparator();
buttonContainer->addAction(handler->actionToggleOtherLayers());
QVBoxLayout *listAndToolBar = new QVBoxLayout;
listAndToolBar->setSpacing(0);
listAndToolBar->addWidget(mLayerView);
listAndToolBar->addWidget(buttonContainer);
layout->addLayout(opacityLayout);
layout->addLayout(listAndToolBar);
setWidget(widget);
retranslateUi();
connect(mOpacitySlider, SIGNAL(valueChanged(int)),
this, SLOT(sliderValueChanged(int)));
updateOpacitySlider();
}
TemplatesDock::TemplatesDock(QWidget *parent)
: QDockWidget(parent)
, mTemplatesView(new TemplatesView)
, mChooseDirectory(new QAction(this))
, mUndoAction(new QAction(this))
, mRedoAction(new QAction(this))
, mMapScene(new MapScene(this))
, mMapView(new MapView(this, MapView::NoStaticContents))
, mToolManager(new ToolManager(this))
{
setObjectName(QLatin1String("TemplatesDock"));
QWidget *widget = new QWidget(this);
// Prevent dropping a template into the editing view
mMapView->setAcceptDrops(false);
mMapView->setScene(mMapScene);
mMapView->setResizeAnchor(QGraphicsView::AnchorViewCenter);
mMapView->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
mMapView->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
QToolBar *toolBar = new QToolBar;
toolBar->setFloatable(false);
toolBar->setMovable(false);
toolBar->setIconSize(Utils::smallIconSize());
mChooseDirectory->setIcon(QIcon(QLatin1String(":/images/16x16/document-open.png")));
Utils::setThemeIcon(mChooseDirectory, "document-open");
connect(mChooseDirectory, &QAction::triggered, this, &TemplatesDock::chooseDirectory);
toolBar->addAction(mChooseDirectory);
mUndoAction->setIcon(QIcon(QLatin1String(":/images/16x16/edit-undo.png")));
Utils::setThemeIcon(mUndoAction, "edit-undo");
connect(mUndoAction, &QAction::triggered, this, &TemplatesDock::undo);
mRedoAction->setIcon(QIcon(QLatin1String(":/images/16x16/edit-redo.png")));
Utils::setThemeIcon(mRedoAction, "edit-redo");
connect(mRedoAction, &QAction::triggered, this, &TemplatesDock::redo);
// Initially disabled until a change happens
mUndoAction->setDisabled(true);
mRedoAction->setDisabled(true);
QToolBar *editingToolBar = new QToolBar;
editingToolBar->setFloatable(false);
editingToolBar->setMovable(false);
editingToolBar->setIconSize(Utils::smallIconSize());
auto objectSelectionTool = new ObjectSelectionTool(this);
auto editPolygonTool = new EditPolygonTool(this);
// Assign empty shortcuts to avoid collision with the map editor
objectSelectionTool->setShortcut(QKeySequence());
editPolygonTool->setShortcut(QKeySequence());
editingToolBar->addAction(mUndoAction);
editingToolBar->addAction(mRedoAction);
editingToolBar->addSeparator();
editingToolBar->addAction(mToolManager->registerTool(objectSelectionTool));
editingToolBar->addAction(mToolManager->registerTool(editPolygonTool));
mFixTilesetButton = new QPushButton(this);
connect(mFixTilesetButton, &QPushButton::clicked, this, &TemplatesDock::fixTileset);
mFixTilesetButton->setVisible(false);
mDescriptionLabel = new QLabel;
mDescriptionLabel->setWordWrap(true);
mDescriptionLabel->setVisible(false);
auto toolsLayout = new QHBoxLayout;
toolsLayout->addWidget(editingToolBar);
toolsLayout->addWidget(mFixTilesetButton);
auto *editorLayout = new QVBoxLayout;
editorLayout->addLayout(toolsLayout);
editorLayout->addWidget(mDescriptionLabel);
editorLayout->addWidget(mMapView);
editorLayout->setMargin(0);
editorLayout->setSpacing(0);
auto *editorWidget = new QWidget;
editorWidget->setLayout(editorLayout);
auto *splitter = new QSplitter;
splitter->addWidget(mTemplatesView);
splitter->addWidget(editorWidget);
auto *layout = new QVBoxLayout(widget);
layout->setMargin(0);
layout->setSpacing(0);
layout->addWidget(splitter);
layout->addWidget(toolBar);
setWidget(widget);
retranslateUi();
connect(mTemplatesView, &TemplatesView::currentTemplateChanged,
this, &TemplatesDock::currentTemplateChanged);
connect(mTemplatesView, &TemplatesView::currentTemplateChanged,
this, &TemplatesDock::setTemplate);
connect(mTemplatesView, &TemplatesView::focusInEvent,
this, &TemplatesDock::focusInEvent);
connect(mTemplatesView, &TemplatesView::focusOutEvent,
this, &TemplatesDock::focusOutEvent);
connect(mToolManager, &ToolManager::selectedToolChanged,
mMapScene, &MapScene::setSelectedTool);
setFocusPolicy(Qt::ClickFocus);
mMapView->setFocusProxy(this);
}
//---------------------------------------------------------------
void SkewTWindow::createToolBar ()
{
QToolBar *toolBar = addToolBar (tr("skewt"));
toolBar->setFloatable(false);
toolBar->setMovable(false);
//------------------------------------
acExit = new QAction (this);
acExit->setToolTip (tr("Close the window"));
acExit->setIcon(QIcon(Util::pathImg("exit.png")));
connect(acExit, SIGNAL(triggered()), this, SLOT(actionsCommonSlot()));
toolBar->addAction (acExit);
acPrint = new QAction (this);
acPrint->setToolTip (tr("Print the diagram"));
acPrint->setIcon(QIcon(Util::pathImg("printer.png")));
connect(acPrint, SIGNAL(triggered()), this, SLOT(actionsCommonSlot()));
toolBar->addAction (acPrint);
acSaveImage = new QAction (this);
acSaveImage->setToolTip (tr("Save current image"));
acSaveImage->setIcon(QIcon(Util::pathImg("media-floppy.png")));
connect(acSaveImage, SIGNAL(triggered()), this, SLOT(actionsCommonSlot()));
toolBar->addAction (acSaveImage);
acExportData = new QAction (this);
acExportData->setToolTip (tr("Export data (spreadsheet file)"));
acExportData->setIcon(QIcon(Util::pathImg("spreadsheet.png")));
connect(acExportData, SIGNAL(triggered()), this, SLOT(actionsCommonSlot()));
toolBar->addAction (acExportData);
toolBar->addSeparator();
//------------------------------------
toolBar->addWidget (new QLabel (tr("T max: ")));
cbTempMax = new QComboBox (this);
for (int t=-40; t<=80; t+=5)
cbTempMax->addItem (QString("%1 °C").arg(t), t);
cbTempMax->setMaxVisibleItems (50);
connect(cbTempMax, SIGNAL(activated(int)), this, SLOT(actionsCommonSlot()));
double tmax = Util::getSetting ("skewt_tempCMax", 40).toDouble();
cbTempMax->setCurrentIndex (cbTempMax->findData (tmax));
toolBar->addWidget (cbTempMax);
//------------------------------------
toolBar->addWidget (new QLabel (tr("P min: ")));
cbHpaMin = new QComboBox (this);
for (int p=100; p<=700; p+=100)
cbHpaMin->addItem (QString("%1 hPa").arg(p), p-5);
connect(cbHpaMin, SIGNAL(activated(int)), this, SLOT(actionsCommonSlot()));
double pmin = Util::getSetting ("skewt_hpaMin", 190).toDouble();
cbHpaMin->setCurrentIndex (cbHpaMin->findData (pmin));
toolBar->addWidget (cbHpaMin);
//------------------------------------
double sz;
toolBar->addWidget (new QLabel (tr("Size: ")));
cbSizeW = new QComboBox (this);
for (double s=600; s<=2000; s+=200)
cbSizeW->addItem (QString("%1").arg(s), s);
connect(cbSizeW, SIGNAL(activated(int)), this, SLOT(actionsCommonSlot()));
sz = Util::getSetting ("skewt_sizeW", 800).toDouble();
cbSizeW->setCurrentIndex (cbSizeW->findData (sz));
toolBar->addWidget (cbSizeW);
cbSizeH = new QComboBox (this);
for (double s=600; s<=2000; s+=200)
cbSizeH->addItem (QString("%1").arg(s), s);
connect(cbSizeH, SIGNAL(activated(int)), this, SLOT(actionsCommonSlot()));
sz = Util::getSetting ("skewt_sizeH", 800).toDouble();
cbSizeH->setCurrentIndex (cbSizeH->findData (sz));
toolBar->addWidget (cbSizeH);
toolBar->addSeparator();
//------------------------------------
chkShowConv = new QCheckBox (tr("Base: "),this);
chkShowConv->setChecked (Util::getSetting ("skewt_showConvectiveCurves",true).toBool());
connect(chkShowConv, SIGNAL(stateChanged(int)), this, SLOT(actionsCommonSlot()));
toolBar->addWidget (chkShowConv);
cbConvBase = new QComboBox (this);
if (skewt->hasSurfaceData) {
cbConvBase->addItem ( ("Surface"), "surface");
cbConvBase->addItem ( ("Avg Surface-10 hPa"), "surface-10");
cbConvBase->addItem ( ("Avg Surface-20 hPa"), "surface-20");
cbConvBase->addItem ( ("Avg Surface-50 hPa"), "surface-50");
cbConvBase->addItem ( ("Avg Surface-100 hPa"), "surface-100");
}
cbConvBase->addItem ("1000 hPa", "1000-1000");
cbConvBase->addItem ("975 hPa", "975-975");
cbConvBase->addItem ("950 hPa", "950-950");
cbConvBase->addItem ("925 hPa", "925-925");
cbConvBase->addItem ("900 hPa", "900-900");
cbConvBase->addItem ("850 hPa", "850-850");
cbConvBase->addItem ("800 hPa", "800-800");
cbConvBase->addItem ("750 hPa", "750-750");
cbConvBase->addItem ("700 hPa", "700-700");
cbConvBase->addItem ("650 hPa", "650-650");
cbConvBase->addItem ("Avg 1000-975 hPa", "1000-975");
cbConvBase->addItem ("Avg 1000-950 hPa", "1000-950");
cbConvBase->addItem ("Avg 1000-925 hPa", "1000-925");
cbConvBase->addItem ("Avg 1000-900 hPa", "1000-900");
cbConvBase->addItem ("Avg 1000-850 hPa", "1000-850");
cbConvBase->addItem ("Avg 1000-800 hPa", "1000-800");
cbConvBase->setMaxVisibleItems (50);
connect(cbConvBase, SIGNAL(activated(int)), this, SLOT(actionsCommonSlot()));
QString sbase = Util::getSetting ("skewt_convectiveBase", "1000-1000").toString();
cbConvBase->setCurrentIndex (cbConvBase->findData (sbase));
cbConvBase->setEnabled (chkShowConv->isChecked());
toolBar->addWidget (cbConvBase);
}
PythonEditorWidget::PythonEditorWidget(InviwoMainWindow* ivwwin, InviwoApplication* app)
: InviwoDockWidget(tr("Python Editor"), ivwwin)
, settings_("Inviwo", "Inviwo")
, infoTextColor_(153, 153, 153)
, errorTextColor_(255, 107, 107)
, runAction_(nullptr)
, script_()
, unsavedChanges_(false)
, app_(app)
, appendLog_(true)
{
setObjectName("PythonEditor");
settings_.beginGroup("PythonEditor");
QString lastFile = settings_.value("lastScript", "").toString();
appendLog_ = settings_.value("appendLog", appendLog_).toBool();
settings_.endGroup();
setVisible(false);
setWindowIcon(QIcon(":/icons/python.png"));
QMainWindow* mainWindow = new QMainWindow();
mainWindow->setContextMenuPolicy(Qt::NoContextMenu);
QToolBar* toolBar = new QToolBar();
mainWindow->addToolBar(toolBar);
toolBar->setFloatable(false);
toolBar->setMovable(false);
setWidget(mainWindow);
{
runAction_ = toolBar->addAction(QIcon(":/icons/python.png"), "Compile and Run");
runAction_->setShortcut(QKeySequence(tr("F5")));
runAction_->setShortcutContext(Qt::WidgetWithChildrenShortcut);
runAction_->setToolTip("Compile and Run Script");
mainWindow->addAction(runAction_);
connect(runAction_, &QAction::triggered, [this]() {run(); });
}
{
auto action = toolBar->addAction(QIcon(":/icons/new.png"), tr("&New Script"));
action->setShortcut(QKeySequence::New);
action->setShortcutContext(Qt::WidgetWithChildrenShortcut);
action->setToolTip("New Script");
mainWindow->addAction(action);
connect(action, &QAction::triggered, [this](){setDefaultText();});
}
{
auto action = toolBar->addAction(QIcon(":/icons/open.png"), tr("&Open Script"));
action->setShortcut(QKeySequence::Open);
action->setShortcutContext(Qt::WidgetWithChildrenShortcut);
action->setToolTip("Open Script");
mainWindow->addAction(action);
connect(action, &QAction::triggered, [this](){open();});
}
{
auto action = toolBar->addAction(QIcon(":/icons/save.png"), tr("&Save Script"));
action->setShortcut(QKeySequence::Save);
action->setShortcutContext(Qt::WidgetWithChildrenShortcut);
action->setToolTip("Save Script");
mainWindow->addAction(action);
connect(action, &QAction::triggered, [this](){save();});
}
{
auto action = toolBar->addAction(QIcon(":/icons/saveas.png"), tr("&Save Script As..."));
action->setShortcut(QKeySequence::SaveAs);
action->setShortcutContext(Qt::WidgetWithChildrenShortcut);
action->setToolTip("Save Script As...");
mainWindow->addAction(action);
connect(action, &QAction::triggered, [this](){saveAs();});
}
{
QIcon icon;
icon.addFile(":/icons/log-append.png", QSize(), QIcon::Normal, QIcon::On);
icon.addFile(":/icons/log-clearonrun.png", QSize(), QIcon::Normal, QIcon::Off);
QString str = (appendLog_ ? "Append Log" : "Clear Log on Run");
auto action = toolBar->addAction(icon, str);
action->setShortcut(Qt::ControlModifier + Qt::Key_E);
action->setShortcutContext(Qt::WidgetWithChildrenShortcut);
action->setCheckable(true);
action->setChecked(appendLog_);
action->setToolTip(appendLog_ ? "Append Log" : "Clear Log on Run");
mainWindow->addAction(action);
connect(action, &QAction::toggled, [this, action](bool toggle) {
appendLog_ = toggle;
// update tooltip and menu entry
QString tglstr = (toggle ? "Append Log" : "Clear Log on Run");
action->setText(tglstr);
action->setToolTip(tglstr);
// update settings
settings_.beginGroup("PythonEditor");
settings_.setValue("appendLog", appendLog_);
settings_.endGroup();
});
}
{
auto action = toolBar->addAction(QIcon(":/icons/log-clear.png"), "Clear Log Output");
action->setShortcut(Qt::ControlModifier + Qt::Key_E);
action->setShortcutContext(Qt::WidgetWithChildrenShortcut);
action->setToolTip("Clear Log Output");
mainWindow->addAction(action);
connect(action, &QAction::triggered, [this](){clearOutput();});
}
// Done creating buttons
QSplitter* splitter = new QSplitter(nullptr);
splitter->setOrientation(Qt::Vertical);
pythonCode_ = new PythonTextEditor(nullptr);
pythonCode_->setObjectName("pythonEditor");
pythonCode_->setUndoRedoEnabled(true);
setDefaultText();
pythonOutput_ = new QTextEdit(nullptr);
pythonOutput_->setObjectName("pythonConsole");
pythonOutput_->setReadOnly(true);
pythonOutput_->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
syntaxHighligther_ =
SyntaxHighligther::createSyntaxHighligther<Python>(pythonCode_->document());
splitter->addWidget(pythonCode_);
splitter->addWidget(pythonOutput_);
splitter->setStretchFactor(0, 1);
splitter->setStretchFactor(1, 0);
splitter->setHandleWidth(2);
// enable QSplitter:hover stylesheet
// QTBUG-13768 https://bugreports.qt.io/browse/QTBUG-13768
splitter->handle(1)->setAttribute(Qt::WA_Hover);
mainWindow->setCentralWidget(splitter);
QObject::connect(pythonCode_, SIGNAL(textChanged()), this, SLOT(onTextChange()));
// close this window before the main window is closed
QObject::connect(ivwwin, &InviwoMainWindow::closingMainWindow, [this]() { delete this; });
this->updateStyle();
this->resize(500, 700);
if (app_) {
app_->getSettingsByType<SystemSettings>()->pythonSyntax_.onChange(
this, &PythonEditorWidget::updateStyle);
app_->getSettingsByType<SystemSettings>()->pyFontSize_.onChange(
this, &PythonEditorWidget::updateStyle);
app_->registerFileObserver(this);
}
unsavedChanges_ = false;
if (lastFile.size() != 0) loadFile(lastFile.toLocal8Bit().constData(), false);
setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
setFloating(true);
}
TileStampsDock::TileStampsDock(TileStampManager *stampManager, QWidget *parent)
: QDockWidget(parent)
, mTileStampManager(stampManager)
, mTileStampModel(stampManager->tileStampModel())
, mNewStamp(new QAction(this))
, mAddVariation(new QAction(this))
, mDelete(new QAction(this))
{
setObjectName(QLatin1String("TileStampsDock"));
mTileStampView = new TileStampView(this);
mTileStampView->setModel(mTileStampModel);
mTileStampView->setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
mTileStampView->header()->setStretchLastSection(false);
#if QT_VERSION >= 0x050000
mTileStampView->header()->setSectionResizeMode(0, QHeaderView::Stretch);
mTileStampView->header()->setSectionResizeMode(1, QHeaderView::ResizeToContents);
#else
mTileStampView->header()->setResizeMode(0, QHeaderView::Stretch);
mTileStampView->header()->setResizeMode(1, QHeaderView::ResizeToContents);
#endif
mTileStampView->setContextMenuPolicy(Qt::CustomContextMenu);
connect(mTileStampView, SIGNAL(customContextMenuRequested(QPoint)),
SLOT(showContextMenu(QPoint)));
mNewStamp->setIcon(QIcon(QLatin1String(":images/16x16/document-new.png")));
mAddVariation->setIcon(QIcon(QLatin1String(":/images/16x16/add.png")));
mDelete->setIcon(QIcon(QLatin1String(":images/16x16/edit-delete.png")));
Utils::setThemeIcon(mNewStamp, "document-new");
Utils::setThemeIcon(mAddVariation, "add");
Utils::setThemeIcon(mDelete, "edit-delete");
connect(mNewStamp, SIGNAL(triggered()), stampManager, SLOT(newStamp()));
connect(mAddVariation, SIGNAL(triggered()), SLOT(addVariation()));
connect(mDelete, SIGNAL(triggered()), SLOT(delete_()));
mDelete->setEnabled(false);
mAddVariation->setEnabled(false);
QWidget *widget = new QWidget(this);
QVBoxLayout *layout = new QVBoxLayout(widget);
layout->setMargin(5);
QToolBar *buttonContainer = new QToolBar;
buttonContainer->setFloatable(false);
buttonContainer->setMovable(false);
buttonContainer->setIconSize(QSize(16, 16));
buttonContainer->addAction(mNewStamp);
buttonContainer->addAction(mAddVariation);
buttonContainer->addAction(mDelete);
QVBoxLayout *listAndToolBar = new QVBoxLayout;
listAndToolBar->setSpacing(0);
listAndToolBar->addWidget(mTileStampView);
listAndToolBar->addWidget(buttonContainer);
layout->addLayout(listAndToolBar);
QItemSelectionModel *selectionModel = mTileStampView->selectionModel();
connect(selectionModel, SIGNAL(currentRowChanged(QModelIndex,QModelIndex)),
this, SLOT(currentRowChanged(QModelIndex)));
setWidget(widget);
retranslateUi();
}
Window::Window(QWidget* parent):
QMainWindow(parent)
{
setObjectName("PlanetScannerWindow");
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()));
QAction* settingsAction = toolbar->addAction(QIcon(":/icons/settings.png"), "Settings");
connect(settingsAction, SIGNAL(triggered()), this, SLOT(showSettingsDialog()));
planetTreeView = new QTreeView(this);
planetTreeView->setMinimumHeight(10);
planetTreeModel = new PlanetTreeModel(planetTreeView);
planetTreeProxyModel = new PlanetTreeSortFilterProxyModel(planetTreeModel);
planetTreeProxyModel->setSourceModel(planetTreeModel);
planetTreeView->setModel(planetTreeProxyModel);
planetTreeModel->setHorizontalHeaderLabels(QStringList() << "Hostname" << "Map" << "Gametype" << "Players" << "Address");
planetTreeView->setSortingEnabled(true);
planetTreeView->sortByColumn(0, Qt::AscendingOrder);
planetTreeView->setContextMenuPolicy(Qt::CustomContextMenu);
planetTreeView->setSelectionMode(QAbstractItemView::SingleSelection);
connect(planetTreeView, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(showContextMenu(QPoint)));
QAction* connectAction = new QAction("Connect", planetTreeView);
QAction* connectAsSpectatorAction = new QAction("Connect as spectator", planetTreeView);
QAction* copyAction = new QAction("Copy", planetTreeView);
QAction* openProfileAction = new QAction("Open profile in a browser", planetTreeView);
connect(connectAction, SIGNAL(triggered()), this, SLOT(connectSelected()));
connect(connectAsSpectatorAction, SIGNAL(triggered()), this, SLOT(connectAsSpectatorSelected()));
connect(copyAction, SIGNAL(triggered()), this, SLOT(copySelected()));
connect(openProfileAction, &QAction::triggered, this, &Window::openProfileSelected);
gameContextMenu = new QMenu(planetTreeView);
planetContextMenu = new QMenu(planetTreeView);
registeredPlayerContextMenu = new QMenu(planetTreeView);
unregisteredPlayerContextMenu = new QMenu(planetTreeView);
gameContextMenu->addActions(QList<QAction*>() << connectAction << connectAsSpectatorAction << copyAction);
planetContextMenu->addActions(QList<QAction*>() << copyAction);
registeredPlayerContextMenu->addActions(QList<QAction*>() << openProfileAction << copyAction);
unregisteredPlayerContextMenu->addActions(QList<QAction*>() << copyAction);
setCentralWidget(planetTreeView);
game = new QProcess(this);
statistics = new StatisticsWebSite(this);
connect(statistics, &StatisticsWebSite::playersInfoRecieved, this, &Window::processStatisticsPlayers);
autoRefreshTimer = new QTimer(this);
connect(autoRefreshTimer, SIGNAL(timeout()), this, SLOT(refreshPlanets()));
contextMenuShown = false;
Settings& settings = Settings::getInstance();
connect(&settings, &Settings::dataChanged, this, &Window::applyChangedSettings);
settings.load();
applyChangedSettings();
::Settings::loadWindow(this);
refreshPlanets();
}
ConfigDialog::ConfigDialog(QDir _home, Zones *_zones, Context *context) :
home(_home), zones(_zones), context(context)
{
setAttribute(Qt::WA_DeleteOnClose);
#ifdef Q_OS_MAC
QToolBar *head = addToolBar(tr("Preferences"));
setMinimumSize(600,540);
setUnifiedTitleAndToolBarOnMac(true);
head->setFloatable(false);
head->setMovable(false);
#else
QToolBar *head = addToolBar(tr("Options"));
head->setMovable(false); // oops!
QFont defaultFont;
setMinimumSize(60 * defaultFont.pointSize(),580); //Change for 53 to 60 - To be decided if also Size for Q_OS_MAC need change
#endif
// center
QWidget *spacer = new QWidget(this);
spacer->setAutoFillBackground(false);
spacer->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
head->addWidget(spacer);
// icons
static QIcon generalIcon(QPixmap(":images/toolbar/GeneralPreferences.png"));
static QIcon athleteIcon(QPixmap(":/images/toolbar/user.png"));
static QIcon passwordIcon(QPixmap(":/images/toolbar/passwords.png"));
static QIcon appearanceIcon(QPixmap(":/images/toolbar/color.png"));
static QIcon dataIcon(QPixmap(":/images/toolbar/data.png"));
static QIcon metricsIcon(QPixmap(":/images/toolbar/abacus.png"));
static QIcon devicesIcon(QPixmap(":/images/devices/kickr.png"));
// Setup the signal mapping so the right config
// widget is displayed when the icon is clicked
QSignalMapper *iconMapper = new QSignalMapper(this); // maps each option
connect(iconMapper, SIGNAL(mapped(int)), this, SLOT(changePage(int)));
head->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
QAction *added;
// General settings
added = head->addAction(generalIcon, tr("General"));
connect(added, SIGNAL(triggered()), iconMapper, SLOT(map()));
iconMapper->setMapping(added, 0);
added =head->addAction(athleteIcon, tr("Athlete"));
connect(added, SIGNAL(triggered()), iconMapper, SLOT(map()));
iconMapper->setMapping(added, 1);
added =head->addAction(passwordIcon, tr("Passwords"));
connect(added, SIGNAL(triggered()), iconMapper, SLOT(map()));
iconMapper->setMapping(added, 2);
added =head->addAction(appearanceIcon, tr("Appearance"));
connect(added, SIGNAL(triggered()), iconMapper, SLOT(map()));
iconMapper->setMapping(added, 3);
added =head->addAction(dataIcon, tr("Data Fields"));
connect(added, SIGNAL(triggered()), iconMapper, SLOT(map()));
iconMapper->setMapping(added, 4);
added =head->addAction(metricsIcon, tr("Metrics"));
connect(added, SIGNAL(triggered()), iconMapper, SLOT(map()));
iconMapper->setMapping(added, 5);
added =head->addAction(devicesIcon, tr("Train Devices"));
connect(added, SIGNAL(triggered()), iconMapper, SLOT(map()));
iconMapper->setMapping(added, 6);
// more space
spacer = new QWidget(this);
spacer->setAutoFillBackground(false);
spacer->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
head->addWidget(spacer);
pagesWidget = new QStackedWidget(this);
// create those config pages
general = new GeneralConfig(_home, _zones, context);
pagesWidget->addWidget(general);
athlete = new AthleteConfig(_home, _zones, context);
pagesWidget->addWidget(athlete);
password = new PasswordConfig(_home, _zones, context);
pagesWidget->addWidget(password);
appearance = new AppearanceConfig(_home, _zones, context);
pagesWidget->addWidget(appearance);
data = new DataConfig(_home, _zones, context);
pagesWidget->addWidget(data);
metric = new MetricConfig(_home, _zones, context);
pagesWidget->addWidget(metric);
device = new DeviceConfig(_home, _zones, context);
pagesWidget->addWidget(device);
closeButton = new QPushButton(tr("Close"));
saveButton = new QPushButton(tr("Save"));
QHBoxLayout *horizontalLayout = new QHBoxLayout;
horizontalLayout->addWidget(pagesWidget, 1);
QHBoxLayout *buttonsLayout = new QHBoxLayout;
buttonsLayout->addStretch();
buttonsLayout->setSpacing(5);
buttonsLayout->addWidget(closeButton);
buttonsLayout->addWidget(saveButton);
QWidget *contents = new QWidget(this);
setCentralWidget(contents);
contents->setContentsMargins(0,0,0,0);
QVBoxLayout *mainLayout = new QVBoxLayout;
mainLayout->addLayout(horizontalLayout);
mainLayout->addStretch();
mainLayout->addLayout(buttonsLayout);
mainLayout->setSpacing(0);
contents->setLayout(mainLayout);
// We go fixed width to ensure a consistent layout for
// tabs, sub-tabs and internal widgets and lists
#ifdef Q_OS_MACX
setWindowTitle(tr("Preferences"));
#else
setWindowTitle(tr("Options"));
#endif
connect(closeButton, SIGNAL(clicked()), this, SLOT(closeClicked()));
connect(saveButton, SIGNAL(clicked()), this, SLOT(saveClicked()));
}