Core::GeneratedFiles
dryRunCustomWizardGeneratorScript(const QString &targetPath,
const QStringList &script,
const QList<GeneratorScriptArgument> &arguments,
const QMap<QString, QString> &fieldMap,
QString *errorMessage)
{
// Run in temporary directory as the target path may not exist yet.
QString stdOut;
if (!runGenerationScriptHelper(QDir::tempPath(), script, arguments, true,
fieldMap, &stdOut, errorMessage))
return Core::GeneratedFiles();
Core::GeneratedFiles files;
// Parse the output consisting of lines with ',' separated tokens.
// (file name + attributes matching those of the <file> element)
foreach (const QString &line, stdOut.split(QLatin1Char('\n'))) {
const QString trimmed = line.trimmed();
if (!trimmed.isEmpty()) {
Core::GeneratedFile file;
Core::GeneratedFile::Attributes attributes = Core::GeneratedFile::CustomGeneratorAttribute;
const QStringList tokens = line.split(QLatin1Char(','));
const int count = tokens.count();
for (int i = 0; i < count; i++) {
const QString &token = tokens.at(i);
if (i) {
if (token == QLatin1String(customWizardFileOpenEditorAttributeC))
attributes |= Core::GeneratedFile::OpenEditorAttribute;
else if (token == QLatin1String(customWizardFileOpenProjectAttributeC))
attributes |= Core::GeneratedFile::OpenProjectAttribute;
} else {
// Token 0 is file name. Wizard wants native names.
// Expand to full path if relative
const QFileInfo fileInfo(token);
const QString fullPath =
fileInfo.isAbsolute() ?
token :
(targetPath + QLatin1Char('/') + token);
file.setPath(fullPath);
}
}
file.setAttributes(attributes);
files.push_back(file);
}
}
if (CustomWizard::verbose()) {
QDebug nospace = qDebug().nospace();
nospace << script << " generated:\n";
foreach (const Core::GeneratedFile &f, files)
nospace << ' ' << f.path() << f.attributes() << '\n';
}
return files;
}
Core::GeneratedFiles Html5App::generateFiles(QString *errorMessage) const
{
Core::GeneratedFiles files = AbstractMobileApp::generateFiles(errorMessage);
if (m_mainHtmlMode == ModeGenerate) {
files.append(file(generateFile(Html5AppGeneratedFileInfo::MainHtmlFile, errorMessage), path(MainHtml)));
files.last().setAttributes(Core::GeneratedFile::OpenEditorAttribute);
}
files.append(file(generateFile(Html5AppGeneratedFileInfo::AppViewerPriFile, errorMessage), path(AppViewerPri)));
files.append(file(generateFile(Html5AppGeneratedFileInfo::AppViewerCppFile, errorMessage), path(AppViewerCpp)));
files.append(file(generateFile(Html5AppGeneratedFileInfo::AppViewerHFile, errorMessage), path(AppViewerH)));
return files;
}
bool QtWizard::postGenerateFiles(const Core::GeneratedFiles &l, QString *errorMessage)
{
// Post-Generate: Open the project
const QString proFileName = l.back().path();
if (!m_projectExplorer->openProject(proFileName)) {
*errorMessage = tr("The project %1 could not be opened.").arg(proFileName);
return false;
}
return true;
}
Core::GeneratedFiles DProjectWizard::generateFiles(const QWizard *w,
QString *errorMessage) const
{
Q_UNUSED(errorMessage)
const DProjectWizardDialog *wizard = qobject_cast<const DProjectWizardDialog *>(w);
const QString projectName = wizard->projectName();
const QDir dir(wizard->path());
const QString projectFileName = QFileInfo(dir, projectName + QLatin1String(".qcd")).absoluteFilePath();
Core::GeneratedFile generatedProjectFile(projectFileName);
generatedProjectFile.setContents(QLatin1String("[Files]\n"));
generatedProjectFile.setAttributes(Core::GeneratedFile::OpenProjectAttribute);
Core::GeneratedFiles files;
files.append(generatedProjectFile);
return files;
}
Core::GeneratedFiles JsonWizardScannerGenerator::scan(const QString &dir, const QDir &base)
{
Core::GeneratedFiles result;
QDir directory(dir);
if (!directory.exists())
return result;
QList<QFileInfo> entries = directory.entryInfoList(QDir::AllEntries | QDir::NoDotAndDotDot,
QDir::DirsLast | QDir::Name);
foreach (const QFileInfo &fi, entries) {
const QString relativePath = base.relativeFilePath(fi.absoluteFilePath());
if (fi.isDir() && matchesSubdirectoryPattern(relativePath)) {
result += scan(fi.absoluteFilePath(), base);
} else {
Core::GeneratedFile f(fi.absoluteFilePath());
f.setAttributes(f.attributes() | Core::GeneratedFile::KeepExistingFileAttribute);
result.append(f);
}
}
return result;
}
Core::GeneratedFiles QtQuickApp::generateFiles(QString *errorMessage) const
{
Core::GeneratedFiles files = AbstractMobileApp::generateFiles(errorMessage);
if (!useExistingMainQml()) {
files.append(file(generateFile(QtQuickAppGeneratedFileInfo::MainQmlFile, errorMessage), path(MainQml)));
if ((componentSet() == QtQuickApp::Meego10Components))
files.append(file(generateFile(QtQuickAppGeneratedFileInfo::MainPageQmlFile, errorMessage), path(MainPageQml)));
files.last().setAttributes(Core::GeneratedFile::OpenEditorAttribute);
}
files.append(file(generateFile(QtQuickAppGeneratedFileInfo::AppViewerPriFile, errorMessage), path(AppViewerPri)));
files.append(file(generateFile(QtQuickAppGeneratedFileInfo::AppViewerCppFile, errorMessage), path(AppViewerCpp)));
files.append(file(generateFile(QtQuickAppGeneratedFileInfo::AppViewerHFile, errorMessage), path(AppViewerH)));
return files;
}
Core::GeneratedFiles LibraryWizard::generateFiles(const QWizard *w,
QString *errorMessage) const
{
Q_UNUSED(errorMessage)
const LibraryWizardDialog *dialog = qobject_cast<const LibraryWizardDialog *>(w);
const QtProjectParameters projectParams = dialog->parameters();
const QString projectPath = projectParams.projectPath();
const LibraryParameters params = dialog->libraryParameters();
const QString sharedLibExportMacro = QtProjectParameters::exportMacro(projectParams.fileName);
Core::GeneratedFiles rc;
// Class header + source
const QString sourceFileName = buildFileName(projectPath, params.sourceFileName, sourceSuffix());
Core::GeneratedFile source(sourceFileName);
source.setAttributes(Core::GeneratedFile::OpenEditorAttribute);
const QString headerFileFullName = buildFileName(projectPath, params.headerFileName, headerSuffix());
const QString headerFileName = Utils::FileName::fromString(headerFileFullName).fileName();
QString pluginJsonFileFullName;
QString pluginJsonFileName;
if (projectParams.type == QtProjectParameters::Qt4Plugin) {
pluginJsonFileFullName = buildFileName(projectPath, projectParams.fileName, QLatin1String("json"));
pluginJsonFileName = Utils::FileName::fromString(pluginJsonFileFullName).fileName();
}
Core::GeneratedFile header(headerFileFullName);
// Create files: global header for shared libs
QString globalHeaderFileName;
if (projectParams.type == QtProjectParameters::SharedLibrary) {
const QString globalHeaderName = buildFileName(projectPath, projectParams.fileName.toLower() + QLatin1String(sharedHeaderPostfixC), headerSuffix());
Core::GeneratedFile globalHeader(globalHeaderName);
globalHeaderFileName = Utils::FileName::fromString(globalHeader.path()).fileName();
globalHeader.setContents(CppTools::AbstractEditorSupport::licenseTemplate(globalHeaderFileName)
+ LibraryParameters::generateSharedHeader(globalHeaderFileName, projectParams.fileName, sharedLibExportMacro));
rc.push_back(globalHeader);
}
// Generate code
QString headerContents, sourceContents;
params.generateCode(projectParams.type, projectParams.fileName, headerFileName,
globalHeaderFileName, sharedLibExportMacro, pluginJsonFileName,
/* indentation*/ 4, &headerContents, &sourceContents);
source.setContents(CppTools::AbstractEditorSupport::licenseTemplate(sourceFileName, params.className)
+ sourceContents);
header.setContents(CppTools::AbstractEditorSupport::licenseTemplate(headerFileFullName, params.className)
+ headerContents);
rc.push_back(source);
rc.push_back(header);
// Create files: profile
const QString profileName = buildFileName(projectPath, projectParams.fileName, profileSuffix());
Core::GeneratedFile profile(profileName);
profile.setAttributes(Core::GeneratedFile::OpenProjectAttribute);
QString profileContents;
{
QTextStream proStr(&profileContents);
QtProjectParameters::writeProFileHeader(proStr);
projectParams.writeProFile(proStr);
proStr << "\nSOURCES += " << Utils::FileName::fromString(source.path()).fileName()
<< "\n\nHEADERS += " << headerFileName;
if (!globalHeaderFileName.isEmpty())
proStr << "\\\n " << globalHeaderFileName << '\n';
if (!pluginJsonFileName.isEmpty())
proStr << "\nDISTFILES += " << pluginJsonFileName << '\n';
writeLinuxProFile(proStr);
}
profile.setContents(profileContents);
rc.push_back(profile);
if (!pluginJsonFileName.isEmpty()) {
Core::GeneratedFile jsonFile(pluginJsonFileFullName);
jsonFile.setContents(QLatin1String("{\n \"Keys\" : [ ]\n}\n"));
rc.push_back(jsonFile);
}
return rc;
}
Core::GeneratedFiles QmlApp::generateFiles(QString *errorMessage)
{
Core::GeneratedFiles files;
QTC_ASSERT(errorMessage, return files);
errorMessage->clear();
setReplacementVariables();
const QFileInfoList templateFiles = allFilesRecursive(templateDirectory());
foreach (const QFileInfo &templateFile, templateFiles) {
const QString targetSubDirectory = templateFile.path().mid(templateDirectory().length());
const QString targetDirectory = projectDirectory() + targetSubDirectory + QLatin1Char('/');
QString targetFileName = templateFile.fileName();
if (templateFile.fileName() == QLatin1String("main.pro")) {
targetFileName = projectName() + QLatin1String(".pro");
m_creatorFileName = Core::BaseFileWizard::buildFileName(projectDirectory(),
projectName(),
QLatin1String("pro"));
} else if (templateFile.fileName() == QLatin1String("main.qmlproject")) {
targetFileName = projectName() + QLatin1String(".qmlproject");
m_creatorFileName = Core::BaseFileWizard::buildFileName(projectDirectory(),
projectName(),
QLatin1String("qmlproject"));
} else if (templateFile.fileName() == QLatin1String("main.qbp")) {
targetFileName = projectName() + QLatin1String(".qbp");
} else if (targetFileName == QLatin1String("template.xml")
|| targetFileName == QLatin1String("template.png")) {
continue;
} else {
targetFileName = renameQmlFile(templateFile.fileName());
}
if (binaryFiles().contains(templateFile.suffix())) {
bool canAddBinaryFile = addBinaryFile(templateFile.absolutePath(),
templateFile.fileName(),
targetDirectory,
targetFileName,
&files,
errorMessage);
if (!canAddBinaryFile)
return Core::GeneratedFiles();
} else {
bool canAddTemplate = addTemplate(templateFile.absolutePath(),
templateFile.fileName(),
targetDirectory,
targetFileName,
&files,
errorMessage);
if (!canAddTemplate)
return Core::GeneratedFiles();
if (templateFile.fileName() == QLatin1String("main.pro")) {
files.last().setAttributes(Core::GeneratedFile::OpenProjectAttribute);
} else if (templateFile.fileName() == QLatin1String("main.qmlproject")) {
files.last().setAttributes(Core::GeneratedFile::OpenProjectAttribute);
} else if (templateFile.fileName() == m_templateInfo.openFile) {
files.last().setAttributes(Core::GeneratedFile::OpenEditorAttribute);
}
}
}
return files;
}
