feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

BlackBerry: Refactored BarDescriptorDocument

Browse Source 
The BarDescriptorDocument now operates directly on the underlying
QDomDocument, and is much better at keeping the tags on their original
lines. Any new values are appended to the end of the document.

A generic API is provided for changing the values inside the document,
BarDescriptorDocument::setValue(..).

BarDescriptorDocument no longer depends on the BarDescriptorEditorWidget, which
should make it easier to implement splitting of the editor.

Task-number: QTCREATORBUG-11012

Change-Id: Icfd681e3af016ea819b99b8cad2cede46600e910
Reviewed-by: Nicolas Arnaud-Cormos <nicolas@kdab.com>
Reviewed-by: Mehdi Fekari <mfekari@blackberry.com>
Reviewed-by: Rafael Roquetto <rafael.roquetto@kdab.com>
This commit is contained in:
Tobias Naetterlund
2013-12-23 15:36:42 +01:00
committed by Tobias Nätterlund
parent 717e384bb5
commit 3994e698cd
27 changed files with 1039 additions and 1616 deletions
Download Patch File Download Diff File Expand all files Collapse all files

533
src/plugins/qnx/bardescriptordocument.cpp
View File

@@ -32,47 +32,21 @@
#include "bardescriptordocument.h"
#include "qnxconstants.h"
#include "bardescriptoreditor.h"
#include "bardescriptoreditorwidget.h"
#include "bardescriptordocumentnodehandlers.h"
#include <coreplugin/editormanager/ieditor.h>
#include <coreplugin/editormanager/editormanager.h>
#include <utils/qtcassert.h>
#include <QFile>
#include <QFileInfo>
#include <QDir>
#include <QFileInfo>
#include <QMetaEnum>
#include <QTextCodec>
using namespace Qnx;
using namespace Qnx::Internal;
BarDescriptorDocument::BarDescriptorDocument(BarDescriptorEditorWidget *editorWidget)
: Core::TextDocument(editorWidget)
, m_nodeHandlers(QList<BarDescriptorDocumentAbstractNodeHandler *>())
, m_editorWidget(editorWidget)
BarDescriptorDocument::BarDescriptorDocument(QObject *parent)
: Core::TextDocument(parent)
{
// General
registerNodeHandler(new BarDescriptorDocumentIdNodeHandler(m_editorWidget));
registerNodeHandler(new BarDescriptorDocumentVersionNumberNodeHandler(m_editorWidget));
registerNodeHandler(new BarDescriptorDocumentBuildIdNodeHandler(m_editorWidget));
registerNodeHandler(new BarDescriptorDocumentAuthorNodeHandler(m_editorWidget));
registerNodeHandler(new BarDescriptorDocumentAuthorIdNodeHandler(m_editorWidget));
// Application
registerNodeHandler(new BarDescriptorDocumentApplicationNameNodeHandler(m_editorWidget));
registerNodeHandler(new BarDescriptorDocumentApplicationDescriptionNodeHandler(m_editorWidget));
registerNodeHandler(new BarDescriptorDocumentApplicationIconNodeHandler(m_editorWidget));
registerNodeHandler(new BarDescriptorDocumentSplashScreenNodeHandler(m_editorWidget));
registerNodeHandler(new BarDescriptorDocumentInitialWindowNodeHandler(m_editorWidget));
registerNodeHandler(new BarDescriptorDocumentArgNodeHandler(m_editorWidget));
registerNodeHandler(new BarDescriptorDocumentActionNodeHandler(m_editorWidget));
registerNodeHandler(new BarDescriptorDocumentEnvNodeHandler(m_editorWidget));
// Assets
registerNodeHandler(new BarDescriptorDocumentAssetNodeHandler(m_editorWidget));
// blackberry-nativepackager requires the XML file to be in UTF-8 encoding,
// force if possible
if (QTextCodec *defaultUTF8 = QTextCodec::codecForName("UTF-8"))
@@ -83,10 +57,6 @@ BarDescriptorDocument::BarDescriptorDocument(BarDescriptorEditorWidget *editorWi
BarDescriptorDocument::~BarDescriptorDocument()
{
while (!m_nodeHandlers.isEmpty()) {
BarDescriptorDocumentAbstractNodeHandler *nodeHandler = m_nodeHandlers.takeFirst();
delete nodeHandler;
}
}
bool BarDescriptorDocument::open(QString *errorString, const QString &fileName) {
@@ -95,9 +65,8 @@ bool BarDescriptorDocument::open(QString *errorString, const QString &fileName)
return false;
setFilePath(fileName);
m_editorWidget->setFilePath(fileName);
bool result = loadContent(contents);
const bool result = loadContent(contents, false);
if (!result)
*errorString = tr("%1 does not appear to be a valid application descriptor file").arg(QDir::toNativeSeparators(fileName));
@@ -110,12 +79,12 @@ bool BarDescriptorDocument::save(QString *errorString, const QString &fn, bool a
QTC_ASSERT(!autoSave, return false);
QTC_ASSERT(fn.isEmpty(), return false);
bool result = write(filePath(), xmlSource(), errorString);
const bool result = write(filePath(), xmlSource(), errorString);
if (!result)
return false;
m_editorWidget->setDirty(false);
emit changed();
m_dirty = false;
emit Core::IDocument::changed();
return true;
}
@@ -143,7 +112,7 @@ bool BarDescriptorDocument::shouldAutoSave() const
bool BarDescriptorDocument::isModified() const
{
return m_editorWidget->isDirty();
return m_dirty;
}
bool BarDescriptorDocument::isSaveAsAllowed() const
@@ -172,91 +141,435 @@ bool BarDescriptorDocument::reload(QString *errorString, Core::IDocument::Reload
QString BarDescriptorDocument::xmlSource() const
{
BarDescriptorEditor *editor = qobject_cast<BarDescriptorEditor*>(m_editorWidget->editor());
QTC_ASSERT(editor, return QString());
if (editor->activePage() == BarDescriptorEditor::Source) {
return m_editorWidget->xmlSource();
} else {
QDomDocument doc;
doc.appendChild(doc.createProcessingInstruction(QLatin1String("xml"), QLatin1String("version='1.0' encoding='") + QLatin1String(codec()->name()) + QLatin1String("' standalone='no'")));
// QNX
QDomElement rootElem = doc.createElement(QLatin1String("qnx"));
rootElem.setAttribute(QLatin1String("xmlns"), QLatin1String("http://www.qnx.com/schemas/application/1.0"));
QMap<int, BarDescriptorDocumentAbstractNodeHandler*> nodeHandlerMap;
foreach (BarDescriptorDocumentAbstractNodeHandler *nodeHandler, m_nodeHandlers)
nodeHandlerMap.insertMulti(nodeHandler->order(), nodeHandler);
QList<BarDescriptorDocumentAbstractNodeHandler*> nodeHandlers = nodeHandlerMap.values();
foreach (BarDescriptorDocumentAbstractNodeHandler *nodeHandler, nodeHandlers)
rootElem.appendChild(nodeHandler->toNode(doc));
doc.appendChild(rootElem);
return doc.toString(4);
}
const int indent = 4;
return m_barDocument.toString(indent);
}
bool BarDescriptorDocument::loadContent(const QString &xmlSource, QString *errorMessage, int *errorLine)
bool BarDescriptorDocument::loadContent(const QString &xmlCode, bool setDirty, QString *errorMessage, int *errorLine)
{
QDomDocument doc;
bool result = doc.setContent(xmlSource, errorMessage, errorLine);
if (!result)
return false;
QDomElement docElem = doc.documentElement();
if (docElem.tagName() != QLatin1String("qnx"))
return false;
m_editorWidget->clear();
removeUnknownNodeHandlers();
foreach (BarDescriptorDocumentAbstractNodeHandler *nodeHandler, m_nodeHandlers)
nodeHandler->clear();
QDomNode node = docElem.firstChildElement();
while (!node.isNull()) {
BarDescriptorDocumentAbstractNodeHandler *nodeHandler = nodeHandlerForDomNode(node);
if (!nodeHandler) {
nodeHandler = new BarDescriptorDocumentUnknownNodeHandler(m_editorWidget);
registerNodeHandler(nodeHandler);
}
if (!nodeHandler->handle(node))
return false;
node = node.nextSibling();
}
m_editorWidget->setXmlSource(xmlSource);
if (xmlCode == xmlSource())
return true;
bool result = m_barDocument.setContent(xmlCode, errorMessage, errorLine);
m_dirty = setDirty;
emitAllChanged();
emit Core::IDocument::changed();
return result;
}
void BarDescriptorDocument::registerNodeHandler(BarDescriptorDocumentAbstractNodeHandler *nodeHandler)
QVariant BarDescriptorDocument::value(BarDescriptorDocument::Tag tag) const
{
m_nodeHandlers << nodeHandler;
const QString tagName = QString::fromLatin1(metaObject()->enumerator(metaObject()->enumeratorOffset()).valueToKey(tag));
switch (tag) {
case id:
case versionNumber:
case buildId:
case name:
case description:
case author:
case publisher:
case authorId:
return stringValue(tagName);
case icon:
return childStringListValue(tagName, QLatin1String("image")).value(0);
case splashScreens:
return childStringListValue(tagName, QLatin1String("image"));
case asset: {
QVariant var;
var.setValue(assets());
return var;
}
case aspectRatio:
case autoOrients:
case systemChrome:
return childStringListValue(QLatin1String("initialWindow"), tagName).value(0);
case transparent:
return childStringListValue(QLatin1String("initialWindow"), tagName).value(0) == QLatin1String("true");
case arg:
case action:
return stringListValue(tagName);
case env:
QVariant var;
var.setValue(environment());
return var;
}
BarDescriptorDocumentAbstractNodeHandler *BarDescriptorDocument::nodeHandlerForDomNode(const QDomNode &node)
return QVariant();
}
void BarDescriptorDocument::setValue(BarDescriptorDocument::Tag tag, const QVariant &value)
{
foreach (BarDescriptorDocumentAbstractNodeHandler *handler, m_nodeHandlers) {
if (handler->canHandle(node) && !dynamic_cast<BarDescriptorDocumentUnknownNodeHandler*>(handler))
return handler;
const QMetaEnum tagEnum = metaObject()->enumerator(metaObject()->enumeratorOffset());
const QString tagName = QString::fromLatin1(tagEnum.valueToKey(tag));
switch (tag) {
case id:
case versionNumber:
case buildId:
case name:
case description:
case authorId:
setStringValue(tagName, value.toString());
break;
case icon:
case splashScreens:
setChildStringListValue(tagName, QLatin1String("image"), value.toStringList());
break;
case asset:
setAssets(value.value<BarDescriptorAssetList>());
break;
case aspectRatio:
case autoOrients:
case systemChrome:
setChildStringListValue(QLatin1String("initialWindow"), tagName, value.toStringList());
break;
case transparent:
setChildStringListValue(QLatin1String("initialWindow"), tagName, QStringList() << (value.toBool() ? QLatin1String("true") : QLatin1String("false")));
break;
case arg:
case action:
setStringListValue(tagName, value.toStringList());
break;
case env:
setEnvironment(value.value<QList<Utils::EnvironmentItem> >());
break;
case author:
case publisher:
// Unset <publisher> when setting <author> as only one should be used
setStringValue(QString::fromLatin1(tagEnum.valueToKey(author)), value.toString());
setStringValue(QString::fromLatin1(tagEnum.valueToKey(publisher)), QLatin1String(""));
break;
}
return 0;
m_dirty = true;
emit changed(tag, value);
emit Core::IDocument::changed();
}
void BarDescriptorDocument::removeUnknownNodeHandlers()
QString BarDescriptorDocument::stringValue(const QString &tagName) const
{
for (int i = m_nodeHandlers.size() - 1; i >= 0; --i) {
BarDescriptorDocumentUnknownNodeHandler *nodeHandler = dynamic_cast<BarDescriptorDocumentUnknownNodeHandler*>(m_nodeHandlers[i]);
if (nodeHandler) {
m_nodeHandlers.removeAt(i);
delete nodeHandler;
QDomNodeList nodes = m_barDocument.elementsByTagName(tagName);
if (nodes.isEmpty() || nodes.size() > 1)
return QString();
QDomNode node = nodes.item(0);
QDomText textNode = node.firstChild().toText();
if (textNode.isNull())
return QString();
return textNode.data();
}
void BarDescriptorDocument::setStringValue(const QString &tagName, const QString &value)
{
QDomNodeList nodes = m_barDocument.elementsByTagName(tagName);
if (nodes.size() > 1)
return;
QDomNode existingNode = nodes.item(0);
if (existingNode.isNull() && value.isEmpty())
return;
if (!existingNode.isNull() && value.isEmpty()) {
m_barDocument.documentElement().removeChild(existingNode);
} else if (existingNode.isNull()) {
QDomElement newNode = m_barDocument.createElement(tagName);
newNode.appendChild(m_barDocument.createTextNode(value));
m_barDocument.documentElement().appendChild(newNode);
} else {
QDomText textNode = existingNode.firstChild().toText();
if (textNode.isNull())
return;
textNode.setData(value);
}
}
QStringList BarDescriptorDocument::childStringListValue(const QString &tagName, const QString &childTagName) const
{
QDomNodeList nodes = m_barDocument.elementsByTagName(tagName);
if (nodes.isEmpty() || nodes.size() > 1)
return QStringList();
QDomNode parentNode = nodes.item(0);
QDomElement childElm = parentNode.firstChildElement(childTagName);
if (childElm.isNull())
return QStringList();
QStringList result;
while (!childElm.isNull()) {
QDomText textNode = childElm.firstChild().toText();
if (textNode.isNull())
return QStringList();
result.append(textNode.data());
childElm = childElm.nextSiblingElement(childTagName);
}
return result;
}
void BarDescriptorDocument::setChildStringListValue(const QString &tagName, const QString &childTagName, const QStringList &stringList)
{
QDomNodeList nodes = m_barDocument.elementsByTagName(tagName);
if (nodes.size() > 1)
return;
QDomNode existingNode = nodes.item(0);
if (existingNode.isNull()) {
QDomElement newParentNode = m_barDocument.createElement(tagName);
foreach (const QString &value, stringList) {
QDomElement newChildNode = m_barDocument.createElement(childTagName);
QDomText newTextNode = m_barDocument.createTextNode(value);
newChildNode.appendChild(newTextNode);
newParentNode.appendChild(newChildNode);
}
m_barDocument.documentElement().appendChild(newParentNode);
} else {
QStringList values = stringList;
QDomElement childElm = existingNode.firstChildElement(childTagName);
if (!childElm.isNull()) {
// Loop through existing elements, remove the existing nodes
// that no longer are in "values", and remove from "values"
// the existing nodes that don't need re-creation
while (!childElm.isNull()) {
QDomText textNode = childElm.firstChild().toText();
if (textNode.isNull())
continue;
QDomElement toRemove;
if (!values.contains(textNode.data()))
toRemove = childElm;
else
values.removeAll(textNode.data());
childElm = childElm.nextSiblingElement(childTagName);
if (!toRemove.isNull())
existingNode.removeChild(toRemove);
}
}
// Add the new elements
int newElementCount = 0;
foreach (const QString &value, values) {
if (value.isEmpty())
continue;
QDomElement newChildNode = m_barDocument.createElement(childTagName);
newChildNode.appendChild(m_barDocument.createTextNode(value));
existingNode.appendChild(newChildNode);
++newElementCount;
}
if (newElementCount == 0)
m_barDocument.documentElement().removeChild(existingNode);
}
}
QStringList BarDescriptorDocument::stringListValue(const QString &tagName) const
{
QStringList result;
QDomElement childElm = m_barDocument.documentElement().firstChildElement(tagName);
while (!childElm.isNull()) {
QDomText textNode = childElm.firstChild().toText();
if (textNode.isNull())
continue;
result.append(textNode.data());
childElm = childElm.nextSiblingElement(tagName);
}
return result;
}
void BarDescriptorDocument::setStringListValue(const QString &tagName, const QStringList &stringList)
{
QStringList values = stringList;
QDomElement childElm = m_barDocument.documentElement().firstChildElement(tagName);
if (!childElm.isNull()) {
// Loop through existing elements, remove the existing nodes
// that no longer are in "values", and remove from "values"
// the existing nodes that don't need re-creation
while (!childElm.isNull()) {
QDomText textNode = childElm.firstChild().toText();
if (textNode.isNull())
continue;
QDomElement toRemove;
if (!values.contains(textNode.data()))
toRemove = childElm;
else
values.removeAll(textNode.data());
childElm = childElm.nextSiblingElement(tagName);
if (!toRemove.isNull())
m_barDocument.documentElement().removeChild(toRemove);
}
}
// Add the new elements
foreach (const QString &value, values) {
if (value.isEmpty())
continue;
QDomElement newChildNode = m_barDocument.createElement(tagName);
newChildNode.appendChild(m_barDocument.createTextNode(value));
m_barDocument.documentElement().appendChild(newChildNode);
}
}
BarDescriptorAssetList BarDescriptorDocument::assets() const
{
BarDescriptorAssetList result;
QDomNodeList nodes = m_barDocument.elementsByTagName(QLatin1String("asset"));
if (nodes.isEmpty())
return result;
for (int i = 0; i < nodes.size(); ++i) {
QDomElement assetElm = nodes.item(i).toElement();
if (assetElm.isNull())
continue;
QDomText textNode = assetElm.firstChild().toText();
if (textNode.isNull())
continue;
QString path = assetElm.attribute(QLatin1String("path"));
QString entry = assetElm.attribute(QLatin1String("entry"));
QString dest = textNode.data();
BarDescriptorAsset asset;
asset.source = path;
asset.destination = dest;
asset.entry = entry == QLatin1String("true");
result.append(asset);
}
return result;
}
void BarDescriptorDocument::setAssets(const BarDescriptorAssetList &assets)
{
QDomNodeList nodes = m_barDocument.elementsByTagName(QLatin1String("asset"));
BarDescriptorAssetList newAssets = assets;
QList<QDomNode> toRemove;
for (int i = 0; i < nodes.size(); ++i) {
QDomElement assetElm = nodes.at(i).toElement();
if (assetElm.isNull())
continue;
QDomText textNode = assetElm.firstChild().toText();
if (textNode.isNull())
continue;
QString source = assetElm.attribute(QLatin1String("path"));
bool found = false;
foreach (const BarDescriptorAsset &asset, newAssets) {
if (asset.source == source) {
found = true;
if (asset.entry) {
assetElm.setAttribute(QLatin1String("type"), QLatin1String("Qnx/Elf"));
assetElm.setAttribute(QLatin1String("entry"), QLatin1String("true"));
} else {
assetElm.removeAttribute(QLatin1String("type"));
assetElm.removeAttribute(QLatin1String("entry"));
}
textNode.setData(asset.destination);
newAssets.removeAll(asset);
break;
}
}
if (!found)
toRemove.append(assetElm);
}
foreach (const QDomNode &node, toRemove)
m_barDocument.documentElement().removeChild(node);
foreach (const BarDescriptorAsset &asset, newAssets) {
QDomElement assetElm = m_barDocument.createElement(QLatin1String("asset"));
assetElm.setAttribute(QLatin1String("path"), asset.source);
if (asset.entry) {
assetElm.setAttribute(QLatin1String("type"), QLatin1String("Qnx/Elf"));
assetElm.setAttribute(QLatin1String("entry"), QLatin1String("true"));
}
assetElm.appendChild(m_barDocument.createTextNode(asset.destination));
m_barDocument.documentElement().appendChild(assetElm);
}
}
QList<Utils::EnvironmentItem> BarDescriptorDocument::environment() const
{
QList<Utils::EnvironmentItem> result;
QDomElement envElm = m_barDocument.documentElement().firstChildElement(QLatin1String("env"));
while (!envElm.isNull()) {
QString var = envElm.attribute(QLatin1String("var"));
QString value = envElm.attribute(QLatin1String("value"));
Utils::EnvironmentItem item(var, value);
result.append(item);
envElm = envElm.nextSiblingElement(QLatin1String("env"));
}
return result;
}
void BarDescriptorDocument::setEnvironment(const QList<Utils::EnvironmentItem> &environment)
{
QDomNodeList envNodes = m_barDocument.elementsByTagName(QLatin1String("env"));
QList<Utils::EnvironmentItem> newEnvironment = environment;
QList<QDomElement> toRemove;
for (int i = 0; i < envNodes.size(); ++i) {
QDomElement elm = envNodes.at(i).toElement();
if (elm.isNull())
continue;
QString var = elm.attribute(QLatin1String("var"));
bool found = false;
foreach (const Utils::EnvironmentItem item, newEnvironment) {
if (item.name == var) {
found = true;
elm.setAttribute(QLatin1String("value"), item.value);
newEnvironment.removeAll(item);
break;
}
}
if (!found)
toRemove.append(elm);
}
foreach (const QDomNode &node, toRemove)
m_barDocument.documentElement().removeChild(node);
foreach (const Utils::EnvironmentItem item, newEnvironment) {
QDomElement elm = m_barDocument.createElement(QLatin1String("env"));
elm.setAttribute(QLatin1String("var"), item.name);
elm.setAttribute(QLatin1String("value"), item.value);
m_barDocument.documentElement().appendChild(elm);
}
}
void BarDescriptorDocument::emitAllChanged()
{
QMetaEnum tags = metaObject()->enumerator(metaObject()->enumeratorOffset());
for (int i = 0; i < tags.keyCount(); ++i) {
Tag tag = static_cast<Tag>(tags.value(i));
emit changed(tag, value(tag));
}
}

74
src/plugins/qnx/bardescriptordocument.h
View File

@@ -33,8 +33,10 @@
#define QNX_INTERNAL_BARDESCRIPTORDOCUMENT_H
#include <coreplugin/textdocument.h>
#include <utils/environment.h>
#include <QDomNode>
#include <QDomDocument>
#include <QMetaType>
namespace Qnx {
namespace Internal {
@@ -44,16 +46,44 @@ public:
QString source;
QString destination;
bool entry;
bool operator==(const BarDescriptorAsset &asset) const
{
return source == asset.source && destination == asset.destination;
}
};
class BarDescriptorEditorWidget;
class BarDescriptorDocumentAbstractNodeHandler;
typedef QList<BarDescriptorAsset> BarDescriptorAssetList;
class BarDescriptorDocument : public Core::TextDocument
{
Q_OBJECT
Q_ENUMS(Tag)
public:
explicit BarDescriptorDocument(BarDescriptorEditorWidget *editorWidget);
enum Tag {
id = 0,
versionNumber,
buildId,
name,
description,
icon,
splashScreens,
asset,
aspectRatio,
autoOrients,
systemChrome,
transparent,
arg,
action,
env,
author,
publisher,
authorId
};
explicit BarDescriptorDocument(QObject *parent = 0);
~BarDescriptorDocument();
bool open(QString *errorString, const QString &fileName);
@@ -71,19 +101,43 @@ public:
bool reload(QString *errorString, ReloadFlag flag, ChangeType type);
QString xmlSource() const;
bool loadContent(const QString &xmlSource, QString *errorMessage = 0, int *errorLine = 0);
bool loadContent(const QString &xmlCode, bool setDirty, QString *errorMessage = 0, int *errorLine = 0);
QVariant value(Tag tag) const;
signals:
void changed(BarDescriptorDocument::Tag tag, const QVariant &value);
public slots:
void setValue(BarDescriptorDocument::Tag tag, const QVariant &value);
private:
void registerNodeHandler(BarDescriptorDocumentAbstractNodeHandler *nodeHandler);
BarDescriptorDocumentAbstractNodeHandler *nodeHandlerForDomNode(const QDomNode &node);
void removeUnknownNodeHandlers();
QString stringValue(const QString &tagName) const;
void setStringValue(const QString &tagName, const QString &value);
QList<BarDescriptorDocumentAbstractNodeHandler *> m_nodeHandlers;
QStringList childStringListValue(const QString &tagName, const QString &childTagName) const;
void setChildStringListValue(const QString &tagName, const QString &childTagName, const QStringList &stringList);
BarDescriptorEditorWidget *m_editorWidget;
QStringList stringListValue(const QString &tagName) const;
void setStringListValue(const QString &tagName, const QStringList &stringList);
BarDescriptorAssetList assets() const;
void setAssets(const BarDescriptorAssetList &assets);
QList<Utils::EnvironmentItem> environment() const;
void setEnvironment(const QList<Utils::EnvironmentItem> &environment);
void emitAllChanged();
bool m_dirty;
QDomDocument m_barDocument;
};
} // namespace Internal
} // namespace Qnx
Q_DECLARE_METATYPE(Qnx::Internal::BarDescriptorAssetList)
Q_DECLARE_METATYPE(QList<Utils::EnvironmentItem>)
Q_DECLARE_METATYPE(Qnx::Internal::BarDescriptorDocument::Tag)
#endif // QNX_INTERNAL_BARDESCRIPTORDOCUMENT_H

708
src/plugins/qnx/bardescriptordocumentnodehandlers.cpp
View File

@@ -1,708 +0,0 @@
/**************************************************************************
**
** Copyright (C) 2014 BlackBerry Limited. All rights reserved.
**
** Contact: BlackBerry (qt@blackberry.com)
** Contact: KDAB (info@kdab.com)
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
****************************************************************************/
#include "bardescriptordocumentnodehandlers.h"
#include "bardescriptoreditorwidget.h"
#include "bardescriptoreditorassetswidget.h"
#include "bardescriptoreditorauthorinformationwidget.h"
#include "bardescriptoreditorentrypointwidget.h"
#include "bardescriptoreditorenvironmentwidget.h"
#include "bardescriptoreditorgeneralwidget.h"
#include "bardescriptoreditorpackageinformationwidget.h"
#include "bardescriptoreditorpermissionswidget.h"
#include <utils/environment.h>
#include <utils/qtcassert.h>
#include <QDomNode>
using namespace Qnx;
using namespace Qnx::Internal;
BarDescriptorDocumentAbstractNodeHandler::BarDescriptorDocumentAbstractNodeHandler(BarDescriptorEditorWidget *editorWidget)
: m_editorWidget(editorWidget)
, m_order(0xFFFF)
{
}
BarDescriptorDocumentAbstractNodeHandler::~BarDescriptorDocumentAbstractNodeHandler()
{
}
bool BarDescriptorDocumentAbstractNodeHandler::handle(const QDomNode &node)
{
if (m_order == 0xFFFF)
m_order = node.lineNumber();
return fromNode(node);
}
void BarDescriptorDocumentAbstractNodeHandler::clear()
{
m_order = 0xFFFF;
}
int BarDescriptorDocumentAbstractNodeHandler::order() const
{
return m_order;
}
BarDescriptorEditorPackageInformationWidget *BarDescriptorDocumentAbstractNodeHandler::packageInformationWidget() const
{
return m_editorWidget->packageInformationWidget();
}
BarDescriptorEditorAuthorInformationWidget *BarDescriptorDocumentAbstractNodeHandler::authorInformationWidget() const
{
return m_editorWidget->authorInformationWidget();
}
BarDescriptorEditorEntryPointWidget *BarDescriptorDocumentAbstractNodeHandler::entryPointWidget() const
{
return m_editorWidget->entryPointWidget();
}
BarDescriptorEditorGeneralWidget *BarDescriptorDocumentAbstractNodeHandler::generalWidget() const
{
return m_editorWidget->generalWidget();
}
BarDescriptorEditorPermissionsWidget *BarDescriptorDocumentAbstractNodeHandler::permissionsWidget() const
{
return m_editorWidget->permissionsWidget();
}
BarDescriptorEditorEnvironmentWidget *BarDescriptorDocumentAbstractNodeHandler::environmentWidget() const
{
return m_editorWidget->environmentWidget();
}
BarDescriptorEditorAssetsWidget *BarDescriptorDocumentAbstractNodeHandler::assetsWidget() const
{
return m_editorWidget->assetsWidget();
}
bool BarDescriptorDocumentAbstractNodeHandler::canHandleSimpleTextElement(const QDomNode &node, const QString &tagName) const
{
QDomElement element = node.toElement();
if (element.isNull())
return false;
if (element.tagName().toLower() != tagName.toLower())
return false;
QDomText textNode = element.firstChild().toText();
if (textNode.isNull())
return false;
return true;
}
QString BarDescriptorDocumentAbstractNodeHandler::loadSimpleTextElement(const QDomNode &node)
{
QDomElement element = node.toElement();
QDomText textNode = element.firstChild().toText();
return textNode.data();
}
QDomElement BarDescriptorDocumentAbstractNodeHandler::createSimpleTextElement(QDomDocument &doc, const QString &tagName, const QString &textValue) const
{
if (textValue.isEmpty())
return QDomElement();
QDomElement elem = doc.createElement(tagName);
elem.appendChild(doc.createTextNode(textValue));
return elem;
}
// ----------------------------------------------------------------------------
BarDescriptorDocumentIdNodeHandler::BarDescriptorDocumentIdNodeHandler(BarDescriptorEditorWidget *editorWidget)
: BarDescriptorDocumentAbstractNodeHandler(editorWidget)
{
}
bool BarDescriptorDocumentIdNodeHandler::canHandle(const QDomNode &node) const
{
return canHandleSimpleTextElement(node, QLatin1String("id"));
}
bool BarDescriptorDocumentIdNodeHandler::fromNode(const QDomNode &node)
{
if (!canHandle(node))
return false;
packageInformationWidget()->setPackageId(loadSimpleTextElement(node));
return true;
}
QDomNode BarDescriptorDocumentIdNodeHandler::toNode(QDomDocument &doc) const
{
return createSimpleTextElement(doc, QLatin1String("id"), packageInformationWidget()->packageId());
}
// ----------------------------------------------------------------------------
BarDescriptorDocumentVersionNumberNodeHandler::BarDescriptorDocumentVersionNumberNodeHandler(BarDescriptorEditorWidget *editorWidget)
: BarDescriptorDocumentAbstractNodeHandler(editorWidget)
{
}
bool BarDescriptorDocumentVersionNumberNodeHandler::canHandle(const QDomNode &node) const
{
return canHandleSimpleTextElement(node, QLatin1String("versionNumber"));
}
bool BarDescriptorDocumentVersionNumberNodeHandler::fromNode(const QDomNode &node)
{
if (!canHandle(node))
return false;
packageInformationWidget()->setPackageVersion(loadSimpleTextElement(node));
return true;
}
QDomNode BarDescriptorDocumentVersionNumberNodeHandler::toNode(QDomDocument &doc) const
{
return createSimpleTextElement(doc, QLatin1String("versionNumber"), packageInformationWidget()->packageVersion());
}
// ----------------------------------------------------------------------------
BarDescriptorDocumentBuildIdNodeHandler::BarDescriptorDocumentBuildIdNodeHandler(BarDescriptorEditorWidget *editorWidget)
: BarDescriptorDocumentAbstractNodeHandler(editorWidget)
{
}
bool BarDescriptorDocumentBuildIdNodeHandler::canHandle(const QDomNode &node) const
{
return canHandleSimpleTextElement(node, QLatin1String("buildId"));
}
bool BarDescriptorDocumentBuildIdNodeHandler::fromNode(const QDomNode &node)
{
if (!canHandle(node))
return false;
packageInformationWidget()->setPackageBuildId(loadSimpleTextElement(node));
return true;
}
QDomNode BarDescriptorDocumentBuildIdNodeHandler::toNode(QDomDocument &doc) const
{
return createSimpleTextElement(doc, QLatin1String("buildId"), packageInformationWidget()->packageBuildId());
}
// ----------------------------------------------------------------------------
BarDescriptorDocumentApplicationNameNodeHandler::BarDescriptorDocumentApplicationNameNodeHandler(BarDescriptorEditorWidget *editorWidget)
: BarDescriptorDocumentAbstractNodeHandler(editorWidget)
{
}
bool BarDescriptorDocumentApplicationNameNodeHandler::canHandle(const QDomNode &node) const
{
return canHandleSimpleTextElement(node, QLatin1String("name"));
}
bool BarDescriptorDocumentApplicationNameNodeHandler::fromNode(const QDomNode &node)
{
// TODO: Add support for localization
if (!canHandle(node))
return false;
entryPointWidget()->setApplicationName(loadSimpleTextElement(node));
return true;
}
QDomNode BarDescriptorDocumentApplicationNameNodeHandler::toNode(QDomDocument &doc) const
{
// TODO: Add support for localization
return createSimpleTextElement(doc, QLatin1String("name"), entryPointWidget()->applicationName());
}
// ----------------------------------------------------------------------------
BarDescriptorDocumentApplicationDescriptionNodeHandler::BarDescriptorDocumentApplicationDescriptionNodeHandler(BarDescriptorEditorWidget *editorWidget)
: BarDescriptorDocumentAbstractNodeHandler(editorWidget)
{
}
bool BarDescriptorDocumentApplicationDescriptionNodeHandler::canHandle(const QDomNode &node) const
{
return canHandleSimpleTextElement(node, QLatin1String("description"));
}
bool BarDescriptorDocumentApplicationDescriptionNodeHandler::fromNode(const QDomNode &node)
{
// TODO: Add support for localization
if (!canHandle(node))
return false;
entryPointWidget()->setApplicationDescription(loadSimpleTextElement(node));
return true;
}
QDomNode BarDescriptorDocumentApplicationDescriptionNodeHandler::toNode(QDomDocument &doc) const
{
return createSimpleTextElement(doc, QLatin1String("description"), entryPointWidget()->applicationDescription());
}
// ----------------------------------------------------------------------------
BarDescriptorDocumentApplicationIconNodeHandler::BarDescriptorDocumentApplicationIconNodeHandler(BarDescriptorEditorWidget *editorWidget)
: BarDescriptorDocumentAbstractNodeHandler(editorWidget)
{
}
bool BarDescriptorDocumentApplicationIconNodeHandler::canHandle(const QDomNode &node) const
{
QDomElement element = node.toElement();
if (element.isNull())
return false;
if (element.tagName() != QLatin1String("icon"))
return false;
QDomElement imageElement = element.firstChild().toElement();
if (imageElement.isNull())
return false;
if (imageElement.tagName() != QLatin1String("image"))
return false;
QDomText imageTextNode = imageElement.firstChild().toText();
if (imageTextNode.isNull())
return false;
return true;
}
bool BarDescriptorDocumentApplicationIconNodeHandler::fromNode(const QDomNode &node)
{
// TODO: Add support for localization
if (!canHandle(node))
return false;
QDomNode imageNode = node.firstChild();
QDomText imageTextNode = imageNode.firstChild().toText();
entryPointWidget()->setApplicationIcon(imageTextNode.data());
return true;
}
QDomNode BarDescriptorDocumentApplicationIconNodeHandler::toNode(QDomDocument &doc) const
{
// TODO: Add support for localization
const QString iconFileName = entryPointWidget()->applicationIconFileName();
if (iconFileName.isEmpty())
return QDomElement();
QDomElement iconElement = doc.createElement(QLatin1String("icon"));
iconElement.appendChild(createSimpleTextElement(doc, QLatin1String("image"), iconFileName));
return iconElement;
}
// ----------------------------------------------------------------------------
BarDescriptorDocumentSplashScreenNodeHandler::BarDescriptorDocumentSplashScreenNodeHandler(BarDescriptorEditorWidget *editorWidget)
: BarDescriptorDocumentAbstractNodeHandler(editorWidget)
{
}
bool BarDescriptorDocumentSplashScreenNodeHandler::canHandle(const QDomNode &node) const
{
QDomElement element = node.toElement();
if (element.isNull())
return false;
if (element.tagName().toLower() != QLatin1String("splashscreens"))
return false;
QDomElement imageElement = element.firstChild().toElement();
if (imageElement.isNull())
return false;
if (imageElement.tagName().toLower() != QLatin1String("image"))
return false;
QDomText imageTextNode = imageElement.firstChild().toText();
if (imageTextNode.isNull())
return false;
return true;
}
bool BarDescriptorDocumentSplashScreenNodeHandler::fromNode(const QDomNode &node)
{
if (!canHandle(node))
return false;
QDomElement imageNode = node.firstChildElement();
while (!imageNode.isNull()) {
if (imageNode.tagName().toLower() == QLatin1String("image")) {
QDomText imageTextNode = imageNode.firstChild().toText();
entryPointWidget()->appendSplashScreen(imageTextNode.data());
}
imageNode = imageNode.nextSiblingElement();
}
return true;
}
QDomNode BarDescriptorDocumentSplashScreenNodeHandler::toNode(QDomDocument &doc) const
{
QStringList splashScreens = entryPointWidget()->splashScreens();
if (splashScreens.isEmpty())
return QDomElement();
QDomElement splashScreenElement = doc.createElement(QLatin1String("splashScreens"));
foreach (const QString &splashScreen, splashScreens)
splashScreenElement.appendChild(createSimpleTextElement(doc, QLatin1String("image"), splashScreen));
return splashScreenElement;
}
// ----------------------------------------------------------------------------
BarDescriptorDocumentAssetNodeHandler::BarDescriptorDocumentAssetNodeHandler(BarDescriptorEditorWidget *editorWidget)
: BarDescriptorDocumentAbstractNodeHandler(editorWidget)
{
}
bool BarDescriptorDocumentAssetNodeHandler::canHandle(const QDomNode &node) const
{
return canHandleSimpleTextElement(node, QLatin1String("asset"));
}
bool BarDescriptorDocumentAssetNodeHandler::fromNode(const QDomNode &node)
{
if (!canHandle(node))
return false;
QDomElement element = node.toElement();
QString path = element.attribute(QLatin1String("path"));
QString entry = element.attribute(QLatin1String("entry"));
QDomText destNode = element.firstChild().toText();
QString dest = destNode.data();
BarDescriptorAsset asset;
asset.source = path;
asset.destination = dest;
asset.entry = entry == QLatin1String("true");
assetsWidget()->addAsset(asset);
return true;
}
QDomNode BarDescriptorDocumentAssetNodeHandler::toNode(QDomDocument &doc) const
{
QDomDocumentFragment fragment = doc.createDocumentFragment();
QList<BarDescriptorAsset> assets = assetsWidget()->assets();
foreach (const BarDescriptorAsset &asset, assets) {
QDomElement assetElem = doc.createElement(QLatin1String("asset"));
assetElem.setAttribute(QLatin1String("path"), asset.source);
if (asset.entry) {
assetElem.setAttribute(QLatin1String("type"), QLatin1String("Qnx/Elf"));
assetElem.setAttribute(QLatin1String("entry"), QLatin1String("true"));
}
assetElem.appendChild(doc.createTextNode(asset.destination));
fragment.appendChild(assetElem);
}
return fragment;
}
// ----------------------------------------------------------------------------
BarDescriptorDocumentInitialWindowNodeHandler::BarDescriptorDocumentInitialWindowNodeHandler(BarDescriptorEditorWidget *editorWidget)
: BarDescriptorDocumentAbstractNodeHandler(editorWidget)
{
}
bool BarDescriptorDocumentInitialWindowNodeHandler::canHandle(const QDomNode &node) const
{
QDomElement element = node.toElement();
if (element.isNull())
return false;
if (element.tagName() != QLatin1String("initialWindow"))
return false;
return true;
}
bool BarDescriptorDocumentInitialWindowNodeHandler::fromNode(const QDomNode &node)
{
if (!canHandle(node))
return false;
QDomElement child = node.firstChildElement();
while (!child.isNull()) {
if (child.tagName() == QLatin1String("aspectRatio")) {
generalWidget()->setOrientation(loadSimpleTextElement(child));
} else if (child.tagName() == QLatin1String("autoOrients")) {
if (loadSimpleTextElement(child) == QLatin1String("true"))
generalWidget()->setOrientation(QLatin1String("auto-orient"));
} else if (child.tagName() == QLatin1String("systemChrome")) {
generalWidget()->setChrome(loadSimpleTextElement(child));
} else if (child.tagName() == QLatin1String("transparent")) {
const QString transparent = loadSimpleTextElement(child);
generalWidget()->setTransparent(transparent == QLatin1String("true"));
}
child = child.nextSiblingElement();
}
return true;
}
QDomNode BarDescriptorDocumentInitialWindowNodeHandler::toNode(QDomDocument &doc) const
{
QDomElement element = doc.createElement(QLatin1String("initialWindow"));
if (generalWidget()->orientation() == QLatin1String("auto-orient")) {
element.appendChild(createSimpleTextElement(doc, QLatin1String("autoOrients"), QLatin1String("true")));
} else if (!generalWidget()->orientation().isEmpty()) {
element.appendChild(createSimpleTextElement(doc, QLatin1String("aspectRatio"), generalWidget()->orientation()));
element.appendChild(createSimpleTextElement(doc, QLatin1String("autoOrients"), QLatin1String("false")));
}
element.appendChild(createSimpleTextElement(doc, QLatin1String("systemChrome"), generalWidget()->chrome()));
element.appendChild(createSimpleTextElement(doc, QLatin1String("transparent"), generalWidget()->transparent() ? QLatin1String("true") : QLatin1String("false")));
return element;
}
// ----------------------------------------------------------------------------
BarDescriptorDocumentActionNodeHandler::BarDescriptorDocumentActionNodeHandler(BarDescriptorEditorWidget *editorWidget)
: BarDescriptorDocumentAbstractNodeHandler(editorWidget)
{
}
bool BarDescriptorDocumentActionNodeHandler::canHandle(const QDomNode &node) const
{
return canHandleSimpleTextElement(node, QLatin1String("action"));
}
bool BarDescriptorDocumentActionNodeHandler::fromNode(const QDomNode &node)
{
if (!canHandle(node))
return false;
QString value = loadSimpleTextElement(node);
if (value != QLatin1String("run_native")) // This has no representation in the GUI, and is always added
permissionsWidget()->checkPermission(value);
return true;
}
QDomNode BarDescriptorDocumentActionNodeHandler::toNode(QDomDocument &doc) const
{
QDomDocumentFragment frag = doc.createDocumentFragment();
QDomElement runNativeElement = doc.createElement(QLatin1String("action"));
runNativeElement.setAttribute(QLatin1String("system"), QLatin1String("true"));
runNativeElement.appendChild(doc.createTextNode(QLatin1String("run_native")));
frag.appendChild(runNativeElement);
QStringList checkedIdentifiers = permissionsWidget()->checkedPermissions();
foreach (const QString &identifier, checkedIdentifiers)
frag.appendChild(createSimpleTextElement(doc, QLatin1String("action"), identifier));
return frag;
}
// ----------------------------------------------------------------------------
BarDescriptorDocumentArgNodeHandler::BarDescriptorDocumentArgNodeHandler(BarDescriptorEditorWidget *editorWidget)
: BarDescriptorDocumentAbstractNodeHandler(editorWidget)
{
}
bool BarDescriptorDocumentArgNodeHandler::canHandle(const QDomNode &node) const
{
return canHandleSimpleTextElement(node, QLatin1String("arg"));
}
bool BarDescriptorDocumentArgNodeHandler::fromNode(const QDomNode &node)
{
if (!canHandle(node))
return false;
generalWidget()->appendApplicationArgument(loadSimpleTextElement(node));
return true;
}
QDomNode BarDescriptorDocumentArgNodeHandler::toNode(QDomDocument &doc) const
{
QDomDocumentFragment frag = doc.createDocumentFragment();
QStringList arguments = generalWidget()->applicationArguments();
foreach (const QString &argument, arguments)
frag.appendChild(createSimpleTextElement(doc, QLatin1String("arg"), argument));
return frag;
}
// ----------------------------------------------------------------------------
BarDescriptorDocumentEnvNodeHandler::BarDescriptorDocumentEnvNodeHandler(BarDescriptorEditorWidget *editorWidget)
: BarDescriptorDocumentAbstractNodeHandler(editorWidget)
{
}
bool BarDescriptorDocumentEnvNodeHandler::canHandle(const QDomNode &node) const
{
QDomElement element = node.toElement();
if (element.isNull())
return false;
if (element.tagName() != QLatin1String("env"))
return false;
if (!element.hasAttribute(QLatin1String("var")) || !element.hasAttribute(QLatin1String("value")))
return false;
return true;
}
bool BarDescriptorDocumentEnvNodeHandler::fromNode(const QDomNode &node)
{
if (!canHandle(node))
return false;
QDomElement element = node.toElement();
QString var = element.attribute(QLatin1String("var"));
QString value = element.attribute(QLatin1String("value"));
Utils::EnvironmentItem item(var, value);
environmentWidget()->appendEnvironmentItem(item);
return true;
}
QDomNode BarDescriptorDocumentEnvNodeHandler::toNode(QDomDocument &doc) const
{
QDomDocumentFragment frag = doc.createDocumentFragment();
QList<Utils::EnvironmentItem> environmentItems = environmentWidget()->environment();
foreach (const Utils::EnvironmentItem &item, environmentItems) {
QDomElement element = doc.createElement(QLatin1String("env"));
element.setAttribute(QLatin1String("var"), item.name);
element.setAttribute(QLatin1String("value"), item.value);
frag.appendChild(element);
}
return frag;
}
// ----------------------------------------------------------------------------
BarDescriptorDocumentAuthorNodeHandler::BarDescriptorDocumentAuthorNodeHandler(BarDescriptorEditorWidget *editorWidget)
: BarDescriptorDocumentAbstractNodeHandler(editorWidget)
{
}
bool BarDescriptorDocumentAuthorNodeHandler::canHandle(const QDomNode &node) const
{
return canHandleSimpleTextElement(node, QLatin1String("author"))
|| canHandleSimpleTextElement(node, QLatin1String("publisher"));
}
bool BarDescriptorDocumentAuthorNodeHandler::fromNode(const QDomNode &node)
{
if (!canHandle(node))
return false;
authorInformationWidget()->setAuthor(loadSimpleTextElement(node));
return true;
}
QDomNode BarDescriptorDocumentAuthorNodeHandler::toNode(QDomDocument &doc) const
{
return createSimpleTextElement(doc, QLatin1String("author"), authorInformationWidget()->author());
}
// ----------------------------------------------------------------------------
BarDescriptorDocumentAuthorIdNodeHandler::BarDescriptorDocumentAuthorIdNodeHandler(BarDescriptorEditorWidget *editorWidget)
: BarDescriptorDocumentAbstractNodeHandler(editorWidget)
{
}
bool BarDescriptorDocumentAuthorIdNodeHandler::canHandle(const QDomNode &node) const
{
return canHandleSimpleTextElement(node, QLatin1String("authorId"));
}
bool BarDescriptorDocumentAuthorIdNodeHandler::fromNode(const QDomNode &node)
{
if (!canHandle(node))
return false;
authorInformationWidget()->setAuthorId(loadSimpleTextElement(node));
return true;
}
QDomNode BarDescriptorDocumentAuthorIdNodeHandler::toNode(QDomDocument &doc) const
{
return createSimpleTextElement(doc, QLatin1String("authorId"), authorInformationWidget()->authorId());
}
// ----------------------------------------------------------------------------
BarDescriptorDocumentUnknownNodeHandler::BarDescriptorDocumentUnknownNodeHandler(BarDescriptorEditorWidget *editorWidget)
: BarDescriptorDocumentAbstractNodeHandler(editorWidget)
{
}
bool BarDescriptorDocumentUnknownNodeHandler::canHandle(const QDomNode &node) const
{
Q_UNUSED(node);
return true;
}
bool BarDescriptorDocumentUnknownNodeHandler::fromNode(const QDomNode &node)
{
m_node = node.cloneNode();
return true;
}
QDomNode BarDescriptorDocumentUnknownNodeHandler::toNode(QDomDocument &doc) const
{
Q_UNUSED(doc);
return m_node;
}

302
src/plugins/qnx/bardescriptordocumentnodehandlers.h
View File

@@ -1,302 +0,0 @@
/**************************************************************************
**
** Copyright (C) 2014 BlackBerry Limited. All rights reserved.
**
** Contact: BlackBerry (qt@blackberry.com)
** Contact: KDAB (info@kdab.com)
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
****************************************************************************/
#ifndef QNX_INTERNAL_BARDESCRIPTORDOCUMENTNODEHANDLERS_H
#define QNX_INTERNAL_BARDESCRIPTORDOCUMENTNODEHANDLERS_H
#include <QDomNode>
#include <QSharedPointer>
namespace Qnx {
namespace Internal {
class BarDescriptorEditorWidget;
class BarDescriptorEditorAssetsWidget;
class BarDescriptorEditorAuthorInformationWidget;
class BarDescriptorEditorEntryPointWidget;
class BarDescriptorEditorEnvironmentWidget;
class BarDescriptorEditorGeneralWidget;
class BarDescriptorEditorPackageInformationWidget;
class BarDescriptorEditorPermissionsWidget;
class BarDescriptorDocumentAbstractNodeHandler
{
public:
BarDescriptorDocumentAbstractNodeHandler(BarDescriptorEditorWidget *editorWidget);
virtual ~BarDescriptorDocumentAbstractNodeHandler();
virtual bool canHandle(const QDomNode &node) const = 0;
bool handle(const QDomNode &node);
virtual QDomNode toNode(QDomDocument &doc) const = 0;
void clear();
int order() const;
protected:
BarDescriptorEditorPackageInformationWidget *packageInformationWidget() const;
BarDescriptorEditorAuthorInformationWidget *authorInformationWidget() const;
BarDescriptorEditorEntryPointWidget *entryPointWidget() const;
BarDescriptorEditorGeneralWidget *generalWidget() const;
BarDescriptorEditorPermissionsWidget *permissionsWidget() const;
BarDescriptorEditorEnvironmentWidget *environmentWidget() const;
BarDescriptorEditorAssetsWidget *assetsWidget() const;
virtual bool fromNode(const QDomNode &node) = 0;
bool canHandleSimpleTextElement(const QDomNode &node, const QString &tagName) const;
QString loadSimpleTextElement(const QDomNode &node);
QDomElement createSimpleTextElement(QDomDocument &doc, const QString &tagName, const QString &textValue) const;
private:
BarDescriptorEditorWidget *m_editorWidget;
int m_order;
};
// ----------------------------------------------------------------------------
class BarDescriptorDocumentIdNodeHandler : public BarDescriptorDocumentAbstractNodeHandler
{
public:
BarDescriptorDocumentIdNodeHandler(BarDescriptorEditorWidget *editorWidget);
bool canHandle(const QDomNode &node) const;
QDomNode toNode(QDomDocument &doc) const;
protected:
bool fromNode(const QDomNode &node);
};
// ----------------------------------------------------------------------------
class BarDescriptorDocumentVersionNumberNodeHandler : public BarDescriptorDocumentAbstractNodeHandler
{
public:
BarDescriptorDocumentVersionNumberNodeHandler(BarDescriptorEditorWidget *editorWidget);
bool canHandle(const QDomNode &node) const;
QDomNode toNode(QDomDocument &doc) const;
protected:
bool fromNode(const QDomNode &node);
};
// ----------------------------------------------------------------------------
class BarDescriptorDocumentBuildIdNodeHandler : public BarDescriptorDocumentAbstractNodeHandler
{
public:
BarDescriptorDocumentBuildIdNodeHandler(BarDescriptorEditorWidget *editorWidget);
bool canHandle(const QDomNode &node) const;
QDomNode toNode(QDomDocument &doc) const;
protected:
bool fromNode(const QDomNode &node);
};
// ----------------------------------------------------------------------------
class BarDescriptorDocumentApplicationNameNodeHandler : public BarDescriptorDocumentAbstractNodeHandler
{
public:
BarDescriptorDocumentApplicationNameNodeHandler(BarDescriptorEditorWidget *editorWidget);
bool canHandle(const QDomNode &node) const;
QDomNode toNode(QDomDocument &doc) const;
protected:
bool fromNode(const QDomNode &node);
};
// ----------------------------------------------------------------------------
class BarDescriptorDocumentApplicationDescriptionNodeHandler : public BarDescriptorDocumentAbstractNodeHandler
{
public:
BarDescriptorDocumentApplicationDescriptionNodeHandler(BarDescriptorEditorWidget *editorWidget);
bool canHandle(const QDomNode &node) const;
QDomNode toNode(QDomDocument &doc) const;
protected:
bool fromNode(const QDomNode &node);
};
// ----------------------------------------------------------------------------
class BarDescriptorDocumentApplicationIconNodeHandler : public BarDescriptorDocumentAbstractNodeHandler
{
public:
BarDescriptorDocumentApplicationIconNodeHandler(BarDescriptorEditorWidget *editorWidget);
bool canHandle(const QDomNode &node) const;
QDomNode toNode(QDomDocument &doc) const;
protected:
bool fromNode(const QDomNode &node);
};
// ----------------------------------------------------------------------------
class BarDescriptorDocumentSplashScreenNodeHandler : public BarDescriptorDocumentAbstractNodeHandler
{
public:
BarDescriptorDocumentSplashScreenNodeHandler(BarDescriptorEditorWidget *editorWidget);
bool canHandle(const QDomNode &node) const;
QDomNode toNode(QDomDocument &doc) const;
protected:
bool fromNode(const QDomNode &node);
};
// ----------------------------------------------------------------------------
class BarDescriptorDocumentAssetNodeHandler : public BarDescriptorDocumentAbstractNodeHandler
{
public:
BarDescriptorDocumentAssetNodeHandler(BarDescriptorEditorWidget *editorWidget);
bool canHandle(const QDomNode &node) const;
QDomNode toNode(QDomDocument &doc) const;
protected:
bool fromNode(const QDomNode &node);
};
// ----------------------------------------------------------------------------
class BarDescriptorDocumentInitialWindowNodeHandler : public BarDescriptorDocumentAbstractNodeHandler
{
public:
BarDescriptorDocumentInitialWindowNodeHandler(BarDescriptorEditorWidget *editorWidget);
bool canHandle(const QDomNode &node) const;
QDomNode toNode(QDomDocument &doc) const;
protected:
bool fromNode(const QDomNode &node);
};
// ----------------------------------------------------------------------------
class BarDescriptorDocumentActionNodeHandler : public BarDescriptorDocumentAbstractNodeHandler
{
public:
BarDescriptorDocumentActionNodeHandler(BarDescriptorEditorWidget *editorWidget);
bool canHandle(const QDomNode &node) const;
QDomNode toNode(QDomDocument &doc) const;
protected:
bool fromNode(const QDomNode &node);
};
// ----------------------------------------------------------------------------
class BarDescriptorDocumentArgNodeHandler : public BarDescriptorDocumentAbstractNodeHandler
{
public:
BarDescriptorDocumentArgNodeHandler(BarDescriptorEditorWidget *editorWidget);
bool canHandle(const QDomNode &node) const;
QDomNode toNode(QDomDocument &doc) const;
protected:
bool fromNode(const QDomNode &node);
};
// ----------------------------------------------------------------------------
class BarDescriptorDocumentEnvNodeHandler : public BarDescriptorDocumentAbstractNodeHandler
{
public:
BarDescriptorDocumentEnvNodeHandler(BarDescriptorEditorWidget *editorWidget);
bool canHandle(const QDomNode &node) const;
QDomNode toNode(QDomDocument &doc) const;
protected:
bool fromNode(const QDomNode &node);
};
// ----------------------------------------------------------------------------
class BarDescriptorDocumentAuthorNodeHandler : public BarDescriptorDocumentAbstractNodeHandler
{
public:
BarDescriptorDocumentAuthorNodeHandler(BarDescriptorEditorWidget *editorWidget);
bool canHandle(const QDomNode &node) const;
QDomNode toNode(QDomDocument &doc) const;
protected:
bool fromNode(const QDomNode &node);
};
// ----------------------------------------------------------------------------
class BarDescriptorDocumentAuthorIdNodeHandler : public BarDescriptorDocumentAbstractNodeHandler
{
public:
BarDescriptorDocumentAuthorIdNodeHandler(BarDescriptorEditorWidget *editorWidget);
bool canHandle(const QDomNode &node) const;
QDomNode toNode(QDomDocument &doc) const;
protected:
bool fromNode(const QDomNode &node);
};
// ----------------------------------------------------------------------------
class BarDescriptorDocumentUnknownNodeHandler : public BarDescriptorDocumentAbstractNodeHandler
{
public:
BarDescriptorDocumentUnknownNodeHandler(BarDescriptorEditorWidget *editorWidget);
bool canHandle(const QDomNode &node) const;
QDomNode toNode(QDomDocument &doc) const;
protected:
bool fromNode(const QDomNode &node);
private:
QDomNode m_node;
};
} // namespace Internal
} // namespace Qnx
#endif // QNX_INTERNAL_BARDESCRIPTORDOCUMENTNODEHANDLERS_H

39
src/plugins/qnx/bardescriptoreditor.cpp
View File

@@ -56,10 +56,10 @@ namespace Internal {
BarDescriptorEditor::BarDescriptorEditor()
{
m_file = new BarDescriptorDocument(this);
BarDescriptorEditorWidget *editorWidget = new BarDescriptorEditorWidget(this);
setWidget(editorWidget);
m_file = new BarDescriptorDocument(editorWidget);
connect(editorWidget, SIGNAL(changed()), m_file, SIGNAL(changed()));
m_toolBar = new QToolBar(editorWidget);
@@ -106,7 +106,15 @@ BarDescriptorEditor::BarDescriptorEditor()
bool BarDescriptorEditor::open(QString *errorString, const QString &fileName, const QString &realFileName)
{
QTC_ASSERT(fileName == realFileName, return false);
return m_file->open(errorString, fileName);
bool result = m_file->open(errorString, fileName);
if (result) {
BarDescriptorEditorWidget *editorWidget = qobject_cast<BarDescriptorEditorWidget *>(widget());
QTC_ASSERT(editorWidget, return false);
editorWidget->setFilePath(fileName);
}
return result;
}
Core::IDocument *BarDescriptorEditor::document()
@@ -142,31 +150,6 @@ void BarDescriptorEditor::setActivePage(BarDescriptorEditor::EditorPage page)
BarDescriptorEditorWidget *editorWidget = qobject_cast<BarDescriptorEditorWidget *>(widget());
QTC_ASSERT(editorWidget, return);
int prevPage = editorWidget->currentIndex();
if (prevPage == page)
return;
if (page == Source) {
editorWidget->setXmlSource(m_file->xmlSource());
updateCursorPosition();
} else if (prevPage == Source) {
TaskHub::clearTasks(Constants::QNX_TASK_CATEGORY_BARDESCRIPTOR);
QString errorMsg;
int errorLine;
if (!m_file->loadContent(editorWidget->xmlSource(), &errorMsg, &errorLine)) {
TaskHub::addTask(Task::Error, errorMsg, Constants::QNX_TASK_CATEGORY_BARDESCRIPTOR,
Utils::FileName::fromString(m_file->filePath()), errorLine);
TaskHub::requestPopup();
foreach (QAction *action, m_actionGroup->actions())
if (action->data().toInt() == Source)
action->setChecked(true);
return;
}
}
m_cursorPositionAction->setVisible(page == Source);
editorWidget->setCurrentIndex(page);
}

90
src/plugins/qnx/bardescriptoreditorabstractpanelwidget.cpp
View File

@@ -32,10 +32,12 @@
#include "bardescriptoreditorabstractpanelwidget.h"
#include <utils/pathchooser.h>
#include <utils/qtcassert.h>
#include <QCheckBox>
#include <QComboBox>
#include <QLineEdit>
#include <QSignalMapper>
#include <QTextEdit>
using namespace Qnx;
@@ -44,40 +46,86 @@ using namespace Qnx::Internal;
BarDescriptorEditorAbstractPanelWidget::BarDescriptorEditorAbstractPanelWidget(QWidget *parent) :
QWidget(parent)
{
m_signalMapper = new QSignalMapper(this);
connect(m_signalMapper, SIGNAL(mapped(int)), this, SLOT(handleSignalMapped(int)));
}
void BarDescriptorEditorAbstractPanelWidget::setComboBoxBlocked(QComboBox *comboBox, int index)
void BarDescriptorEditorAbstractPanelWidget::setValue(BarDescriptorDocument::Tag tag, const QVariant &value)
{
bool blocked = comboBox->blockSignals(true);
comboBox->setCurrentIndex(index);
comboBox->blockSignals(blocked);
if (m_blockedSignals.contains(tag))
return;
blockSignalMapping(tag);
updateWidgetValue(tag, value);
unblockSignalMapping(tag);
}
void BarDescriptorEditorAbstractPanelWidget::setCheckBoxBlocked(QCheckBox *checkBox, bool checked)
void BarDescriptorEditorAbstractPanelWidget::addSignalMapping(BarDescriptorDocument::Tag tag, QObject *object, const char *signal)
{
bool blocked = checkBox->blockSignals(true);
checkBox->setChecked(checked);
checkBox->blockSignals(blocked);
m_signalMapper->setMapping(object, tag);
connect(object, signal, m_signalMapper, SLOT(map()));
}
void BarDescriptorEditorAbstractPanelWidget::setLineEditBlocked(QLineEdit *lineEdit, const QString &text)
void BarDescriptorEditorAbstractPanelWidget::blockSignalMapping(BarDescriptorDocument::Tag tag)
{
bool blocked = lineEdit->blockSignals(true);
lineEdit->setText(text);
lineEdit->blockSignals(blocked);
m_blockedSignals.prepend(tag);
}
void BarDescriptorEditorAbstractPanelWidget::setTextEditBlocked(QTextEdit *textEdit, const QString &text)
void BarDescriptorEditorAbstractPanelWidget::unblockSignalMapping(BarDescriptorDocument::Tag tag)
{
bool blocked = textEdit->blockSignals(true);
textEdit->setPlainText(text);
textEdit->blockSignals(blocked);
BarDescriptorDocument::Tag removedTag = m_blockedSignals.takeFirst();
QTC_CHECK(removedTag == tag);
}
void BarDescriptorEditorAbstractPanelWidget::setPathChooserBlocked(Utils::PathChooser *pathChooser, const QString &path)
void BarDescriptorEditorAbstractPanelWidget::updateWidgetValue(BarDescriptorDocument::Tag tag, const QVariant &value)
{
bool blocked = pathChooser->blockSignals(true);
pathChooser->setPath(path);
pathChooser->blockSignals(blocked);
QObject *object = m_signalMapper->mapping(static_cast<int>(tag));
if (!object)
return;
if (QLineEdit *lineEdit = qobject_cast<QLineEdit *>(object))
lineEdit->setText(value.toString());
else if (QTextEdit *textEdit = qobject_cast<QTextEdit *>(object))
textEdit->setPlainText(value.toString());
else if (Utils::PathChooser *pathChooser = qobject_cast<Utils::PathChooser *>(object))
pathChooser->setPath(value.toString());
else if (QComboBox *comboBox = qobject_cast<QComboBox *>(object))
comboBox->setCurrentIndex(comboBox->findData(value.toString()));
else if (QCheckBox *checkBox = qobject_cast<QCheckBox *>(object))
checkBox->setChecked(value.toBool());
else
QTC_CHECK(false);
}
void BarDescriptorEditorAbstractPanelWidget::emitChanged(BarDescriptorDocument::Tag tag)
{
QObject *sender = m_signalMapper->mapping(tag);
if (!sender)
return;
if (QLineEdit *lineEdit = qobject_cast<QLineEdit *>(sender))
emit changed(tag, lineEdit->text());
else if (QTextEdit *textEdit = qobject_cast<QTextEdit *>(sender))
emit changed(tag, textEdit->toPlainText());
else if (Utils::PathChooser *pathChooser = qobject_cast<Utils::PathChooser *>(sender))
emit changed(tag, pathChooser->path());
else if (QComboBox *comboBox = qobject_cast<QComboBox *>(sender))
emit changed(tag, comboBox->itemData(comboBox->currentIndex()));
else if (QCheckBox *checkBox = qobject_cast<QCheckBox *>(sender))
emit changed(tag, checkBox->isChecked());
else
QTC_CHECK(false);
}
void BarDescriptorEditorAbstractPanelWidget::handleSignalMapped(int id)
{
BarDescriptorDocument::Tag tag = static_cast<BarDescriptorDocument::Tag>(id);
if (m_blockedSignals.contains(tag))
return;
blockSignalMapping(tag);
emitChanged(tag);
unblockSignalMapping(tag);
}

27
src/plugins/qnx/bardescriptoreditorabstractpanelwidget.h
View File

@@ -34,6 +34,8 @@
#include <QWidget>
#include "bardescriptordocument.h"
namespace Utils {
class PathChooser;
}
@@ -42,6 +44,8 @@ QT_BEGIN_NAMESPACE
class QCheckBox;
class QComboBox;
class QLineEdit;
class QSignalMapper;
class QStringListModel;
class QTextEdit;
QT_END_NAMESPACE
@@ -54,17 +58,26 @@ class BarDescriptorEditorAbstractPanelWidget : public QWidget
public:
explicit BarDescriptorEditorAbstractPanelWidget(QWidget *parent = 0);
virtual void clear() = 0;
public slots:
void setValue(BarDescriptorDocument::Tag tag, const QVariant &value);
signals:
void changed();
void changed(BarDescriptorDocument::Tag tag, const QVariant &value);
protected:
void setComboBoxBlocked(QComboBox *comboBox, int index);
void setCheckBoxBlocked(QCheckBox *checkBox, bool checked);
void setLineEditBlocked(QLineEdit *lineEdit, const QString &text);
void setTextEditBlocked(QTextEdit *textEdit, const QString &text);
void setPathChooserBlocked(Utils::PathChooser *pathChooser, const QString &path);
virtual void updateWidgetValue(BarDescriptorDocument::Tag tag, const QVariant &value);
virtual void emitChanged(BarDescriptorDocument::Tag tag);
void addSignalMapping(BarDescriptorDocument::Tag tag, QObject *object, const char *signal);
void blockSignalMapping(BarDescriptorDocument::Tag tag);
void unblockSignalMapping(BarDescriptorDocument::Tag tag);
private slots:
void handleSignalMapped(int id);
private:
QSignalMapper *m_signalMapper;
QList<BarDescriptorDocument::Tag> m_blockedSignals;
};
} // namespace Internal

74
src/plugins/qnx/bardescriptoreditorassetswidget.cpp
View File

@@ -57,7 +57,10 @@ BarDescriptorEditorAssetsWidget::BarDescriptorEditorAssetsWidget(QWidget *parent
connect(m_ui->addAsset, SIGNAL(clicked()), this, SLOT(addNewAsset()));
connect(m_ui->removeAsset, SIGNAL(clicked()), this, SLOT(removeSelectedAsset()));
connect(m_assetsModel, SIGNAL(itemChanged(QStandardItem*)), this, SLOT(updateEntryCheckState(QStandardItem*)));
connectAssetsModel();
addSignalMapping(BarDescriptorDocument::asset, m_assetsModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)));
addSignalMapping(BarDescriptorDocument::asset, m_assetsModel, SIGNAL(rowsInserted(QModelIndex,int,int)));
addSignalMapping(BarDescriptorDocument::asset, m_assetsModel, SIGNAL(rowsRemoved(QModelIndex,int,int)));
}
BarDescriptorEditorAssetsWidget::~BarDescriptorEditorAssetsWidget()
@@ -67,32 +70,9 @@ BarDescriptorEditorAssetsWidget::~BarDescriptorEditorAssetsWidget()
void BarDescriptorEditorAssetsWidget::clear()
{
// We can't just block signals, as the view depends on them
disconnectAssetsModel();
blockSignalMapping(BarDescriptorDocument::asset);
m_assetsModel->removeRows(0, m_assetsModel->rowCount());
connectAssetsModel();
}
void BarDescriptorEditorAssetsWidget::addAsset(const BarDescriptorAsset &asset)
{
disconnectAssetsModel();
addAssetInternal(asset);
connectAssetsModel();
}
QList<BarDescriptorAsset> BarDescriptorEditorAssetsWidget::assets() const
{
QList<BarDescriptorAsset> result;
for (int i = 0; i < m_assetsModel->rowCount(); ++i) {
BarDescriptorAsset asset;
asset.source = m_assetsModel->item(i, 0)->text();
asset.destination = m_assetsModel->item(i, 1)->text();
asset.entry = m_assetsModel->item(i, 2)->checkState() == Qt::Checked;
result << asset;
}
return result;
unblockSignalMapping(BarDescriptorDocument::asset);
}
QStandardItemModel *BarDescriptorEditorAssetsWidget::assetsModel() const
@@ -100,6 +80,19 @@ QStandardItemModel *BarDescriptorEditorAssetsWidget::assetsModel() const
return m_assetsModel;
}
void BarDescriptorEditorAssetsWidget::updateWidgetValue(BarDescriptorDocument::Tag tag, const QVariant &value)
{
if (tag != BarDescriptorDocument::asset) {
BarDescriptorEditorAbstractPanelWidget::updateWidgetValue(tag, value);
return;
}
clear();
BarDescriptorAssetList assets = value.value<BarDescriptorAssetList>();
foreach (const BarDescriptorAsset asset, assets)
addAsset(asset);
}
void BarDescriptorEditorAssetsWidget::addAsset(const QString &fullPath)
{
if (fullPath.isEmpty())
@@ -109,7 +102,7 @@ void BarDescriptorEditorAssetsWidget::addAsset(const QString &fullPath)
asset.source = fullPath;
asset.destination = QFileInfo(fullPath).fileName();
asset.entry = false;
addAssetInternal(asset);
addAsset(asset);
}
void BarDescriptorEditorAssetsWidget::removeAsset(const QString &fullPath)
@@ -157,21 +150,28 @@ void BarDescriptorEditorAssetsWidget::updateEntryCheckState(QStandardItem *item)
connect(m_assetsModel, SIGNAL(itemChanged(QStandardItem*)), this, SLOT(updateEntryCheckState(QStandardItem*)));
}
void BarDescriptorEditorAssetsWidget::connectAssetsModel()
void BarDescriptorEditorAssetsWidget::emitChanged(BarDescriptorDocument::Tag tag)
{
connect(m_assetsModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SIGNAL(changed()));
connect(m_assetsModel, SIGNAL(rowsInserted(QModelIndex,int,int)), this, SIGNAL(changed()));
connect(m_assetsModel, SIGNAL(rowsRemoved(QModelIndex,int,int)), this, SIGNAL(changed()));
if (tag != BarDescriptorDocument::asset) {
BarDescriptorEditorAbstractPanelWidget::emitChanged(tag);
return;
}
void BarDescriptorEditorAssetsWidget::disconnectAssetsModel()
{
disconnect(m_assetsModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SIGNAL(changed()));
disconnect(m_assetsModel, SIGNAL(rowsInserted(QModelIndex,int,int)), this, SIGNAL(changed()));
disconnect(m_assetsModel, SIGNAL(rowsRemoved(QModelIndex,int,int)), this, SIGNAL(changed()));
BarDescriptorAssetList result;
for (int i = 0; i < m_assetsModel->rowCount(); ++i) {
BarDescriptorAsset asset;
asset.source = m_assetsModel->item(i, 0)->text();
asset.destination = m_assetsModel->item(i, 1)->text();
asset.entry = m_assetsModel->item(i, 2)->checkState() == Qt::Checked;
result.append(asset);
}
void BarDescriptorEditorAssetsWidget::addAssetInternal(const BarDescriptorAsset &asset)
QVariant var;
var.setValue(result);
emit changed(tag, var);
}
void BarDescriptorEditorAssetsWidget::addAsset(const BarDescriptorAsset &asset)
{
const QString path = asset.source;
const QString dest = asset.destination;

15
src/plugins/qnx/bardescriptoreditorassetswidget.h
View File

@@ -56,27 +56,24 @@ public:
explicit BarDescriptorEditorAssetsWidget(QWidget *parent = 0);
~BarDescriptorEditorAssetsWidget();
void clear();
void addAsset(const BarDescriptorAsset &asset);
QList<BarDescriptorAsset> assets() const;
QStandardItemModel *assetsModel() const;
public slots:
void addAsset(const QString &fullPath);
void removeAsset(const QString &fullPath);
protected:
void updateWidgetValue(BarDescriptorDocument::Tag tag, const QVariant &value);
void emitChanged(BarDescriptorDocument::Tag tag);
private slots:
void addNewAsset();
void removeSelectedAsset();
void updateEntryCheckState(QStandardItem *item);
private:
void connectAssetsModel();
void disconnectAssetsModel();
void addAssetInternal(const BarDescriptorAsset &asset);
void clear();
void addAsset(const BarDescriptorAsset &asset);
bool hasAsset(const BarDescriptorAsset &asset);
Ui::BarDescriptorEditorAssetsWidget *m_ui;

33
src/plugins/qnx/bardescriptoreditorauthorinformationwidget.cpp
View File

@@ -53,8 +53,8 @@ BarDescriptorEditorAuthorInformationWidget::BarDescriptorEditorAuthorInformation
m_ui->setFromDebugToken->setVisible(BlackBerryDebugTokenReader::isSupported());
connect(m_ui->author, SIGNAL(textChanged(QString)), this, SIGNAL(changed()));
connect(m_ui->authorId, SIGNAL(textChanged(QString)), this, SIGNAL(changed()));
addSignalMapping(BarDescriptorDocument::author, m_ui->author, SIGNAL(textChanged(QString)));
addSignalMapping(BarDescriptorDocument::authorId, m_ui->authorId, SIGNAL(textChanged(QString)));
connect(m_ui->setFromDebugToken, SIGNAL(clicked()), this, SLOT(setAuthorFromDebugToken()));
}
@@ -63,30 +63,13 @@ BarDescriptorEditorAuthorInformationWidget::~BarDescriptorEditorAuthorInformatio
delete m_ui;
}
void BarDescriptorEditorAuthorInformationWidget::clear()
void BarDescriptorEditorAuthorInformationWidget::updateWidgetValue(BarDescriptorDocument::Tag tag, const QVariant &value)
{
setLineEditBlocked(m_ui->author, QString());
setLineEditBlocked(m_ui->authorId, QString());
}
QString BarDescriptorEditorAuthorInformationWidget::author() const
{
return m_ui->author->text();
}
void BarDescriptorEditorAuthorInformationWidget::setAuthor(const QString &author)
{
setLineEditBlocked(m_ui->author, author);
}
QString BarDescriptorEditorAuthorInformationWidget::authorId() const
{
return m_ui->authorId->text();
}
void BarDescriptorEditorAuthorInformationWidget::setAuthorId(const QString &authorId)
{
setLineEditBlocked(m_ui->authorId, authorId);
if (tag == BarDescriptorDocument::publisher && !value.toString().isEmpty())
// <publisher> is deprecated and hence not connected to the author field as we only want to read it from the XML
m_ui->author->setText(value.toString());
else
BarDescriptorEditorAbstractPanelWidget::updateWidgetValue(tag, value);
}
void BarDescriptorEditorAuthorInformationWidget::setAuthorFromDebugToken()

9
src/plugins/qnx/bardescriptoreditorauthorinformationwidget.h
View File

@@ -49,13 +49,8 @@ public:
explicit BarDescriptorEditorAuthorInformationWidget(QWidget *parent = 0);
~BarDescriptorEditorAuthorInformationWidget();
void clear();
QString author() const;
void setAuthor(const QString &author);
QString authorId() const;
void setAuthorId(const QString &authorId);
protected:
void updateWidgetValue(BarDescriptorDocument::Tag tag, const QVariant &value);
private slots:
void setAuthorFromDebugToken();

108
src/plugins/qnx/bardescriptoreditorentrypointwidget.cpp
View File

@@ -65,9 +65,6 @@ BarDescriptorEditorEntryPointWidget::BarDescriptorEditorEntryPointWidget(QWidget
m_ui->splashScreenWarningLabel->setVisible(false);
m_ui->splashScreenWarningPixmap->setVisible(false);
connect(m_ui->applicationName, SIGNAL(textChanged(QString)), this, SIGNAL(changed()));
connect(m_ui->applicationDescription, SIGNAL(textChanged()), this, SIGNAL(changed()));
connect(m_ui->iconFilePath, SIGNAL(changed(QString)), this, SLOT(handleIconChanged(QString)));
connect(m_ui->iconClearButton, SIGNAL(clicked()), this, SLOT(clearIcon()));
@@ -75,8 +72,14 @@ BarDescriptorEditorEntryPointWidget::BarDescriptorEditorEntryPointWidget(QWidget
m_ui->splashScreensView->setModel(m_splashScreenModel);
connect(m_ui->addSplashScreen, SIGNAL(clicked()), this, SLOT(browseForSplashScreen()));
connect(m_ui->removeSplashScreen, SIGNAL(clicked()), this, SLOT(removeSelectedSplashScreen()));
connect(m_splashScreenModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SIGNAL(changed()));
connect(m_ui->splashScreensView->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)), this, SLOT(handleSplashScreenSelectionChanged(QItemSelection,QItemSelection)));
addSignalMapping(BarDescriptorDocument::name, m_ui->applicationName, SIGNAL(textChanged(QString)));
addSignalMapping(BarDescriptorDocument::description, m_ui->applicationDescription, SIGNAL(textChanged()));
addSignalMapping(BarDescriptorDocument::icon, m_ui->iconFilePath, SIGNAL(changed(QString)));
addSignalMapping(BarDescriptorDocument::splashScreens, m_splashScreenModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)));
addSignalMapping(BarDescriptorDocument::splashScreens, m_splashScreenModel, SIGNAL(rowsRemoved(QModelIndex,int,int)));
addSignalMapping(BarDescriptorDocument::splashScreens, m_splashScreenModel, SIGNAL(rowsInserted(QModelIndex,int,int)));
}
BarDescriptorEditorEntryPointWidget::~BarDescriptorEditorEntryPointWidget()
@@ -84,68 +87,40 @@ BarDescriptorEditorEntryPointWidget::~BarDescriptorEditorEntryPointWidget()
delete m_ui;
}
void BarDescriptorEditorEntryPointWidget::clear()
{
setPathChooserBlocked(m_ui->iconFilePath, QString());
setApplicationIconPreview(QString());
disconnect(m_splashScreenModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SIGNAL(changed()));
m_splashScreenModel->setStringList(QStringList());
connect(m_splashScreenModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SIGNAL(changed()));
setImagePreview(m_ui->splashScreenPreviewLabel, QString());
}
QString BarDescriptorEditorEntryPointWidget::applicationName() const
{
return m_ui->applicationName->text();
}
void BarDescriptorEditorEntryPointWidget::setApplicationName(const QString &applicationName)
{
setLineEditBlocked(m_ui->applicationName, applicationName);
}
QString BarDescriptorEditorEntryPointWidget::applicationDescription() const
{
return m_ui->applicationDescription->toPlainText();
}
void BarDescriptorEditorEntryPointWidget::setApplicationDescription(const QString &applicationDescription)
{
setTextEditBlocked(m_ui->applicationDescription, applicationDescription);
}
QString BarDescriptorEditorEntryPointWidget::applicationIconFileName() const
{
return QFileInfo(m_ui->iconFilePath->path()).fileName();
}
void BarDescriptorEditorEntryPointWidget::setApplicationIcon(const QString &iconPath)
{
// During file loading, the assets might not have been read yet
QMetaObject::invokeMethod(this, "setApplicationIconDelayed", Qt::QueuedConnection, Q_ARG(QString, iconPath));
}
QStringList BarDescriptorEditorEntryPointWidget::splashScreens() const
{
QStringList result;
foreach (const QString &splashScreen, m_splashScreenModel->stringList())
result << QFileInfo(splashScreen).fileName();
return result;
}
void BarDescriptorEditorEntryPointWidget::appendSplashScreen(const QString &splashScreenPath)
{
QMetaObject::invokeMethod(this, "appendSplashScreenDelayed", Qt::QueuedConnection, Q_ARG(QString, splashScreenPath));
}
void BarDescriptorEditorEntryPointWidget::setAssetsModel(QStandardItemModel *assetsModel)
{
m_assetsModel = QWeakPointer<QStandardItemModel>(assetsModel);
}
void BarDescriptorEditorEntryPointWidget::updateWidgetValue(BarDescriptorDocument::Tag tag, const QVariant &value)
{
// During file loading, the assets might not have been read yet
if (tag == BarDescriptorDocument::icon) {
QMetaObject::invokeMethod(this, "setApplicationIconDelayed", Qt::QueuedConnection, Q_ARG(QString, value.toString()));
} else if (tag == BarDescriptorDocument::splashScreens) {
QStringList splashScreens = value.toStringList();
foreach (const QString &splashScreen, splashScreens)
QMetaObject::invokeMethod(this, "appendSplashScreenDelayed", Qt::QueuedConnection, Q_ARG(QString, splashScreen));
} else {
BarDescriptorEditorAbstractPanelWidget::updateWidgetValue(tag, value);
}
}
void BarDescriptorEditorEntryPointWidget::emitChanged(BarDescriptorDocument::Tag tag)
{
if (tag == BarDescriptorDocument::icon) {
emit changed(tag, QFileInfo(m_ui->iconFilePath->path()).fileName());
} else if (tag == BarDescriptorDocument::splashScreens) {
QStringList list;
foreach (const QString &splashScreen, m_splashScreenModel->stringList())
list << QFileInfo(splashScreen).fileName();
emit changed(tag, list);
} else {
BarDescriptorEditorAbstractPanelWidget::emitChanged(tag);
}
}
void BarDescriptorEditorEntryPointWidget::setApplicationIconPreview(const QString &path)
{
setImagePreview(m_ui->iconPreviewLabel, path);
@@ -164,7 +139,7 @@ void BarDescriptorEditorEntryPointWidget::handleIconChanged(const QString &path)
setApplicationIconPreview(path);
validateIconSize(path);
emit changed();
if (!m_splashScreenModel->stringList().contains(m_prevIconPath))
emit imageRemoved(m_prevIconPath);
m_prevIconPath = path;
@@ -200,6 +175,7 @@ void BarDescriptorEditorEntryPointWidget::removeSelectedSplashScreen()
foreach (const QModelIndex &index, selectedIndexes) {
QString path = m_splashScreenModel->data(index, Qt::DisplayRole).toString();
if (path != m_ui->iconFilePath->path())
emit imageRemoved(path);
m_splashScreenModel->removeRow(index.row());
@@ -230,11 +206,11 @@ void BarDescriptorEditorEntryPointWidget::appendSplashScreenDelayed(const QStrin
if (fullSplashScreenPath.isEmpty())
return;
disconnect(m_splashScreenModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SIGNAL(changed()));
blockSignalMapping(BarDescriptorDocument::splashScreens);
int rowCount = m_splashScreenModel->rowCount();
m_splashScreenModel->insertRow(rowCount);
m_splashScreenModel->setData(m_splashScreenModel->index(rowCount), fullSplashScreenPath);
connect(m_splashScreenModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SIGNAL(changed()));
unblockSignalMapping(BarDescriptorDocument::splashScreens);
}
void BarDescriptorEditorEntryPointWidget::setImagePreview(QLabel *previewLabel, const QString &path)
@@ -309,9 +285,11 @@ void BarDescriptorEditorEntryPointWidget::setApplicationIconDelayed(const QStrin
if (fullIconPath.isEmpty())
return;
setPathChooserBlocked(m_ui->iconFilePath, fullIconPath);
blockSignalMapping(BarDescriptorDocument::icon);
m_ui->iconFilePath->setPath(fullIconPath);
setApplicationIconPreview(fullIconPath);
validateIconSize(fullIconPath);
unblockSignalMapping(BarDescriptorDocument::icon);
}
QString BarDescriptorEditorEntryPointWidget::localAssetPathFromDestination(const QString &destination)

18
src/plugins/qnx/bardescriptoreditorentrypointwidget.h
View File

@@ -57,26 +57,16 @@ public:
explicit BarDescriptorEditorEntryPointWidget(QWidget *parent = 0);
~BarDescriptorEditorEntryPointWidget();
void clear();
QString applicationName() const;
void setApplicationName(const QString &applicationName);
QString applicationDescription() const;
void setApplicationDescription(const QString &applicationDescription);
QString applicationIconFileName() const;
void setApplicationIcon(const QString &iconPath);
QStringList splashScreens() const;
void appendSplashScreen(const QString &splashScreenPath);
void setAssetsModel(QStandardItemModel *assetsModel);
signals:
void imageAdded(const QString &path);
void imageRemoved(const QString &path);
protected:
void updateWidgetValue(BarDescriptorDocument::Tag tag, const QVariant &value);
void emitChanged(BarDescriptorDocument::Tag tag);
private slots:
void setApplicationIconDelayed(const QString &iconPath);
void setApplicationIconPreview(const QString &path);

29
src/plugins/qnx/bardescriptoreditorenvironmentwidget.cpp
View File

@@ -43,7 +43,7 @@ BarDescriptorEditorEnvironmentWidget::BarDescriptorEditorEnvironmentWidget(QWidg
m_ui->environmentWidget->setBaseEnvironmentText(tr("Device Environment"));
connect(m_ui->environmentWidget, SIGNAL(userChangesChanged()), this, SIGNAL(changed()));
addSignalMapping(BarDescriptorDocument::env, m_ui->environmentWidget, SIGNAL(userChangesChanged()));
}
BarDescriptorEditorEnvironmentWidget::~BarDescriptorEditorEnvironmentWidget()
@@ -51,23 +51,24 @@ BarDescriptorEditorEnvironmentWidget::~BarDescriptorEditorEnvironmentWidget()
delete m_ui;
}
void BarDescriptorEditorEnvironmentWidget::clear()
void BarDescriptorEditorEnvironmentWidget::updateWidgetValue(BarDescriptorDocument::Tag tag, const QVariant &value)
{
disconnect(m_ui->environmentWidget, SIGNAL(userChangesChanged()), this, SIGNAL(changed()));
m_ui->environmentWidget->setUserChanges(QList<Utils::EnvironmentItem>());
connect(m_ui->environmentWidget, SIGNAL(userChangesChanged()), this, SIGNAL(changed()));
if (tag != BarDescriptorDocument::env) {
BarDescriptorEditorAbstractPanelWidget::updateWidgetValue(tag, value);
return;
}
QList<Utils::EnvironmentItem> BarDescriptorEditorEnvironmentWidget::environment() const
{
return m_ui->environmentWidget->userChanges();
m_ui->environmentWidget->setUserChanges(value.value<QList<Utils::EnvironmentItem> >());
}
void BarDescriptorEditorEnvironmentWidget::appendEnvironmentItem(const Utils::EnvironmentItem &envItem)
void BarDescriptorEditorEnvironmentWidget::emitChanged(BarDescriptorDocument::Tag tag)
{
disconnect(m_ui->environmentWidget, SIGNAL(userChangesChanged()), this, SIGNAL(changed()));
QList<Utils::EnvironmentItem> items = m_ui->environmentWidget->userChanges();
items.append(envItem);
m_ui->environmentWidget->setUserChanges(items);
connect(m_ui->environmentWidget, SIGNAL(userChangesChanged()), this, SIGNAL(changed()));
if (tag != BarDescriptorDocument::env) {
BarDescriptorEditorAbstractPanelWidget::emitChanged(tag);
return;
}
QVariant var;
var.setValue(m_ui->environmentWidget->userChanges());
emit changed(tag, var);
}

7
src/plugins/qnx/bardescriptoreditorenvironmentwidget.h
View File

@@ -51,10 +51,9 @@ public:
explicit BarDescriptorEditorEnvironmentWidget(QWidget *parent = 0);
~BarDescriptorEditorEnvironmentWidget();
void clear();
QList<Utils::EnvironmentItem> environment() const;
void appendEnvironmentItem(const Utils::EnvironmentItem &envItem);
protected:
void updateWidgetValue(BarDescriptorDocument::Tag tag, const QVariant &value);
void emitChanged(BarDescriptorDocument::Tag tag);
private:
Ui::BarDescriptorEditorEnvironmentWidget *m_ui;

91
src/plugins/qnx/bardescriptoreditorgeneralwidget.cpp
View File

@@ -51,10 +51,10 @@ BarDescriptorEditorGeneralWidget::BarDescriptorEditorGeneralWidget(QWidget *pare
m_ui->chrome->addItem(tr("Standard"), QLatin1String("standard"));
m_ui->chrome->addItem(tr("None"), QLatin1String("none"));
connect(m_ui->orientation, SIGNAL(currentIndexChanged(int)), this, SIGNAL(changed()));
connect(m_ui->chrome, SIGNAL(currentIndexChanged(int)), this, SIGNAL(changed()));
connect(m_ui->transparentMainWindow, SIGNAL(toggled(bool)), this, SIGNAL(changed()));
connect(m_ui->applicationArguments, SIGNAL(textChanged(QString)), this, SIGNAL(changed()));
addSignalMapping(BarDescriptorDocument::aspectRatio, m_ui->orientation, SIGNAL(currentIndexChanged(int)));
addSignalMapping(BarDescriptorDocument::systemChrome, m_ui->chrome, SIGNAL(currentIndexChanged(int)));
addSignalMapping(BarDescriptorDocument::transparent, m_ui->transparentMainWindow, SIGNAL(toggled(bool)));
addSignalMapping(BarDescriptorDocument::arg, m_ui->applicationArguments, SIGNAL(textChanged(QString)));
}
BarDescriptorEditorGeneralWidget::~BarDescriptorEditorGeneralWidget()
@@ -62,62 +62,41 @@ BarDescriptorEditorGeneralWidget::~BarDescriptorEditorGeneralWidget()
delete m_ui;
}
void BarDescriptorEditorGeneralWidget::clear()
void BarDescriptorEditorGeneralWidget::updateWidgetValue(BarDescriptorDocument::Tag tag, const QVariant &value)
{
setComboBoxBlocked(m_ui->orientation, m_ui->orientation->findData(QLatin1String("")));
setComboBoxBlocked(m_ui->chrome, m_ui->chrome->findData(QLatin1String("none")));
setCheckBoxBlocked(m_ui->transparentMainWindow, false);
setLineEditBlocked(m_ui->applicationArguments, QString());
if (tag == BarDescriptorDocument::aspectRatio) {
m_ui->orientation->setCurrentIndex(m_ui->orientation->findData(value));
} else if (tag == BarDescriptorDocument::autoOrients) {
if (value.toString() == QLatin1String("true")) {
blockSignalMapping(BarDescriptorDocument::aspectRatio);
m_ui->orientation->setCurrentIndex(m_ui->orientation->findData(QLatin1String("auto-orient")));
unblockSignalMapping(BarDescriptorDocument::aspectRatio);
}
} else if (tag == BarDescriptorDocument::arg) {
m_ui->applicationArguments->setText(value.toStringList().join(QLatin1String(" ")));
} else {
BarDescriptorEditorAbstractPanelWidget::updateWidgetValue(tag, value);
}
}
QString BarDescriptorEditorGeneralWidget::orientation() const
void BarDescriptorEditorGeneralWidget::emitChanged(BarDescriptorDocument::Tag tag)
{
return m_ui->orientation->itemData(m_ui->orientation->currentIndex()).toString();
if (tag == BarDescriptorDocument::aspectRatio) {
QString value = m_ui->orientation->itemData(m_ui->orientation->currentIndex()).toString();
if (value == QLatin1String("auto-orient")) {
emit changed(BarDescriptorDocument::aspectRatio, QLatin1String(""));
emit changed(BarDescriptorDocument::autoOrients, QLatin1String("true"));
return;
} else if (!value.isEmpty()) {
emit changed(BarDescriptorDocument::aspectRatio, value);
emit changed(BarDescriptorDocument::autoOrients, QLatin1String("false"));
} else {
emit changed(BarDescriptorDocument::aspectRatio, value);
emit changed(BarDescriptorDocument::autoOrients, QLatin1String(""));
}
void BarDescriptorEditorGeneralWidget::setOrientation(const QString &orientation)
{
int index = m_ui->orientation->findData(orientation);
QTC_ASSERT(index >= 0, return);
setComboBoxBlocked(m_ui->orientation, index);
} else if (tag == BarDescriptorDocument::arg) {
emit changed(tag, m_ui->applicationArguments->text().split(QLatin1Char(' ')));
} else {
BarDescriptorEditorAbstractPanelWidget::emitChanged(tag);
}
QString BarDescriptorEditorGeneralWidget::chrome() const
{
return m_ui->chrome->itemData(m_ui->chrome->currentIndex()).toString();
}
void BarDescriptorEditorGeneralWidget::setChrome(const QString &chrome)
{
int index = m_ui->chrome->findData(chrome);
QTC_ASSERT(index >= 0, return);
setComboBoxBlocked(m_ui->chrome, index);
}
bool BarDescriptorEditorGeneralWidget::transparent() const
{
return m_ui->transparentMainWindow->isChecked();
}
void BarDescriptorEditorGeneralWidget::setTransparent(bool transparent)
{
setCheckBoxBlocked(m_ui->transparentMainWindow, transparent);
}
void BarDescriptorEditorGeneralWidget::appendApplicationArgument(const QString &argument)
{
QString completeArguments = m_ui->applicationArguments->text();
if (!completeArguments.isEmpty())
completeArguments.append(QLatin1Char(' '));
completeArguments.append(argument);
setLineEditBlocked(m_ui->applicationArguments, completeArguments);
}
QStringList BarDescriptorEditorGeneralWidget::applicationArguments() const
{
// TODO: Should probably handle "argument with spaces within quotes"
return m_ui->applicationArguments->text().split(QLatin1Char(' '));
}

16
src/plugins/qnx/bardescriptoreditorgeneralwidget.h
View File

@@ -49,19 +49,9 @@ public:
explicit BarDescriptorEditorGeneralWidget(QWidget *parent = 0);
~BarDescriptorEditorGeneralWidget();
void clear();
QString orientation() const;
void setOrientation(const QString &orientation);
QString chrome() const;
void setChrome(const QString &chrome);
bool transparent() const;
void setTransparent(bool transparent);
void appendApplicationArgument(const QString &argument);
QStringList applicationArguments() const;
protected:
void updateWidgetValue(BarDescriptorDocument::Tag tag, const QVariant &value);
void emitChanged(BarDescriptorDocument::Tag tag);
private:
Ui::BarDescriptorEditorGeneralWidget *m_ui;

49
src/plugins/qnx/bardescriptoreditorpackageinformationwidget.cpp
View File

@@ -45,55 +45,12 @@ BarDescriptorEditorPackageInformationWidget::BarDescriptorEditorPackageInformati
QRegExpValidator *versionNumberValidator = new QRegExpValidator(versionNumberRegExp, this);
m_ui->packageVersion->setValidator(versionNumberValidator);
connect(m_ui->packageId, SIGNAL(textChanged(QString)), this, SIGNAL(changed()));
connect(m_ui->packageVersion, SIGNAL(textChanged(QString)), this, SIGNAL(changed()));
connect(m_ui->packageBuildId, SIGNAL(textChanged(QString)), this, SIGNAL(changed()));
addSignalMapping(BarDescriptorDocument::id, m_ui->packageId, SIGNAL(textChanged(QString)));
addSignalMapping(BarDescriptorDocument::versionNumber, m_ui->packageVersion, SIGNAL(textChanged(QString)));
addSignalMapping(BarDescriptorDocument::buildId, m_ui->packageBuildId, SIGNAL(textChanged(QString)));
}
BarDescriptorEditorPackageInformationWidget::~BarDescriptorEditorPackageInformationWidget()
{
delete m_ui;
}
void BarDescriptorEditorPackageInformationWidget::clear()
{
setLineEditBlocked(m_ui->packageId, QString());
setLineEditBlocked(m_ui->packageVersion, QString());
setLineEditBlocked(m_ui->packageBuildId, QString());
}
QString BarDescriptorEditorPackageInformationWidget::packageId() const
{
return m_ui->packageId->text();
}
void BarDescriptorEditorPackageInformationWidget::setPackageId(const QString &packageId)
{
setLineEditBlocked(m_ui->packageId, packageId);
}
QString BarDescriptorEditorPackageInformationWidget::packageVersion() const
{
QString version = m_ui->packageVersion->text();
int pos = 0;
if (m_ui->packageVersion->validator()->validate(version, pos) == QValidator::Intermediate) {
if (version.endsWith(QLatin1Char('.')))
version = version.left(version.size() - 1);
}
return version;
}
void BarDescriptorEditorPackageInformationWidget::setPackageVersion(const QString &packageVersion)
{
setLineEditBlocked(m_ui->packageVersion, packageVersion);
}
QString BarDescriptorEditorPackageInformationWidget::packageBuildId() const
{
return m_ui->packageBuildId->text();
}
void BarDescriptorEditorPackageInformationWidget::setPackageBuildId(const QString &packageBuildId)
{
setLineEditBlocked(m_ui->packageBuildId, packageBuildId);
}

11
src/plugins/qnx/bardescriptoreditorpackageinformationwidget.h
View File

@@ -49,17 +49,6 @@ public:
explicit BarDescriptorEditorPackageInformationWidget(QWidget *parent = 0);
~BarDescriptorEditorPackageInformationWidget();
void clear();
QString packageId() const;
void setPackageId(const QString &packageId);
QString packageVersion() const;
void setPackageVersion(const QString &packageVersion);
QString packageBuildId() const;
void setPackageBuildId(const QString &packageBuildId);
private:
Ui::BarDescriptorEditorPackageInformationWidget *m_ui;
};

36
src/plugins/qnx/bardescriptoreditorpermissionswidget.cpp
View File

@@ -48,7 +48,8 @@ BarDescriptorEditorPermissionsWidget::BarDescriptorEditorPermissionsWidget(QWidg
connect(m_ui->selectAllPermissions, SIGNAL(clicked()), m_permissionsModel, SLOT(checkAll()));
connect(m_ui->deselectAllPermissions, SIGNAL(clicked()), m_permissionsModel, SLOT(uncheckAll()));
connect(m_permissionsModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SIGNAL(changed()));
addSignalMapping(BarDescriptorDocument::action, m_permissionsModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)));
}
BarDescriptorEditorPermissionsWidget::~BarDescriptorEditorPermissionsWidget()
@@ -56,13 +57,6 @@ BarDescriptorEditorPermissionsWidget::~BarDescriptorEditorPermissionsWidget()
delete m_ui;
}
void BarDescriptorEditorPermissionsWidget::clear()
{
disconnect(m_permissionsModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SIGNAL(changed()));
m_permissionsModel->uncheckAll();
connect(m_permissionsModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SIGNAL(changed()));
}
QStringList BarDescriptorEditorPermissionsWidget::checkedPermissions() const
{
return m_permissionsModel->checkedIdentifiers();
@@ -70,7 +64,29 @@ QStringList BarDescriptorEditorPermissionsWidget::checkedPermissions() const
void BarDescriptorEditorPermissionsWidget::checkPermission(const QString &identifier)
{
disconnect(m_permissionsModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SIGNAL(changed()));
blockSignalMapping(BarDescriptorDocument::action);
m_permissionsModel->checkPermission(identifier);
connect(m_permissionsModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SIGNAL(changed()));
unblockSignalMapping(BarDescriptorDocument::action);
}
void BarDescriptorEditorPermissionsWidget::updateWidgetValue(BarDescriptorDocument::Tag tag, const QVariant &value)
{
if (tag != BarDescriptorDocument::action) {
BarDescriptorEditorAbstractPanelWidget::updateWidgetValue(tag, value);
return;
}
QStringList permissions = value.toStringList();
Q_FOREACH (const QString &permission, permissions)
checkPermission(permission);
}
void BarDescriptorEditorPermissionsWidget::emitChanged(BarDescriptorDocument::Tag tag)
{
if (tag != BarDescriptorDocument::action) {
BarDescriptorEditorAbstractPanelWidget::emitChanged(tag);
return;
}
emit changed(tag, checkedPermissions());
}

6
src/plugins/qnx/bardescriptoreditorpermissionswidget.h
View File

@@ -51,12 +51,14 @@ public:
explicit BarDescriptorEditorPermissionsWidget(QWidget *parent = 0);
~BarDescriptorEditorPermissionsWidget();
void clear();
protected:
void updateWidgetValue(BarDescriptorDocument::Tag tag, const QVariant &value);
void emitChanged(BarDescriptorDocument::Tag tag);
private:
QStringList checkedPermissions() const;
void checkPermission(const QString &identifier);
private:
Ui::BarDescriptorEditorPermissionsWidget *m_ui;
BarDescriptorPermissionsModel *m_permissionsModel;

137
src/plugins/qnx/bardescriptoreditorwidget.cpp
View File

@@ -44,9 +44,12 @@
#include <coreplugin/icore.h>
#include <projectexplorer/iprojectproperties.h>
#include <projectexplorer/projectwindow.h>
#include <projectexplorer/task.h>
#include <projectexplorer/taskhub.h>
#include <texteditor/plaintexteditor.h>
#include <texteditor/texteditorsettings.h>
#include <texteditor/texteditorconstants.h>
#include <utils/qtcassert.h>
using namespace Qnx;
using namespace Qnx::Internal;
@@ -54,7 +57,6 @@ using namespace Qnx::Internal;
BarDescriptorEditorWidget::BarDescriptorEditorWidget(BarDescriptorEditor *editor, QWidget *parent)
: QStackedWidget(parent)
, m_editor(editor)
, m_dirty(false)
{
Core::IContext *myContext = new Core::IContext(this);
myContext->setWidget(this);
@@ -67,6 +69,25 @@ BarDescriptorEditorWidget::BarDescriptorEditorWidget(BarDescriptorEditor *editor
initSourcePage();
setCurrentIndex(0);
connect(m_entryPointWidget, SIGNAL(changed(BarDescriptorDocument::Tag,QVariant)), barDescriptorDocument(), SLOT(setValue(BarDescriptorDocument::Tag,QVariant)));
connect(m_packageInformationWidget, SIGNAL(changed(BarDescriptorDocument::Tag,QVariant)), barDescriptorDocument(), SLOT(setValue(BarDescriptorDocument::Tag,QVariant)));
connect(m_authorInformationWidget, SIGNAL(changed(BarDescriptorDocument::Tag,QVariant)), barDescriptorDocument(), SLOT(setValue(BarDescriptorDocument::Tag,QVariant)));
connect(m_generalWidget, SIGNAL(changed(BarDescriptorDocument::Tag,QVariant)), barDescriptorDocument(), SLOT(setValue(BarDescriptorDocument::Tag,QVariant)));
connect(m_permissionsWidget, SIGNAL(changed(BarDescriptorDocument::Tag,QVariant)), barDescriptorDocument(), SLOT(setValue(BarDescriptorDocument::Tag,QVariant)));
connect(m_environmentWidget, SIGNAL(changed(BarDescriptorDocument::Tag,QVariant)), barDescriptorDocument(), SLOT(setValue(BarDescriptorDocument::Tag,QVariant)));
connect(m_assetsWidget, SIGNAL(changed(BarDescriptorDocument::Tag,QVariant)), barDescriptorDocument(), SLOT(setValue(BarDescriptorDocument::Tag,QVariant)));
connect(barDescriptorDocument(), SIGNAL(changed(BarDescriptorDocument::Tag,QVariant)), m_entryPointWidget, SLOT(setValue(BarDescriptorDocument::Tag,QVariant)));
connect(barDescriptorDocument(), SIGNAL(changed(BarDescriptorDocument::Tag,QVariant)), m_packageInformationWidget, SLOT(setValue(BarDescriptorDocument::Tag,QVariant)));
connect(barDescriptorDocument(), SIGNAL(changed(BarDescriptorDocument::Tag,QVariant)), m_authorInformationWidget, SLOT(setValue(BarDescriptorDocument::Tag,QVariant)));
connect(barDescriptorDocument(), SIGNAL(changed(BarDescriptorDocument::Tag,QVariant)), m_generalWidget, SLOT(setValue(BarDescriptorDocument::Tag,QVariant)));
connect(barDescriptorDocument(), SIGNAL(changed(BarDescriptorDocument::Tag,QVariant)), m_permissionsWidget, SLOT(setValue(BarDescriptorDocument::Tag,QVariant)));
connect(barDescriptorDocument(), SIGNAL(changed(BarDescriptorDocument::Tag,QVariant)), m_environmentWidget, SLOT(setValue(BarDescriptorDocument::Tag,QVariant)));
connect(barDescriptorDocument(), SIGNAL(changed(BarDescriptorDocument::Tag,QVariant)), m_assetsWidget, SLOT(setValue(BarDescriptorDocument::Tag,QVariant)));
connect(m_xmlSourceWidget, SIGNAL(textChanged()), this, SLOT(updateDocumentContent()));
connect(barDescriptorDocument(), SIGNAL(changed()), this, SLOT(updateSourceView()));
}
void BarDescriptorEditorWidget::initGeneralPage()
@@ -95,10 +116,6 @@ void BarDescriptorEditorWidget::initGeneralPage()
authorInformationPanel->setDisplayName(tr("Author Information"));
authorInformationPanel->setWidget(m_authorInformationWidget);
generalPanel->addPropertiesPanel(authorInformationPanel);
connect(m_entryPointWidget, SIGNAL(changed()), this, SLOT(setDirty()));
connect(m_packageInformationWidget, SIGNAL(changed()), this, SLOT(setDirty()));
connect(m_authorInformationWidget, SIGNAL(changed()), this, SLOT(setDirty()));
}
void BarDescriptorEditorWidget::initApplicationPage()
@@ -127,10 +144,6 @@ void BarDescriptorEditorWidget::initApplicationPage()
environmentPanel->setDisplayName(tr("Environment"));
environmentPanel->setWidget(m_environmentWidget);
applicationPanel->addPropertiesPanel(environmentPanel);
connect(m_generalWidget, SIGNAL(changed()), this, SLOT(setDirty()));
connect(m_permissionsWidget, SIGNAL(changed()), this, SLOT(setDirty()));
connect(m_environmentWidget, SIGNAL(changed()), this, SLOT(setDirty()));
}
void BarDescriptorEditorWidget::initAssetsPage()
@@ -145,8 +158,6 @@ void BarDescriptorEditorWidget::initAssetsPage()
assetsPropertiesPanel->setWidget(m_assetsWidget);
assetsPanel->addPropertiesPanel(assetsPropertiesPanel);
connect(m_assetsWidget, SIGNAL(changed()), this, SLOT(setDirty()));
m_entryPointWidget->setAssetsModel(m_assetsWidget->assetsModel());
connect(m_entryPointWidget, SIGNAL(imageAdded(QString)), m_assetsWidget, SLOT(addAsset(QString)));
connect(m_entryPointWidget, SIGNAL(imageRemoved(QString)), m_assetsWidget, SLOT(removeAsset(QString)));
@@ -159,7 +170,6 @@ void BarDescriptorEditorWidget::initSourcePage()
TextEditor::TextEditorSettings::initializeEditor(m_xmlSourceWidget);
m_xmlSourceWidget->configure(QLatin1String(Constants::QNX_BAR_DESCRIPTOR_MIME_TYPE));
connect(m_xmlSourceWidget, SIGNAL(textChanged()), this, SLOT(setDirty()));
}
void BarDescriptorEditorWidget::initPanelSize(ProjectExplorer::PanelsWidget *panelsWidget)
@@ -168,46 +178,6 @@ void BarDescriptorEditorWidget::initPanelSize(ProjectExplorer::PanelsWidget *pan
panelsWidget->widget()->setMinimumWidth(0);
}
Core::IEditor *BarDescriptorEditorWidget::editor() const
{
return m_editor;
}
BarDescriptorEditorPackageInformationWidget *BarDescriptorEditorWidget::packageInformationWidget() const
{
return m_packageInformationWidget;
}
BarDescriptorEditorAuthorInformationWidget *BarDescriptorEditorWidget::authorInformationWidget() const
{
return m_authorInformationWidget;
}
BarDescriptorEditorEntryPointWidget *BarDescriptorEditorWidget::entryPointWidget() const
{
return m_entryPointWidget;
}
BarDescriptorEditorGeneralWidget *BarDescriptorEditorWidget::generalWidget() const
{
return m_generalWidget;
}
BarDescriptorEditorPermissionsWidget *BarDescriptorEditorWidget::permissionsWidget() const
{
return m_permissionsWidget;
}
BarDescriptorEditorEnvironmentWidget *BarDescriptorEditorWidget::environmentWidget() const
{
return m_environmentWidget;
}
BarDescriptorEditorAssetsWidget *BarDescriptorEditorWidget::assetsWidget() const
{
return m_assetsWidget;
}
TextEditor::BaseTextEditorWidget *BarDescriptorEditorWidget::sourceWidget() const
{
return m_xmlSourceWidget;
@@ -216,51 +186,44 @@ TextEditor::BaseTextEditorWidget *BarDescriptorEditorWidget::sourceWidget() cons
void BarDescriptorEditorWidget::setFilePath(const QString &filePath)
{
Core::IDocument *doc = m_xmlSourceWidget->baseTextDocument();
if (doc) {
if (doc)
doc->setFilePath(filePath);
// setFilePath() call leads to a textChanged() signal emitted
// and therefore having this editor-widget to become dirty
// therefore we have to explicitly unset the dirty flag
setDirty(false);
}
}
QString BarDescriptorEditorWidget::xmlSource() const
void BarDescriptorEditorWidget::updateDocumentContent()
{
return m_xmlSourceWidget->toPlainText();
ProjectExplorer::TaskHub::clearTasks(Constants::QNX_TASK_CATEGORY_BARDESCRIPTOR);
QString errorMsg;
int errorLine;
disconnect(barDescriptorDocument(), SIGNAL(changed()), this, SLOT(updateSourceView()));
bool result = barDescriptorDocument()->loadContent(m_xmlSourceWidget->toPlainText(), true, &errorMsg, &errorLine);
connect(barDescriptorDocument(), SIGNAL(changed()), this, SLOT(updateSourceView()));
if (!result) {
ProjectExplorer::TaskHub::addTask(ProjectExplorer::Task::Error, errorMsg, Constants::QNX_TASK_CATEGORY_BARDESCRIPTOR,
Utils::FileName::fromString(barDescriptorDocument()->filePath()), errorLine);
ProjectExplorer::TaskHub::requestPopup();
}
}
void BarDescriptorEditorWidget::setXmlSource(const QString &xmlSource)
void BarDescriptorEditorWidget::updateSourceView()
{
bool blocked = m_xmlSourceWidget->blockSignals(true);
m_xmlSourceWidget->setPlainText(xmlSource);
int line;
int column;
int position = m_xmlSourceWidget->position();
m_xmlSourceWidget->convertPosition(position, &line, &column);
m_xmlSourceWidget->setPlainText(barDescriptorDocument()->xmlSource());
m_xmlSourceWidget->gotoLine(line, column);
m_xmlSourceWidget->blockSignals(blocked);
}
bool BarDescriptorEditorWidget::isDirty() const
BarDescriptorDocument *BarDescriptorEditorWidget::barDescriptorDocument() const
{
return m_dirty;
}
void BarDescriptorEditorWidget::clear()
{
m_entryPointWidget->clear();
m_packageInformationWidget->clear();
m_authorInformationWidget->clear();
m_generalWidget->clear();
m_permissionsWidget->clear();
m_environmentWidget->clear();
m_assetsWidget->clear();
bool blocked = m_xmlSourceWidget->blockSignals(true);
m_xmlSourceWidget->clear();
m_xmlSourceWidget->blockSignals(blocked);
}
void BarDescriptorEditorWidget::setDirty(bool dirty)
{
m_dirty = dirty;
emit changed();
return qobject_cast<BarDescriptorDocument*>(m_editor->document());
}

30
src/plugins/qnx/bardescriptoreditorwidget.h
View File

@@ -68,34 +68,20 @@ class BarDescriptorEditorWidget : public QStackedWidget
public:
explicit BarDescriptorEditorWidget(BarDescriptorEditor *editor, QWidget *parent = 0);
Core::IEditor *editor() const;
BarDescriptorEditorEntryPointWidget *entryPointWidget() const;
BarDescriptorEditorPackageInformationWidget *packageInformationWidget() const;
BarDescriptorEditorAuthorInformationWidget *authorInformationWidget() const;
BarDescriptorEditorGeneralWidget *generalWidget() const;
BarDescriptorEditorPermissionsWidget *permissionsWidget() const;
BarDescriptorEditorEnvironmentWidget *environmentWidget() const;
BarDescriptorEditorAssetsWidget *assetsWidget() const;
TextEditor::BaseTextEditorWidget *sourceWidget() const;
void setFilePath(const QString &filePath);
QString xmlSource() const;
void setXmlSource(const QString &xmlSource);
bool isDirty() const;
void clear();
public slots:
void setDirty(bool dirty = true);
signals:
void changed();
void changed(BarDescriptorDocument::Tag tag, const QVariant &value);
private slots:
void updateDocumentContent();
void updateSourceView();
private:
BarDescriptorDocument *barDescriptorDocument() const;
void initGeneralPage();
void initApplicationPage();
void initAssetsPage();
@@ -104,8 +90,6 @@ private:
Core::IEditor *m_editor;
bool m_dirty;
// New UI
BarDescriptorEditorEntryPointWidget *m_entryPointWidget;
BarDescriptorEditorPackageInformationWidget *m_packageInformationWidget;

2
src/plugins/qnx/qnx.pro
View File

@@ -57,7 +57,6 @@ SOURCES += qnxplugin.cpp \
bardescriptoreditor.cpp \
bardescriptoreditorwidget.cpp \
bardescriptordocument.cpp \
bardescriptordocumentnodehandlers.cpp \
bardescriptorpermissionsmodel.cpp \
blackberrykeyswidget.cpp \
blackberrykeyspage.cpp \
@@ -156,7 +155,6 @@ HEADERS += qnxplugin.h\
bardescriptoreditor.h \
bardescriptoreditorwidget.h \
bardescriptordocument.h \
bardescriptordocumentnodehandlers.h \
bardescriptorpermissionsmodel.h \
blackberrykeyswidget.h \
blackberrykeyspage.h \

2
src/plugins/qnx/qnx.qbs
View File

@@ -20,8 +20,6 @@ QtcPlugin {
files: [
"bardescriptordocument.cpp",
"bardescriptordocument.h",
"bardescriptordocumentnodehandlers.cpp",
"bardescriptordocumentnodehandlers.h",
"bardescriptoreditor.cpp",
"bardescriptoreditor.h",
"bardescriptoreditorabstractpanelwidget.cpp",

197
src/plugins/qnx/qnxplugin.cpp
View File

@@ -136,4 +136,201 @@ ExtensionSystem::IPlugin::ShutdownFlag QNXPlugin::aboutToShutdown()
return SynchronousShutdown;
}
#ifdef WITH_TESTS
#include <QTest>
#include "bardescriptordocument.h"
void QNXPlugin::testBarDescriptorDocumentSetValue_data()
{
QTest::addColumn<BarDescriptorDocument::Tag>("tag");
QTest::addColumn<QVariant>("value");
QTest::addColumn<QString>("baseXml");
QTest::addColumn<QString>("xml");
QTest::addColumn<bool>("compareResultValue");
QTest::newRow("new-id") << BarDescriptorDocument::id
<< QVariant(QString::fromLatin1("my-application-id"))
<< QString::fromLatin1("<?xml version='1.0' encoding='UTF-8' standalone='no'?>\n"
"<qnx xmlns=\"http://www.qnx.com/schemas/application/1.0\"/>\n")
<< QString::fromLatin1("<?xml version='1.0' encoding='UTF-8' standalone='no'?>\n"
"<qnx xmlns=\"http://www.qnx.com/schemas/application/1.0\">\n"
" <id>my-application-id</id>\n"
"</qnx>\n")
<< true;
QTest::newRow("changed-id") << BarDescriptorDocument::id
<< QVariant(QString::fromLatin1("my-application-id"))
<< QString::fromLatin1("<?xml version='1.0' encoding='UTF-8' standalone='no'?>\n"
"<qnx xmlns=\"http://www.qnx.com/schemas/application/1.0\">\n"
" <id>some-application-id</id>\n"
"</qnx>\n")
<< QString::fromLatin1("<?xml version='1.0' encoding='UTF-8' standalone='no'?>\n"
"<qnx xmlns=\"http://www.qnx.com/schemas/application/1.0\">\n"
" <id>my-application-id</id>\n"
"</qnx>\n")
<< true;
QTest::newRow("removed-id") << BarDescriptorDocument::id
<< QVariant(QString::fromLatin1(""))
<< QString::fromLatin1("<?xml version='1.0' encoding='UTF-8' standalone='no'?>\n"
"<qnx xmlns=\"http://www.qnx.com/schemas/application/1.0\">\n"
" <id>some-application-id</id>\n"
"</qnx>\n")
<< QString::fromLatin1("<?xml version='1.0' encoding='UTF-8' standalone='no'?>\n"
"<qnx xmlns=\"http://www.qnx.com/schemas/application/1.0\"/>\n")
<< true;
QStringList splashScreens;
splashScreens << QLatin1String("image1.png")
<< QLatin1String("image2.png");
QTest::newRow("new-splashScreens") << BarDescriptorDocument::splashScreens
<< QVariant(splashScreens)
<< QString::fromLatin1("<?xml version='1.0' encoding='UTF-8' standalone='no'?>\n"
"<qnx xmlns=\"http://www.qnx.com/schemas/application/1.0\"/>\n")
<< QString::fromLatin1("<?xml version='1.0' encoding='UTF-8' standalone='no'?>\n"
"<qnx xmlns=\"http://www.qnx.com/schemas/application/1.0\">\n"
" <splashScreens>\n"
" <image>image1.png</image>\n"
" <image>image2.png</image>\n"
" </splashScreens>\n"
"</qnx>\n")
<< true;
QTest::newRow("changed-splashScreens") << BarDescriptorDocument::splashScreens
<< QVariant(splashScreens)
<< QString::fromLatin1("<?xml version='1.0' encoding='UTF-8' standalone='no'?>\n"
"<qnx xmlns=\"http://www.qnx.com/schemas/application/1.0\">\n"
" <splashScreens>\n"
" <image>image3.png</image>\n"
" <image>image4.png</image>\n"
" </splashScreens>\n"
"</qnx>\n")
<< QString::fromLatin1("<?xml version='1.0' encoding='UTF-8' standalone='no'?>\n"
"<qnx xmlns=\"http://www.qnx.com/schemas/application/1.0\">\n"
" <splashScreens>\n"
" <image>image1.png</image>\n"
" <image>image2.png</image>\n"
" </splashScreens>\n"
"</qnx>\n")
<< true;
QTest::newRow("removed-splashScreens") << BarDescriptorDocument::splashScreens
<< QVariant(QStringList())
<< QString::fromLatin1("<?xml version='1.0' encoding='UTF-8' standalone='no'?>\n"
"<qnx xmlns=\"http://www.qnx.com/schemas/application/1.0\">\n"
" <splashScreens>\n"
" <image>image1.png</image>\n"
" <image>image2.png</image>\n"
" </splashScreens>\n"
"</qnx>\n")
<< QString::fromLatin1("<?xml version='1.0' encoding='UTF-8' standalone='no'?>\n"
"<qnx xmlns=\"http://www.qnx.com/schemas/application/1.0\"/>\n")
<< true;
BarDescriptorAsset asset1;
asset1.source = QLatin1String("/path/to/file");
asset1.destination = QLatin1String("file");
asset1.entry = false;
BarDescriptorAsset asset2;
asset2.source = QLatin1String("/path/to/file2");
asset2.destination = QLatin1String("file2");
asset2.entry = false; // Cannot test "true", as "type" and "entry" attributes show up in seemingly arbitrary order
BarDescriptorAssetList assetList1;
assetList1 << asset1 << asset2;
QVariant assets;
assets.setValue(assetList1);
QTest::newRow("new-assets") << BarDescriptorDocument::asset
<< assets
<< QString::fromLatin1("<?xml version='1.0' encoding='UTF-8' standalone='no'?>\n"
"<qnx xmlns=\"http://www.qnx.com/schemas/application/1.0\"/>\n")
<< QString::fromLatin1("<?xml version='1.0' encoding='UTF-8' standalone='no'?>\n"
"<qnx xmlns=\"http://www.qnx.com/schemas/application/1.0\">\n"
" <asset path=\"/path/to/file\">file</asset>\n"
" <asset path=\"/path/to/file2\">file2</asset>\n"
"</qnx>\n")
<< false;
asset2.destination = QLatin1String("file3");
BarDescriptorAssetList assetList2;
assetList2 << asset1 << asset2;
assets.setValue(assetList2);
QTest::newRow("changed-assets") << BarDescriptorDocument::asset
<< assets
<< QString::fromLatin1("<?xml version='1.0' encoding='UTF-8' standalone='no'?>\n"
"<qnx xmlns=\"http://www.qnx.com/schemas/application/1.0\">\n"
" <asset path=\"/path/to/file\">file</asset>\n"
" <asset path=\"/path/to/file2\">file2</asset>\n"
"</qnx>\n")
<< QString::fromLatin1("<?xml version='1.0' encoding='UTF-8' standalone='no'?>\n"
"<qnx xmlns=\"http://www.qnx.com/schemas/application/1.0\">\n"
" <asset path=\"/path/to/file\">file</asset>\n"
" <asset path=\"/path/to/file2\">file3</asset>\n"
"</qnx>\n")
<< false;
QTest::newRow("maintain-position") << BarDescriptorDocument::id
<< QVariant(QString::fromLatin1("my-application-id"))
<< QString::fromLatin1("<?xml version='1.0' encoding='UTF-8' standalone='no'?>\n"
"<qnx xmlns=\"http://www.qnx.com/schemas/application/1.0\">\n"
" <asset path=\"/path/to/file\">file</asset>\n"
" <asset path=\"/path/to/file2\">file2</asset>\n"
" <id>some-application-id</id>\n"
" <splashScreens>\n"
" <image>image1.png</image>\n"
" <image>image2.png</image>\n"
" </splashScreens>\n"
"</qnx>\n")
<< QString::fromLatin1("<?xml version='1.0' encoding='UTF-8' standalone='no'?>\n"
"<qnx xmlns=\"http://www.qnx.com/schemas/application/1.0\">\n"
" <asset path=\"/path/to/file\">file</asset>\n"
" <asset path=\"/path/to/file2\">file2</asset>\n"
" <id>my-application-id</id>\n"
" <splashScreens>\n"
" <image>image1.png</image>\n"
" <image>image2.png</image>\n"
" </splashScreens>\n"
"</qnx>\n")
<< true;
QTest::newRow("removed-icon") << BarDescriptorDocument::icon
<< QVariant(QString())
<< QString::fromLatin1("<?xml version='1.0' encoding='UTF-8' standalone='no'?>\n"
"<qnx xmlns=\"http://www.qnx.com/schemas/application/1.0\">\n"
" <icon>\n"
" <image>icon1.png</image>\n"
" </icon>\n"
"</qnx>\n")
<< QString::fromLatin1("<?xml version='1.0' encoding='UTF-8' standalone='no'?>\n"
"<qnx xmlns=\"http://www.qnx.com/schemas/application/1.0\"/>\n")
<< true;
}
void QNXPlugin::testBarDescriptorDocumentSetValue()
{
QFETCH(BarDescriptorDocument::Tag, tag);
QFETCH(QVariant, value);
QFETCH(QString, baseXml);
QFETCH(QString, xml);
QFETCH(bool, compareResultValue);
BarDescriptorDocument doc;
doc.loadContent(baseXml, false);
QCOMPARE(doc.xmlSource(), baseXml);
doc.setValue(tag, value);
QCOMPARE(doc.xmlSource(), xml);
QCOMPARE(doc.isModified(), true);
if (compareResultValue)
QCOMPARE(doc.value(tag), value);
}
#endif
Q_EXPORT_PLUGIN2(QNX, QNXPlugin)

6
src/plugins/qnx/qnxplugin.h
View File

@@ -49,6 +49,12 @@ public:
bool initialize(const QStringList &arguments, QString *errorString);
void extensionsInitialized();
ShutdownFlag aboutToShutdown();
#ifdef WITH_TESTS
private slots:
void testBarDescriptorDocumentSetValue_data();
void testBarDescriptorDocumentSetValue();
#endif
};
} // namespace Internal