EventsUpdater::EventsUpdater(DVRServerRepository *serverRepository, QObject *parent) :
QObject(parent), m_serverRepository(serverRepository), m_limit(-1)
{
Q_ASSERT(m_serverRepository);
connect(m_serverRepository, SIGNAL(serverAdded(DVRServer*)), SLOT(serverAdded(DVRServer*)));
connect(&m_updateTimer, SIGNAL(timeout()), SLOT(updateServers()));
foreach (DVRServer *s, m_serverRepository->servers())
serverAdded(s);
}
EventSourcesModel::EventSourcesModel(DVRServerRepository *serverRepository, QObject *parent)
: QAbstractItemModel(parent)
{
Q_ASSERT(serverRepository);
connect(serverRepository, SIGNAL(serverAdded(DVRServer*)), this, SLOT(serverAdded(DVRServer*)));
connect(serverRepository, SIGNAL(serverRemoved(DVRServer*)), this, SLOT(serverRemoved(DVRServer*)));
QList<DVRServer*> sl = serverRepository->servers();
servers.reserve(sl.size());
blockSignals(true);
foreach (DVRServer *s, sl)
serverAdded(s);
blockSignals(false);
}
DVRServer * DVRServerRepository::createServer(const QString& name)
{
int id = ++m_maxServerId;
DVRServer *server = new DVRServer(id, this);
server->configuration().setDisplayName(name);
emit serverAboutToBeAdded(server);
m_servers.append(server);
connect(server, SIGNAL(serverRemoved(DVRServer*)), this, SLOT(onServerRemoved(DVRServer*)));
connect(server, SIGNAL(statusAlertMessageChanged(QString)), this, SIGNAL(serverAlertsChanged()));
emit serverAdded(server);
return server;
}
EventsModel::EventsModel(DVRServerRepository *serverRepository, QObject *parent)
: QAbstractItemModel(parent), m_serverRepository(serverRepository), serverEventsLimit(-1), incompleteEventsFirst(false)
{
Q_ASSERT(m_serverRepository);
connect(m_serverRepository, SIGNAL(serverAdded(DVRServer*)), SLOT(serverAdded(DVRServer*)));
connect(m_serverRepository, SIGNAL(serverRemoved(DVRServer*)), SLOT(clearServerEvents(DVRServer*)));
connect(&updateTimer, SIGNAL(timeout()), SLOT(updateServers()));
//createTestData();
sortColumn = DateColumn;
sortOrder = Qt::DescendingOrder;
applyFilters();
foreach (DVRServer *s, m_serverRepository->servers())
serverAdded(s);
}
DVRServersModel::DVRServersModel(DVRServerRepository *serverRepository, bool onlyName, QObject *parent)
: QAbstractItemModel(parent), m_onlyName(onlyName), m_offlineDisabled(false)
{
Q_ASSERT(serverRepository);
m_statusIcon = QIcon(QLatin1String(":/icons/status.png"));
m_statusIcon.addFile(QLatin1String(":/icons/status-offline.png"), QSize(), QIcon::Disabled, QIcon::Off);
m_statusErrorIcon = QIcon(QLatin1String(":/icons/status-error.png"));
m_statusErrorIcon.addPixmap(m_statusErrorIcon.pixmap(16), QIcon::Disabled);
m_statusAlertIcon = QIcon(QLatin1String(":/icons/status-alert.png"));
connect(serverRepository, SIGNAL(serverAdded(DVRServer*)), SLOT(serverAdded(DVRServer*)));
connect(serverRepository, SIGNAL(serverRemoved(DVRServer*)), SLOT(serverRemoved(DVRServer*)));
const QList<DVRServer *> &servers = serverRepository->servers();
m_items.reserve(servers.size());
blockSignals(true);
for (int i = 0; i < servers.size(); ++i)
serverAdded(servers[i]);
blockSignals(false);
}
ServerChoice::ServerChoice(TeamHolder* team) :
ui(new Ui::ServerChoice), wasConnected(false), team(team)
{
ui->setupUi(this);
ui->announcement->hide();
ServerChoiceModel *model = new ServerChoiceModel();
model->setParent(ui->serverList);
filter = new QSortFilterProxyModel(ui->serverList);
filter->setSourceModel(model);
filter->setSortRole(ServerChoiceModel::SortRole);
ui->serverList->setModel(filter);
connect(ui->description, SIGNAL(anchorClicked(QUrl)), SLOT(anchorClicked(QUrl)));
QSettings settings;
registry_connection = new Analyzer(true);
connect(registry_connection, SIGNAL(connected()), SLOT(connected()));
registry_connection->connectTo(
settings.value("ServerChoice/RegistryServer", "registry.pokemon-online.eu").toString(),
settings.value("ServerChoice/RegistryPort", 5090).toUInt()
);
registry_connection->setParent(this);
ui->switchPort->setIcon(QApplication::style()->standardIcon(QStyle::SP_BrowserReload));
connect(registry_connection, SIGNAL(connectionError(int,QString)), SLOT(connectionError(int , QString)));
connect(registry_connection, SIGNAL(regAnnouncementReceived(QString)), ui->announcement, SLOT(setText(QString)));
connect(registry_connection, SIGNAL(regAnnouncementReceived(QString)), ui->announcement, SLOT(show()));
connect(registry_connection, SIGNAL(serverReceived(ServerInfo)), model, SLOT(addServer(ServerInfo)));
connect(this, SIGNAL(clearList()), model, SLOT(clear()));
connect(registry_connection, SIGNAL(serverReceived(ServerInfo)), SLOT(serverAdded()));
//TO-DO: Make the item 0 un-resizable and unselectable - Latios
ui->serverList->setColumnWidth(0, settings.value("ServerChoice/PasswordProtectedWidth", 26).toInt());
ui->serverList->setColumnWidth(1, settings.value("ServerChoice/ServerNameWidth", 152).toInt());
if (settings.contains("ServerChoice/PlayersInfoWidth")) {
ui->serverList->setColumnWidth(2, settings.value("ServerChoice/PlayersInfoWidth").toInt());
}
ui->serverList->horizontalHeader()->setStretchLastSection(true);
connect(ui->serverList, SIGNAL(activated(QModelIndex)), SLOT(regServerChosen(QModelIndex)));
connect(ui->serverList, SIGNAL(currentCellChanged(QModelIndex)), SLOT(showDetails(QModelIndex)));
ui->nameEdit->setText(team->name());
ui->advServerEdit->addItem(settings.value("ServerChoice/DefaultServer").toString());
connect(ui->nameEdit, SIGNAL(returnPressed()), SLOT(advServerChosen()));
connect(ui->advServerEdit->lineEdit(), SIGNAL(returnPressed()), SLOT(advServerChosen()));
QCompleter *completer = new QCompleter(ui->advServerEdit);
completer->setCaseSensitivity(Qt::CaseInsensitive);
QStringList res = settings.value("ServerChoice/SavedServers").toStringList();
foreach (QString r, res) {
if (r.contains("-")) {
savedServers.push_back(QStringList() << r.section("-", -1).trimmed() << r.section("-", 0, -2).trimmed());
} else {
savedServers.push_back(QStringList() << r << "");
}
}
QStringListModel *m = new QStringListModel(res, completer);
completer->setModel(m);
ui->advServerEdit->setCompleter(completer);
ui->advServerEdit->setModel(m);
connect(ui->teambuilder, SIGNAL(clicked()), SIGNAL(teambuilder()));
connect(ui->advancedConnection, SIGNAL(clicked()), SLOT(advServerChosen()));
QTimer *t = new QTimer(this);
t->singleShot(5000, this, SLOT(timeout()));
#if QT_VERSION >= QT_VERSION_CHECK(4,8,0)
ui->serverList->sortByColumn(ServerChoiceModel::Players, Qt::SortOrder(filter->headerData(ServerChoiceModel::Players, Qt::Horizontal, Qt::InitialSortOrderRole).toInt()));
#else
ui->serverList->sortByColumn(ServerChoiceModel::Players, Qt::DescendingOrder);
#endif
}
