void FujicoinGUI::createToolBars()
{
if(walletFrame)
{
QToolBar *toolbar = addToolBar(tr("Tabs toolbar"));
appToolBar = toolbar;
toolbar->setContextMenuPolicy(Qt::PreventContextMenu);
toolbar->setMovable(false);
toolbar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
toolbar->addAction(overviewAction);
toolbar->addAction(sendCoinsAction);
toolbar->addAction(receiveCoinsAction);
toolbar->addAction(historyAction);
overviewAction->setChecked(true);
#ifdef ENABLE_WALLET
QWidget *spacer = new QWidget();
spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
toolbar->addWidget(spacer);
m_wallet_selector = new QComboBox();
connect(m_wallet_selector, SIGNAL(currentIndexChanged(int)), this, SLOT(setCurrentWalletBySelectorIndex(int)));
m_wallet_selector_label = new QLabel();
m_wallet_selector_label->setText(tr("Wallet:") + " ");
m_wallet_selector_label->setBuddy(m_wallet_selector);
m_wallet_selector_label_action = appToolBar->addWidget(m_wallet_selector_label);
m_wallet_selector_action = appToolBar->addWidget(m_wallet_selector);
m_wallet_selector_label_action->setVisible(false);
m_wallet_selector_action->setVisible(false);
#endif
}
}
void BitcoinGUI::createToolBars()
{
if(walletFrame)
{
QToolBar *toolbar = addToolBar(tr("Tabs toolbar"));
toolbar->setContextMenuPolicy(Qt::PreventContextMenu);
toolbar->setMovable(false);
toolbar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
toolbar->addAction(overviewAction);
toolbar->addAction(sendCoinsAction);
toolbar->addAction(receiveCoinsAction);
toolbar->addAction(historyAction);
overviewAction->setChecked(true);
}
}
void BitcoinGUI::createToolBars()
{
QToolBar *homeToolBar = new QToolBar(this);
QToolBar *menuToolBar = new QToolBar(this);
homeToolBar->setObjectName("homeToolBar");
menuToolBar->setObjectName("menuToolBar");
// homeToolBar->setFixedWidth(300);
// homeToolBar->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
menuToolBar->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
homeToolBar->setMovable(false);
menuToolBar->setMovable(false);
homeToolBar->setFloatable(false);
menuToolBar->setFloatable(false);
homeToolBar->setContextMenuPolicy(Qt::PreventContextMenu);
menuToolBar->setContextMenuPolicy(Qt::PreventContextMenu);
homeToolBar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
menuToolBar->setToolButtonStyle(Qt::ToolButtonTextOnly);
homeToolBar->addAction(bitstarAction);
homeToolBar->setIconSize(QSize(24, 24));
menuToolBar->layout()->setSpacing(0);
// Add a spacer, so all menuToolBar items are right aligned...
QWidget* spacer = new QWidget();
spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
menuToolBar->addWidget(spacer);
QToolButton *overviewButton = new QToolButton;
overviewButton->setDefaultAction(overviewAction);
overviewButton->setObjectName("overviewMenu");
menuToolBar->addWidget(overviewButton);
QToolButton *sendCoinsButton = new QToolButton;
sendCoinsButton->setDefaultAction(sendCoinsAction);
sendCoinsButton->setObjectName("sendcoinsMenu");
menuToolBar->addWidget(sendCoinsButton);
QToolButton *receiveCoinsButton = new QToolButton;
receiveCoinsButton->setDefaultAction(receiveCoinsAction);
receiveCoinsButton->setObjectName("receivecoinsMenu");
menuToolBar->addWidget(receiveCoinsButton);
QToolButton *historyButton = new QToolButton;
historyButton->setDefaultAction(historyAction);
historyButton->setObjectName("historyMenu");
menuToolBar->addWidget(historyButton);
QToolButton *addressBookButton = new QToolButton;
addressBookButton->setDefaultAction(addressBookAction);
addressBookButton->setObjectName("addressBookMenu");
menuToolBar->addWidget(addressBookButton);
lockToggleButton = new QToolButton;
lockToggleButton->setDefaultAction(lockWalletToggleAction);
lockToggleButton->setObjectName("lockToggleMenu");
lockToggleAction = menuToolBar->addWidget(lockToggleButton);
addToolBar(homeToolBar);
addToolBar(menuToolBar);
}
TileCollisionDock::TileCollisionDock(QWidget *parent)
: QDockWidget(parent)
, mTile(nullptr)
, mTilesetDocument(nullptr)
, mDummyMapDocument(nullptr)
, mMapScene(new MapScene(this))
, mMapView(new MapView(this, MapView::NoStaticContents))
, mToolManager(new ToolManager(this))
, mApplyingChanges(false)
, mSynchronizing(false)
, mHasSelectedObjects(false)
{
setObjectName(QLatin1String("tileCollisionDock"));
mMapView->setScene(mMapScene);
mMapView->setResizeAnchor(QGraphicsView::AnchorViewCenter);
mMapView->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
mMapView->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
CreateObjectTool *rectangleObjectsTool = new CreateRectangleObjectTool(this);
CreateObjectTool *ellipseObjectsTool = new CreateEllipseObjectTool(this);
CreateObjectTool *polygonObjectsTool = new CreatePolygonObjectTool(this);
CreateObjectTool *polylineObjectsTool = new CreatePolylineObjectTool(this);;
QToolBar *toolBar = new QToolBar(this);
toolBar->setObjectName(QLatin1String("TileCollisionDockToolBar"));
toolBar->setMovable(false);
toolBar->setFloatable(false);
toolBar->setContextMenuPolicy(Qt::ActionsContextMenu);
mToolManager = new ToolManager(this);
toolBar->addAction(mToolManager->registerTool(new ObjectSelectionTool(this)));
toolBar->addAction(mToolManager->registerTool(new EditPolygonTool(this)));
toolBar->addAction(mToolManager->registerTool(rectangleObjectsTool));
toolBar->addAction(mToolManager->registerTool(ellipseObjectsTool));
toolBar->addAction(mToolManager->registerTool(polygonObjectsTool));
toolBar->addAction(mToolManager->registerTool(polylineObjectsTool));
auto widget = new QWidget(this);
auto vertical = new QVBoxLayout(widget);
vertical->setSpacing(0);
vertical->setMargin(0);
auto horizontal = new QHBoxLayout();
horizontal->addWidget(toolBar, 1);
vertical->addLayout(horizontal);
vertical->addWidget(mMapView);
setWidget(widget);
mMapScene->setSelectedTool(mToolManager->selectedTool());
connect(mToolManager, &ToolManager::selectedToolChanged,
this, &TileCollisionDock::setSelectedTool);
connect(mToolManager, &ToolManager::statusInfoChanged,
this, &TileCollisionDock::statusInfoChanged);
QComboBox *zoomComboBox = new QComboBox;
horizontal->addWidget(zoomComboBox);
Zoomable *zoomable = mMapView->zoomable();
zoomable->setComboBox(zoomComboBox);
retranslateUi();
}
void QmitkExtWorkbenchWindowAdvisor::PostWindowCreate()
{
QmitkCommonWorkbenchWindowAdvisor::PostWindowCreate();
// very bad hack...
berry::IWorkbenchWindow::Pointer window =
this->GetWindowConfigurer()->GetWindow();
QMainWindow* mainWindow =
static_cast<QMainWindow*> (window->GetShell()->GetControl());
if (!windowIcon.empty())
{
mainWindow->setWindowIcon(QIcon(QString::fromStdString(windowIcon)));
}
mainWindow->setContextMenuPolicy(Qt::PreventContextMenu);
/*mainWindow->setStyleSheet("color: white;"
"background-color: #808080;"
"selection-color: #659EC7;"
"selection-background-color: #808080;"
" QMenuBar {"
"background-color: #808080; }");*/
// ==== Application menu ============================
QMenuBar* menuBar = mainWindow->menuBar();
menuBar->setContextMenuPolicy(Qt::PreventContextMenu);
QMenu* fileMenu = menuBar->addMenu("&File");
fileMenu->setObjectName("FileMenu");
QAction* fileOpenAction = new QmitkExtFileOpenAction(QIcon(":/org.mitk.gui.qt.ext/Load_48.png"), window);
fileMenu->addAction(fileOpenAction);
fileSaveProjectAction = new QmitkExtFileSaveProjectAction(window);
fileSaveProjectAction->setIcon(QIcon(":/org.mitk.gui.qt.ext/Save_48.png"));
fileMenu->addAction(fileSaveProjectAction);
closeProjectAction = new QmitkCloseProjectAction(window);
closeProjectAction->setIcon(QIcon(":/org.mitk.gui.qt.ext/Remove_48.png"));
fileMenu->addAction(closeProjectAction);
fileMenu->addSeparator();
QAction* fileExitAction = new QmitkFileExitAction(window);
fileExitAction->setObjectName("QmitkFileExitAction");
fileMenu->addAction(fileExitAction);
berry::IViewRegistry* viewRegistry =
berry::PlatformUI::GetWorkbench()->GetViewRegistry();
const std::vector<berry::IViewDescriptor::Pointer>& viewDescriptors =
viewRegistry->GetViews();
// another bad hack to get an edit/undo menu...
QMenu* editMenu = menuBar->addMenu("&Edit");
undoAction = editMenu->addAction(QIcon(":/org.mitk.gui.qt.ext/Undo_48.png"),
"&Undo",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onUndo()),
QKeySequence("CTRL+Z"));
undoAction->setToolTip("Undo the last action (not supported by all modules)");
redoAction = editMenu->addAction(QIcon(":/org.mitk.gui.qt.ext/Redo_48.png")
, "&Redo",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onRedo()),
QKeySequence("CTRL+Y"));
redoAction->setToolTip("execute the last action that was undone again (not supported by all modules)");
imageNavigatorAction = new QAction(QIcon(":/org.mitk.gui.qt.ext/Slider.png"), "&Image Navigator", NULL);
bool imageNavigatorViewFound = window->GetWorkbench()->GetViewRegistry()->Find("org.mitk.views.imagenavigator");
if (imageNavigatorViewFound)
{
QObject::connect(imageNavigatorAction, SIGNAL(triggered(bool)), QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onImageNavigator()));
imageNavigatorAction->setCheckable(true);
// add part listener for image navigator
imageNavigatorPartListener = new PartListenerForImageNavigator(imageNavigatorAction);
window->GetPartService()->AddPartListener(imageNavigatorPartListener);
berry::IViewPart::Pointer imageNavigatorView =
window->GetActivePage()->FindView("org.mitk.views.imagenavigator");
imageNavigatorAction->setChecked(false);
if (imageNavigatorView)
{
bool isImageNavigatorVisible = window->GetActivePage()->IsPartVisible(imageNavigatorView);
if (isImageNavigatorVisible)
imageNavigatorAction->setChecked(true);
}
imageNavigatorAction->setToolTip("Open image navigator for navigating through image");
}
// toolbar for showing file open, undo, redo and other main actions
QToolBar* mainActionsToolBar = new QToolBar;
mainActionsToolBar->setContextMenuPolicy(Qt::PreventContextMenu);
#ifdef __APPLE__
mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextUnderIcon );
#else
mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextBesideIcon );
#endif
mainActionsToolBar->addAction(fileOpenAction);
mainActionsToolBar->addAction(fileSaveProjectAction);
mainActionsToolBar->addAction(closeProjectAction);
mainActionsToolBar->addAction(undoAction);
mainActionsToolBar->addAction(redoAction);
if (imageNavigatorViewFound)
{
mainActionsToolBar->addAction(imageNavigatorAction);
}
mainWindow->addToolBar(mainActionsToolBar);
#ifdef __APPLE__
mainWindow->setUnifiedTitleAndToolBarOnMac(true);
#endif
// ==== Window Menu ==========================
QMenu* windowMenu = menuBar->addMenu("Window");
if (showNewWindowMenuItem)
{
windowMenu->addAction("&New Window", QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onNewWindow()));
windowMenu->addSeparator();
}
QMenu* perspMenu = windowMenu->addMenu("&Open Perspective");
QMenu* viewMenu;
if (showViewMenuItem)
{
viewMenu = windowMenu->addMenu("Show &View");
viewMenu->setObjectName("Show View");
}
windowMenu->addSeparator();
resetPerspAction = windowMenu->addAction("&Reset Perspective",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onResetPerspective()));
if(showClosePerspectiveMenuItem)
closePerspAction = windowMenu->addAction("&Close Perspective", QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onClosePerspective()));
windowMenu->addSeparator();
windowMenu->addAction("&Preferences...",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onEditPreferences()),
QKeySequence("CTRL+P"));
// fill perspective menu
berry::IPerspectiveRegistry* perspRegistry =
window->GetWorkbench()->GetPerspectiveRegistry();
QActionGroup* perspGroup = new QActionGroup(menuBar);
std::vector<berry::IPerspectiveDescriptor::Pointer> perspectives(
perspRegistry->GetPerspectives());
bool skip = false;
for (std::vector<berry::IPerspectiveDescriptor::Pointer>::iterator perspIt =
perspectives.begin(); perspIt != perspectives.end(); ++perspIt)
{
// if perspectiveExcludeList is set, it contains the id-strings of perspectives, which
// should not appear as an menu-entry in the perspective menu
if (perspectiveExcludeList.size() > 0)
{
for (unsigned int i=0; i<perspectiveExcludeList.size(); i++)
{
if (perspectiveExcludeList.at(i) == (*perspIt)->GetId())
{
skip = true;
break;
}
}
if (skip)
{
skip = false;
continue;
}
}
QAction* perspAction = new berry::QtOpenPerspectiveAction(window,
*perspIt, perspGroup);
mapPerspIdToAction.insert(std::make_pair((*perspIt)->GetId(), perspAction));
}
perspMenu->addActions(perspGroup->actions());
// sort elements (converting vector to map...)
std::vector<berry::IViewDescriptor::Pointer>::const_iterator iter;
std::map<std::string, berry::IViewDescriptor::Pointer> VDMap;
skip = false;
for (iter = viewDescriptors.begin(); iter != viewDescriptors.end(); ++iter)
{
// if viewExcludeList is set, it contains the id-strings of view, which
// should not appear as an menu-entry in the menu
if (viewExcludeList.size() > 0)
{
for (unsigned int i=0; i<viewExcludeList.size(); i++)
{
if (viewExcludeList.at(i) == (*iter)->GetId())
{
skip = true;
break;
}
}
if (skip)
{
skip = false;
continue;
}
}
if ((*iter)->GetId() == "org.blueberry.ui.internal.introview")
continue;
if ((*iter)->GetId() == "org.mitk.views.imagenavigator")
continue;
std::pair<std::string, berry::IViewDescriptor::Pointer> p(
(*iter)->GetLabel(), (*iter));
VDMap.insert(p);
}
// ==================================================
// ==== Perspective Toolbar ==================================
QToolBar* qPerspectiveToolbar = new QToolBar;
if (showPerspectiveToolbar)
{
qPerspectiveToolbar->addActions(perspGroup->actions());
mainWindow->addToolBar(qPerspectiveToolbar);
}
else
delete qPerspectiveToolbar;
// ==== View Toolbar ==================================
QToolBar* qToolbar = new QToolBar;
std::map<std::string, berry::IViewDescriptor::Pointer>::const_iterator
MapIter;
for (MapIter = VDMap.begin(); MapIter != VDMap.end(); ++MapIter)
{
berry::QtShowViewAction* viewAction = new berry::QtShowViewAction(window,
(*MapIter).second);
viewActions.push_back(viewAction);
if(showViewMenuItem)
viewMenu->addAction(viewAction);
if (showViewToolbar)
{
qToolbar->addAction(viewAction);
}
}
if (showViewToolbar)
{
mainWindow->addToolBar(qToolbar);
}
else
delete qToolbar;
QSettings settings(GetQSettingsFile(), QSettings::IniFormat);
mainWindow->restoreState(settings.value("ToolbarPosition").toByteArray());
// ====================================================
// ===== Help menu ====================================
QMenu* helpMenu = menuBar->addMenu("Help");
helpMenu->addAction("&Welcome",this, SLOT(onIntro()));
helpMenu->addAction("&Help Contents",this, SLOT(onHelp()), QKeySequence("F1"));
helpMenu->addAction("&About",this, SLOT(onAbout()));
// =====================================================
QStatusBar* qStatusBar = new QStatusBar();
//creating a QmitkStatusBar for Output on the QStatusBar and connecting it with the MainStatusBar
QmitkStatusBar *statusBar = new QmitkStatusBar(qStatusBar);
//disabling the SizeGrip in the lower right corner
statusBar->SetSizeGripEnabled(false);
QmitkProgressBar *progBar = new QmitkProgressBar();
qStatusBar->addPermanentWidget(progBar, 0);
progBar->hide();
// progBar->AddStepsToDo(2);
// progBar->Progress(1);
mainWindow->setStatusBar(qStatusBar);
QmitkMemoryUsageIndicatorView* memoryIndicator =
new QmitkMemoryUsageIndicatorView();
qStatusBar->addPermanentWidget(memoryIndicator, 0);
}
void 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);
}
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();
}
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();
}
