void MainWindowPlugin::onOptionsChanged(const OptionsNode &ANode)
{
if (ANode.path() == OPV_MAINWINDOW_STAYONTOP)
{
#ifdef Q_WS_MAC
setWindowOntop(FMainWindow, ANode.value().toBool());
#else
QWidget *widget = mainWindowTopWidget();
bool show = widget->isVisible();
if (ANode.value().toBool())
widget->setWindowFlags(widget->windowFlags() | Qt::WindowStaysOnTopHint);
else
widget->setWindowFlags(widget->windowFlags() & ~Qt::WindowStaysOnTopHint);
if (show)
showMainWindow();
#endif
}
else if (ANode.path() == OPV_MAINWINDOW_MINIMIZETOTRAY_W7)
{
if (isMinimizeToTray())
{
Options::node(OPV_MAINWINDOW_MINIMIZENOTIFY_SHOWCOUNT).setValue(MINIMIZENOTIFY_MAX_SHOWCOUNT+1);
}
if (FMainWindowBorder)
{
FMainWindowBorder->setMinimizeOnClose(!isMinimizeToTray());
}
if (!isMinimizeToTray() && !mainWindowTopWidget()->isVisible())
{
hideMainWindow();
}
}
}
void TuneListenerFile::onOptionsChanged(const OptionsNode &ANode)
{
if (ANode.path() == OPV_TUNE_LISTENER_FILE_NAME)
FFileName=ANode.value().toString();
else if (ANode.path() == OPV_TUNE_LISTENER_FILE_FORMAT)
FFileFormat=(FileFormat)ANode.value().toInt();
}
void MainWindowPlugin::onOptionsChanged(const OptionsNode &ANode)
{
QWidget * widget = FMainWindowBorder ? (QWidget*)FMainWindowBorder : (QWidget*)FMainWindow;
if (ANode.path() == OPV_MAINWINDOW_STAYONTOP)
{
bool show = widget->isVisible();
if (ANode.value().toBool())
widget->setWindowFlags(widget->windowFlags() | Qt::WindowStaysOnTopHint);
else
widget->setWindowFlags(widget->windowFlags() & ~Qt::WindowStaysOnTopHint);
if (show)
showMainWindow();
}
#ifdef Q_OS_WIN
else if (ANode.path() == OPV_MAINWINDOW_MINIMIZETOTRAY_W7)
{
if (QSysInfo::windowsVersion() == QSysInfo::WV_WINDOWS7)
{
bool minimize = ANode.value().toBool();
FMainWindowBorder->setMinimizeOnClose(!minimize);
FMainWindowBorder->setShowInTaskBar(!minimize);
if (minimize)
disconnect(FMainWindowBorder ? (QObject*)FMainWindowBorder : (QObject*)FMainWindow, SIGNAL(closed()), this, SLOT(onMainWindowClosed()));
else
connect(FMainWindowBorder ? (QObject*)FMainWindowBorder : (QObject*)FMainWindow, SIGNAL(closed()), SLOT(onMainWindowClosed()));
}
else
FMainWindowBorder->setShowInTaskBar(false);
}
#endif
}
void MapSourceYandex::onOptionsChanged(const OptionsNode &ANode)
{
if (ANode.path() == OPV_MAP_SOURCE_YANDEX_VERSION_SATELLITE)
setVersionSattellite(ANode.value().toString());
else if (ANode.path() == OPV_MAP_SOURCE_YANDEX_VERSION_SCHEME)
setVersionScheme(ANode.value().toString());
}
void UserTuneHandler::onOptionsChanged(const OptionsNode &ANode)
{
if (ANode.path() == OPV_USERTUNE_SHOW_ROSTER_LABEL) {
FTuneLabelVisible = ANode.value().toBool();
if (FTuneLabelVisible) {
foreach (const Jid streamJid, FRostersModel->streams()) {
updateDataHolder(streamJid, Jid::null);
}
}
} else if (ANode.path() == OPV_USERTUNE_TAG_FORMAT) {
void EditWidget::onOptionsChanged(const OptionsNode &ANode)
{
if (ANode.path() == OPV_MESSAGES_EDITORAUTORESIZE)
{
setAutoResize(ANode.value().toBool());
}
else if (ANode.path() == OPV_MESSAGES_EDITORMINIMUMLINES)
{
setMinimumHeightLines(ANode.value().toInt());
}
}
QMultiMap<int, IOptionsDialogWidget *> AccountManager::optionsDialogWidgets(const QString &ANodeId, QWidget *AParent)
{
QMultiMap<int, IOptionsDialogWidget *> widgets;
if (ANodeId.startsWith(OPN_ACCOUNTS))
{
QStringList nodeTree = ANodeId.split(".",QString::SkipEmptyParts);
if (ANodeId == OPN_ACCOUNTS)
{
widgets.insertMulti(OHO_ACCOUNTS_ACCOUNTS, FOptionsManager->newOptionsDialogHeader(tr("Accounts"),AParent));
// *** <<< eyeCU <<< ***
int flags = 0;
if (Options::node(OPV_COMMON_ADVANCED).value().toBool())
flags|=AccountsOptionsWidget::Advanced;
if (!FWizardAccount)
flags|=AccountsOptionsWidget::NoWizrd;
AccountsOptionsWidget *widget = new AccountsOptionsWidget(this, flags, AParent);
widgets.insertMulti(OWO_ACCOUNTS_ACCOUNTS, widget);
connect(widget, SIGNAL(addAccountLinkActivated(const QString &)), SLOT(onAddAccountLinkActivated(const QString &)));
connect(this, SIGNAL(showAccountSettings(QUuid)), widget, SLOT(onSettingsButtonClicked(QUuid)));
// *** >>> eyeCU >>> ***
widgets.insertMulti(OHO_ACCOUNTS_COMMON, FOptionsManager->newOptionsDialogHeader(tr("Common account settings"),AParent));
QComboBox *resourceCombox = newResourceComboBox(QUuid(),AParent);
widgets.insertMulti(OWO_ACCOUNTS_DEFAULTRESOURCE,FOptionsManager->newOptionsDialogWidget(Options::node(OPV_ACCOUNT_DEFAULTRESOURCE),tr("Default resource:"),resourceCombox,AParent));
}
else if (nodeTree.count()==3 && nodeTree.at(0)==OPN_ACCOUNTS && nodeTree.at(2)=="Parameters")
{
OptionsNode options = Options::node(OPV_ACCOUNT_ITEM,nodeTree.at(1));
widgets.insertMulti(OHO_ACCOUNTS_PARAMS_ACCOUNT,FOptionsManager->newOptionsDialogHeader(tr("Account"),AParent));
widgets.insertMulti(OWO_ACCOUNTS_PARAMS_NAME,FOptionsManager->newOptionsDialogWidget(options.node("name"),tr("Name:"),AParent));
// *** <<< eyeCU <<< ***
if (!FWizardAccount || Options::node(OPV_COMMON_ADVANCED).value().toBool())
widgets.insertMulti(OWO_ACCOUNTS_PARAMS_STREAM_JID,FOptionsManager->newOptionsDialogWidget(options.node("streamJid"),tr("Jabber ID:"),AParent));
// *** >>> eyeCU >>> ***
widgets.insertMulti(OWO_ACCOUNTS_PARAMS_PASSWORD,FOptionsManager->newOptionsDialogWidget(options.node("password"),tr("Password:"******"resource"),tr("Resource:"),resourceCombox,AParent));
}
else if (nodeTree.count()==3 && nodeTree.at(0)==OPN_ACCOUNTS && nodeTree.at(2)=="Additional")
{
OptionsNode options = Options::node(OPV_ACCOUNT_ITEM,nodeTree.at(1));
widgets.insertMulti(OHO_ACCOUNTS_ADDITIONAL_SETTINGS, FOptionsManager->newOptionsDialogHeader(tr("Additional settings"),AParent));
widgets.insertMulti(OWO_ACCOUNTS_ADDITIONAL_REQUIRESECURE,FOptionsManager->newOptionsDialogWidget(options.node("require-encryption"),tr("Require secure connection to server"),AParent));
}
}
return widgets;
}
void InBandStreams::loadMethodSettings(IDataStreamSocket *ASocket, const OptionsNode &ANode)
{
IInBandStream *stream = qobject_cast<IInBandStream *>(ASocket->instance());
if (stream)
{
stream->setMaximumBlockSize(ANode.value("max-block-size").toInt());
stream->setBlockSize(ANode.value("block-size").toInt());
stream->setDataStanzaType(ANode.value("stanza-type").toInt());
}
else
{
REPORT_ERROR("Failed to load inband stream settings: Invalid socket");
}
}
void SocksStreams::loadMethodSettings(IDataStreamSocket *ASocket, const OptionsNode &ANode)
{
ISocksStream *stream = qobject_cast<ISocksStream *>(ASocket->instance());
if (stream)
{
QStringList proxyItems = ANode.value("stream-proxy-list").toStringList();
if (ANode.value("use-account-stream-proxy").toBool())
{
QString streamProxy = accountStreamProxy(stream->streamJid());
if (!streamProxy.isEmpty() && !proxyItems.contains(streamProxy))
proxyItems.prepend(streamProxy);
}
stream->setProxyList(proxyItems);
stream->setConnectTimeout(ANode.value("connect-timeout").toInt());
stream->setDirectConnectionsDisabled(ANode.value("disable-direct-connections").toBool());
stream->setForwardAddress(ANode.value("forward-host").toString(), ANode.value("forward-port").toInt());
if (ANode.value("use-account-network-proxy").toBool())
stream->setNetworkProxy(accountNetworkProxy(stream->streamJid()));
else if (FConnectionManager)
stream->setNetworkProxy(FConnectionManager->proxyById(ANode.value("network-proxy").toString()).proxy);
}
else
{
REPORT_ERROR("Failed to load socks stream settings: Invalid socket");
}
}
IConnectionProxy ConnectionManager::proxyById(const QUuid &AProxyId) const
{
static const IConnectionProxy noProxy = {" "+tr("<No Proxy>"), QNetworkProxy(QNetworkProxy::NoProxy) };
if (!AProxyId.isNull())
{
OptionsNode pnode;
QList<QUuid> plist = proxyList();
if (plist.contains(AProxyId))
pnode = Options::node(OPV_PROXY_ITEM,AProxyId.toString());
else if (plist.contains(defaultProxy()))
pnode = Options::node(OPV_PROXY_ITEM,defaultProxy().toString());
if (!pnode.isNull())
{
IConnectionProxy proxy;
proxy.name = pnode.value("name").toString();
proxy.proxy.setType((QNetworkProxy::ProxyType)pnode.value("type").toInt());
proxy.proxy.setHostName(pnode.value("host").toString());
proxy.proxy.setPort(pnode.value("port").toInt());
proxy.proxy.setUser(pnode.value("user").toString());
proxy.proxy.setPassword(Options::decrypt(pnode.value("pass").toByteArray()).toString());
return proxy;
}
}
return noProxy;
}
void PositioningMethodSerialPortOptions::apply()
{
QString name = ui->cmbPortName->currentText();
Options::node(OPV_POSITIONING_METHOD_SERIALPORT_NAME).setValue(name);
Options::node(OPV_POSITIONING_METHOD_SERIALPORT_BUFFERSIZE).setValue(ui->spbBufferSize->value());
Options::node(OPV_POSITIONING_METHOD_SERIALPORT_TIMEOUT).setValue(ui->spbTimeout->value());
Options::node(OPV_POSITIONING_METHOD_SERIALPORT_TIMETRESHOLD).setValue(ui->spbTimeTreshold->value());
Options::node(OPV_POSITIONING_METHOD_SERIALPORT_DISTANCETRESHOLD).setValue(ui->spbDistanceTreshold->value());
OptionsNode node = Options::node(OPV_POSITIONING_METHOD_SERIALPORT, name);
node.setValue(ui->cmbBaudRate->itemData(ui->cmbBaudRate->currentIndex()).toLongLong(), "baud-rate");
node.setValue(ui->cmbDataBits->itemData(ui->cmbDataBits->currentIndex()).toInt(), "data-bits");
node.setValue(ui->cmbStopBits->itemData(ui->cmbStopBits->currentIndex()).toInt(), "stop-bits");
node.setValue(ui->cmbParity->itemData(ui->cmbParity->currentIndex()).toInt(), "parity");
node.setValue(ui->cmbFlowControl->itemData(ui->cmbFlowControl->currentIndex()).toInt(), "flow-control");
emit childApply();
}
void ConsoleWidget::saveContext(const QUuid &AContextId)
{
OptionsNode node = Options::node(OPV_CONSOLE_CONTEXT_ITEM, AContextId.toString());
node.setValue(ui.cmbStreamJid->currentIndex()>0 ? ui.cmbStreamJid->itemData(ui.cmbStreamJid->currentIndex()).toString() : QString::null,"streamjid");
QStringList conditions;
for (int i=0; i<ui.ltwConditions->count(); i++)
conditions.append(ui.ltwConditions->item(i)->text());
node.setValue(conditions,"conditions");
node.setValue(ui.chbWordWrap->isChecked(),"word-wrap");
node.setValue(ui.chbHilightXML->checkState(),"highlight-xml");
Options::setFileValue(saveGeometry(),"console.context.window-geometry",AContextId.toString());
Options::setFileValue(ui.sptHSplitter->saveState(),"console.context.hsplitter-state",AContextId.toString());
Options::setFileValue(ui.sptVSplitter->saveState(),"console.context.vsplitter-state",AContextId.toString());
}
void MapSourceGoogle::onOptionsChanged(const OptionsNode &ANode)
{
if (ANode.path() == OPV_MAP_SOURCE_GOOGLE_VERSION_MAP)
setVersionMap(ANode.value().toInt());
else if (ANode.path() == OPV_MAP_SOURCE_GOOGLE_VERSION_SATELLITE)
setVersionSatellite(ANode.value().toInt());
else if (ANode.path() == OPV_MAP_SOURCE_GOOGLE_VERSION_TERRAIN_R)
setVersionTerrainR(ANode.value().toInt());
else if (ANode.path() == OPV_MAP_SOURCE_GOOGLE_VERSION_TERRAIN_T)
setVersionTerrainT(ANode.value().toInt());
}
PortSettings PositioningMethodSerialPortOptions::getPortSettings(const QString &APortName)
{
PortSettings portSettings;
OptionsNode node;
if (Options::hasNode(OPV_POSITIONING_METHOD_SERIALPORT, APortName))
node = Options::node(OPV_POSITIONING_METHOD_SERIALPORT, APortName);
else
{
QSerialPort *serialPort = new QSerialPort(APortName);
if (serialPort->open(QIODevice::ReadOnly))
{
portSettings.FBaudRate = serialPort->baudRate();
portSettings.FDataBits = serialPort->dataBits();
portSettings.FStopBits = serialPort->stopBits();
portSettings.FParity = serialPort->parity();
portSettings.FFlowControl = serialPort->flowControl();
serialPort->close();
}
else // Failed to open the port
node = Options::node(OPV_POSITIONING_METHOD_SERIALPORT, APortName);
serialPort->deleteLater();
}
if (!node.isNull())
{
portSettings.FBaudRate = node.value("baud-rate").toLongLong();
portSettings.FDataBits = (QSerialPort::DataBits)node.value("data-bits").toInt();
portSettings.FStopBits = (QSerialPort::StopBits)node.value("stop-bits").toInt();
portSettings.FParity = (QSerialPort::Parity)node.value("parity").toInt();
portSettings.FFlowControl = (QSerialPort::FlowControl)node.value("flow-control").toInt();
}
return portSettings;
}
void ConnectionOptionsWidget::apply(OptionsNode ANode)
{
OptionsNode node = !ANode.isNull() ? ANode : FOptions;
node.setValue(ui.lneHost->text(),"host");
node.setValue(ui.spbPort->value(),"port");
node.setValue(ui.chbUseLegacySSL->isChecked(),"use-legacy-ssl");
node.setValue(ui.cmbSslProtocol->itemData(ui.cmbSslProtocol->currentIndex()),"ssl-protocol");
node.setValue(ui.cmbCertCheckMode->itemData(ui.cmbCertCheckMode->currentIndex()),"cert-verify-mode");
if (FProxySettings)
FManager->saveProxySettings(FProxySettings, node.node("proxy"));
emit childApply();
}
void EditWidget::onOptionsChanged(const OptionsNode &ANode)
{
if (ANode.path() == OPV_MESSAGES_EDITORAUTORESIZE)
{
setAutoResize(ANode.value().toBool());
}
else if (ANode.path() == OPV_MESSAGES_EDITORMINIMUMLINES)
{
setMinimumLines(ANode.value().toInt());
}
else if (ANode.path() == OPV_MESSAGES_EDITORMAXIMUMLINES)
{
setMaximumLines(ANode.value().toInt());
}
else if (ANode.path() == OPV_MESSAGES_EDITORSENDKEY)
{
QKeySequence key = ANode.value().value<QKeySequence>();
if (key.isEmpty())
key = Options::defaultValue(OPV_MESSAGES_EDITORSENDKEY).value<QKeySequence>();
setSendKey(key);
;
}
}
void ConnectionManager::setProxy(const QUuid &AProxyId, const IConnectionProxy &AProxy)
{
if (!AProxyId.isNull() && AProxyId!=APPLICATION_PROXY_REF_UUID)
{
LOG_INFO(QString("Proxy added or updated, id=%1").arg(AProxyId.toString()));
OptionsNode pnode = Options::node(OPV_PROXY_ITEM,AProxyId.toString());
pnode.setValue(AProxy.name,"name");
pnode.setValue(AProxy.proxy.type(),"type");
pnode.setValue(AProxy.proxy.hostName(),"host");
pnode.setValue(AProxy.proxy.port(),"port");
pnode.setValue(AProxy.proxy.user(),"user");
pnode.setValue(Options::encrypt(AProxy.proxy.password()),"pass");
emit proxyChanged(AProxyId, AProxy);
}
else
{
LOG_ERROR(QString("Failed to add or change proxy, id=%1: Invalid proxy Id").arg(AProxyId.toString()));
}
}
void ConsoleWidget::loadContext(const QUuid &AContextId)
{
OptionsNode node = Options::node(OPV_CONSOLE_CONTEXT_ITEM, AContextId.toString());
QString streamJid = node.value("streamjid").toString();
if (streamJid.isEmpty())
ui.cmbStreamJid->setCurrentIndex(0);
else
ui.cmbStreamJid->setCurrentIndex(ui.cmbStreamJid->findData(streamJid));
ui.ltwConditions->clear();
ui.ltwConditions->addItems(node.value("conditions").toStringList());
ui.chbWordWrap->setChecked(node.value("word-wrap").toBool());
ui.chbHilightXML->setCheckState((Qt::CheckState)node.value("highlight-xml").toInt());
onWordWrapButtonToggled(ui.chbWordWrap->isChecked());
if (!restoreGeometry(Options::fileValue("console.context.window-geometry",AContextId.toString()).toByteArray()))
setGeometry(WidgetManager::alignGeometry(QSize(640,640),this));
ui.sptHSplitter->restoreState(Options::fileValue("console.context.hsplitter-state",AContextId.toString()).toByteArray());
ui.sptVSplitter->restoreState(Options::fileValue("console.context.vsplitter-state",AContextId.toString()).toByteArray());
setWindowTitle(tr("XML Console - %1").arg(node.value("name").toString()));
}
IMessageStyleOptions SimpleMessageStyleEngine::styleOptions(const OptionsNode &AEngineNode, const QString &AStyleId) const
{
IMessageStyleOptions options;
if (AStyleId.isEmpty() || FStylePaths.contains(AStyleId))
{
QString styleId = AStyleId.isEmpty() ? AEngineNode.value("style-id").toString() : AStyleId;
// Select default style
if (!FStylePaths.isEmpty() && !FStylePaths.contains(styleId))
{
int mtype = AEngineNode.parentNSpaces().value(1).toInt();
switch (mtype)
{
case Message::Normal:
case Message::Headline:
case Message::Error:
styleId = "Message Style";
AEngineNode.node("style",styleId).setValue(QString("Default"),"variant");
break;
default:
styleId = "Chat Style";
AEngineNode.node("style",styleId).setValue(QString("Default"),"variant");
}
styleId = !FStylePaths.contains(styleId) ? FStylePaths.keys().first() : styleId;
}
if (FStylePaths.contains(styleId))
{
options.engineId = engineId();
options.styleId = styleId;
OptionsNode styleNode = AEngineNode.node("style",styleId);
options.extended.insert(MSO_VARIANT,styleNode.value("variant"));
options.extended.insert(MSO_FONT_FAMILY,styleNode.value("font-family"));
options.extended.insert(MSO_FONT_SIZE,styleNode.value("font-size"));
options.extended.insert(MSO_SELF_COLOR,styleNode.value("self-color"));
options.extended.insert(MSO_CONTACT_COLOR,styleNode.value("contact-color"));
options.extended.insert(MSO_BG_COLOR,styleNode.value("bg-color"));
options.extended.insert(MSO_BG_IMAGE_FILE,styleNode.value("bg-image-file"));
QList<QString> variants = styleVariants(styleId);
QMap<QString,QVariant> info = styleInfo(styleId);
if (!variants.contains(options.extended.value(MSO_VARIANT).toString()))
options.extended.insert(MSO_VARIANT,info.value(MSIV_DEFAULT_VARIANT, variants.value(0)));
if (info.value(MSIV_DISABLE_CUSTOM_BACKGROUND,false).toBool())
{
options.extended.remove(MSO_BG_IMAGE_FILE);
options.extended.insert(MSO_BG_COLOR,info.value(MSIV_DEFAULT_BACKGROUND_COLOR));
}
else if (options.extended.value(MSO_BG_COLOR).toString().isEmpty())
{
options.extended.insert(MSO_BG_COLOR,info.value(MSIV_DEFAULT_BACKGROUND_COLOR));
}
if (options.extended.value(MSO_FONT_FAMILY).toString().isEmpty())
options.extended.insert(MSO_FONT_FAMILY,info.value(MSIV_DEFAULT_FONT_FAMILY));
if (options.extended.value(MSO_FONT_SIZE).toInt() == 0)
options.extended.insert(MSO_FONT_SIZE,info.value(MSIV_DEFAULT_FONT_SIZE));
if (options.extended.value(MSO_SELF_COLOR).toString().isEmpty())
options.extended.insert(MSO_SELF_COLOR,info.value(MSIV_DEFAULT_SELF_COLOR,QColor(Qt::red).name()));
if (options.extended.value(MSO_CONTACT_COLOR).toString().isEmpty())
options.extended.insert(MSO_CONTACT_COLOR,info.value(MSIV_DEFAULT_CONTACT_COLOR,QColor(Qt::blue).name()));
}
else
{
REPORT_ERROR("Failed to find any suitable simple message style");
}
}
else
{
REPORT_ERROR(QString("Failed to get adium style options for style=%1: Style not found").arg(AStyleId));
}
return options;
}
QUuid ConnectionManager::loadProxySettings(const OptionsNode &ANode) const
{
return ANode.value().toString();
}
