qtcreator-tizen-plugin/tizengbskitinformation.cpp

#include "tizengbskitinformation.h"
#include "tizenconstants.h"
#include "tizendebug.h"

#include <utils/elidinglabel.h>
#include <utils/environment.h>
#include <utils/pathchooser.h>

#include <QPushButton>
#include <QDir>
#include <QVBoxLayout>
#include <QFormLayout>
#include <QDialogButtonBox>
#include <QDialog>
#include <QLineEdit>

using namespace ProjectExplorer;
using namespace Utils;

namespace Tizen {
namespace Internal {

static const char *gbsKitInformationId = "Tizen.Gbs.Information";
static const char *gbsProfileId = "Tizen.Gbs.Information.Profile";
static const char *gbsArchitectureId = "Tizen.Gbs.Information.Architecture";
static const char *gbsBuildrootId = "Tizen.Gbs.Information.Buildroot";
static const char *gbsConfigFileId = "Tizen.Gbs.Information.ConfigFile";
static const char *gbsAdditionalParametersId = "Tizen.Gbs.Information.AdditionalParameters";

TizenGbsKitInformation::TizenGbsKitInformation()
{
    setId(TizenGbsKitInformation::id());
    setPriority(3000);
}

QVariant TizenGbsKitInformation::defaultValue(ProjectExplorer::Kit *kit) const
{
    return autoDetect(kit).toString();
}

QList<ProjectExplorer::Task> TizenGbsKitInformation::validate(const ProjectExplorer::Kit *) const
{
    return QList<Task>();
}

ProjectExplorer::KitInformation::ItemList TizenGbsKitInformation::toUserOutput(const ProjectExplorer::Kit *kit) const
{
    return KitInformation::ItemList()
            << qMakePair(tr("Gbs binary"), TizenGbsKitInformation::gbsPath(kit).toString());
}

ProjectExplorer::KitConfigWidget *TizenGbsKitInformation::createConfigWidget(ProjectExplorer::Kit * kit) const
{
    return new TizenGbsKitInformationWidget(kit, this);
}

FileName TizenGbsKitInformation::gbsPath(const ProjectExplorer::Kit *kit)
{
    return  FileName::fromString(kit->value(TizenGbsKitInformation::id()).toString());
}

FileName TizenGbsKitInformation::autoDetect(Kit *)
{
    QStringList path = Environment::systemEnvironment().path();
    foreach (const QString &base, path) {
        QDir dir(base);
        QLatin1Literal gbs("gbs");
        if (dir.exists(gbs)) {
            return FileName::fromString(dir.absoluteFilePath(gbs));
        }
    }
    return FileName();
}

QString TizenGbsKitInformation::gbsProfile(Kit *kit)
{
    return kit->value(gbsProfileId).toString();
}

QString TizenGbsKitInformation::gbsArchitecture(Kit *kit)
{
    return kit->value(gbsArchitectureId).toString();
}

FileName TizenGbsKitInformation::gbsBuildroot(Kit *kit)
{
     return  FileName::fromString(kit->value(gbsBuildrootId).toString());
}

FileName TizenGbsKitInformation::gbsConfigFile(Kit *kit)
{
    return  FileName::fromString(kit->value(gbsConfigFileId).toString());
}

QString TizenGbsKitInformation::gbsAdditionalParameters(Kit *kit)
{
    return kit->value(gbsArchitectureId).toString();
}

Core::Id TizenGbsKitInformation::id()
{
    return Core::Id(gbsKitInformationId);
}

void TizenGbsKitInformation::setGbsPath(Kit *kit, Utils::FileName gbsPath)
{
    kit->setValue(TizenGbsKitInformation::id(), gbsPath.toString());
}

void TizenGbsKitInformation::setGbsProfile(Kit *kit, QString profileName)
{
    kit->setValue(Core::Id(gbsProfileId), profileName);
}

void TizenGbsKitInformation::setGbsArchitecture(Kit *kit, QString architecture)
{
    kit->setValue(Core::Id(gbsArchitectureId), architecture);
}

void TizenGbsKitInformation::setGbsBuildroot(Kit *kit, QString buildroot)
{
    kit->setValue(Core::Id(gbsBuildrootId), buildroot);
}

void TizenGbsKitInformation::setGbsConfigFile(Kit *kit, QString configFilePath)
{
    kit->setValue(Core::Id(gbsConfigFileId), configFilePath);
}

void TizenGbsKitInformation::setGbsAdditionalParameters(Kit *kit, QString additionalParameters)
{
    kit->setValue(Core::Id(gbsAdditionalParametersId), additionalParameters);
}

TizenGbsKitInformationWidget::TizenGbsKitInformationWidget(ProjectExplorer::Kit *kit, const ProjectExplorer::KitInformation *ki):
    KitConfigWidget(kit, ki),
    m_label(new ElidingLabel),
    m_button(new QPushButton(tr("Manage...")))
{
    m_label->setWordWrap(true);
    connect(m_button, SIGNAL(clicked()), this, SLOT(showDialog()));
    refresh();
}

TizenGbsKitInformationWidget::~TizenGbsKitInformationWidget()
{
    delete m_label;
    delete m_button;
}

QString TizenGbsKitInformationWidget::displayName() const
{
    return tr("Gbs build configuration");
}

QString TizenGbsKitInformationWidget::toolTip() const
{
    return tr("Gbs binary to use with this kit");
}

void TizenGbsKitInformationWidget::makeReadOnly()
{
    m_button->setEnabled(false);
}

void TizenGbsKitInformationWidget::refresh()
{
    QString gbsPath = TizenGbsKitInformation::gbsPath(m_kit).toString();
    QString profile = TizenGbsKitInformation::gbsProfile(m_kit);
    QString architecture = TizenGbsKitInformation::gbsArchitecture(m_kit);
    QString buildroot = TizenGbsKitInformation::gbsBuildroot(m_kit).toString();
    QString configFile = TizenGbsKitInformation::gbsConfigFile(m_kit).toString();
    QString additionalParameters = TizenGbsKitInformation::gbsAdditionalParameters(m_kit);

    QStringList result;
    result << gbsPath << QLatin1Literal("build");
    if (!configFile.isEmpty())
        result << QLatin1Literal("-D") << configFile;
    if (!buildroot.isEmpty())
        result << QLatin1Literal("-B") << buildroot;
    if (!profile.isEmpty())
        result << QLatin1Literal("-P") << profile;
    if (!architecture.isEmpty())
        result << QLatin1Literal("-C") << architecture;
    if (!additionalParameters.isEmpty())
        result << additionalParameters;

    m_label->setText(result.join(QLatin1Literal(" ")));
}

bool TizenGbsKitInformationWidget::visibleInKit()
{
    return DeviceTypeKitInformation::deviceTypeId(m_kit) == Constants::TIZEN_DEVICE_TYPE;
}

QWidget *TizenGbsKitInformationWidget::mainWidget() const
{
    return m_label;
}

QWidget *TizenGbsKitInformationWidget::buttonWidget() const
{
    return m_button;
}

void TizenGbsKitInformationWidget::showDialog()
{
    QDialog dialog;
    QVBoxLayout *layout = new QVBoxLayout(&dialog);
    QFormLayout *formLayout = new QFormLayout;
    formLayout->setFieldGrowthPolicy(QFormLayout::AllNonFixedFieldsGrow);

    QLabel *binaryLabel = new QLabel(tr("&Gbs binary:"), &dialog);
    PathChooser *chooser = new PathChooser(&dialog);
    chooser->setExpectedKind(PathChooser::ExistingCommand);
    chooser->setPath(TizenGbsKitInformation::gbsPath(m_kit).toString());
    binaryLabel->setBuddy(chooser);
    formLayout->addRow(binaryLabel, chooser);

    QLabel *profileLabel = new QLabel(tr("&Profile:"), &dialog);
    QLineEdit *profileLineEdit = new QLineEdit(TizenGbsKitInformation::gbsProfile(m_kit), &dialog);
    profileLabel->setBuddy(profileLineEdit);
    formLayout->addRow(profileLabel, profileLineEdit);

    layout->addLayout(formLayout);

    QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal, &dialog);
    connect(buttonBox, SIGNAL(accepted()), &dialog, SLOT(accept()));
    connect(buttonBox, SIGNAL(rejected()), &dialog, SLOT(reject()));
    layout->addWidget(buttonBox);

    dialog.setWindowTitle(tr("Gbs for \"%1\"").arg(m_kit->displayName()));

    if (dialog.exec() == QDialog::Accepted) {
        TizenGbsKitInformation::setGbsPath(m_kit, chooser->fileName());
        TizenGbsKitInformation::setGbsProfile(m_kit, profileLineEdit->text());
    }
}


} //namespace Internal
} //namespace Tizen