← Back to branch summary

~zeller-benjamin/qtcreator-plugin-ubuntu/qtc41-beta

« back to all changes in this revision

Viewing changes to src/ubuntu/ubuntuprojectapp.cpp

  • Committer: Juhapekka Piiroinen
  • Date: 2013-09-04 15:30:00 UTC
  • mto: (23.1.14 binary-plugin)
  • mto: This revision was merged to the branch mainline in revision 24.
  • Revision ID: juhapekka.piiroinen@canonical.com-20130904153000-r4lhfhrjlwmop277
Added cordova plugin from ubuntu-qtcreator-plugins.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/ubuntu/ubuntuprojectapp.cpp
 
1
/*
 
2
 * Copyright 2013 Canonical Ltd.
 
3
 *
 
4
 * This program is free software; you can redistribute it and/or modify
 
5
 * it under the terms of the GNU Lesser General Public License as published by
 
6
 * the Free Software Foundation; version 2.1.
 
7
 *
 
8
 * This program is distributed in the hope that it will be useful,
 
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
 * GNU Lesser General Public License for more details.
 
12
 *
 
13
 * You should have received a copy of the GNU Lesser General Public License
 
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
15
 *
 
16
 * Author: Juhapekka Piiroinen <juhapekka.piiroinen@canonical.com>
 
17
 */
 
18
 
 
19
#include "ubuntuprojectapp.h"
 
20
 
 
21
#include "ubuntushared.h"
 
22
#include "ubuntuprojectapplicationwizard.h"
 
23
#include "ubuntuconstants.h"
 
24
#include "ubuntuproject.h"
 
25
 
 
26
#include <app/app_version.h>
 
27
#include <projectexplorer/customwizard/customwizard.h>
 
28
#include <projectexplorer/projectexplorerconstants.h>
 
29
#include <projectexplorer/projectexplorer.h>
 
30
#include <projectexplorer/project.h>
 
31
#include <qtsupport/qtsupportconstants.h>
 
32
#include <coreplugin/icore.h>
 
33
#include <utils/filesearch.h>
 
34
#include <qmlprojectmanager/qmlprojectmanager.h>
 
35
#include <qt4projectmanager/qt4projectmanager.h>
 
36
#include <QtGlobal>
 
37
 
 
38
#include <QIcon>
 
39
#include <QDir>
 
40
#include <QDebug>
 
41
#include <QTextStream>
 
42
#include <QDeclarativeEngine>
 
43
#include <QJsonArray>
 
44
 
 
45
using namespace Ubuntu;
 
46
using namespace Ubuntu::Internal;
 
47
 
 
48
UbuntuProjectApp::UbuntuProjectApp(QObject *parent) :
 
49
    QObject(parent)
 
50
{
 
51
}
 
52
 
 
53
Core::GeneratedFiles UbuntuProjectApp::generateFiles(const QWizard *w, QString *errorMessage) {
 
54
    Q_UNUSED(errorMessage);
 
55
 
 
56
    QByteArray contents;
 
57
    Core::GeneratedFiles files;
 
58
 
 
59
    QJsonValue tmp_type = m_obj.value(QLatin1String(Constants::UBUNTU_PROJECTJSON_TYPE));
 
60
    QString projectType = QLatin1String(Constants::UBUNTU_QMLPROJECT_TYPE);
 
61
    if (tmp_type.isUndefined() == false) {
 
62
        projectType = tmp_type.toString();
 
63
    }
 
64
 
 
65
    setProjectType(projectType);
 
66
 
 
67
    QJsonValue tmp_hasTests = m_obj.value(QLatin1String(Constants::UBUNTU_HAS_TESTS));
 
68
    bool hasTests = false;
 
69
    if (tmp_hasTests.isUndefined() == false) {
 
70
        hasTests = tmp_hasTests.toBool();
 
71
    }
 
72
 
 
73
    const UbuntuProjectApplicationWizardDialog *wizard = qobject_cast<const UbuntuProjectApplicationWizardDialog *>(w);
 
74
    const QString projectName = wizard->projectName();
 
75
    const QString projectPath = wizard->path() + QLatin1Char('/') + projectName;
 
76
 
 
77
 
 
78
    QString folder;
 
79
    QJsonValue tmp_folder = m_obj.value(QLatin1String(Constants::UBUNTU_PROJECTJSON_FOLDER));
 
80
    if (tmp_folder.isUndefined() == false) {
 
81
        folder = tmp_folder.toString();
 
82
    }
 
83
 
 
84
    if (m_projectType == QLatin1String(Constants::UBUNTU_QMLPROJECT_TYPE)
 
85
            || m_projectType == QLatin1String(Constants::UBUNTU_AUTOPILOTPROJECT_TYPE)
 
86
            || m_projectType == QLatin1String(Constants::UBUNTU_HTMLPROJECT_TYPE)
 
87
            || m_projectType == QLatin1String(Constants::UBUNTU_UBUNTUPROJECT_TYPE)
 
88
            || m_projectType == QLatin1String(Constants::UBUNTU_CORDOVAUBUNTU_TYPE)) {
 
89
 
 
90
        const QString creatorFileName = Core::BaseFileWizard::buildFileName(projectPath,
 
91
                                                                            projectName,
 
92
                                                                            projectType);
 
93
 
 
94
        QString mainFileName;
 
95
 
 
96
        // load the mainFile
 
97
        if (m_projectType == QLatin1String(Constants::UBUNTU_CORDOVAUBUNTU_TYPE)) {
 
98
            mainFileName = Core::BaseFileWizard::buildFileName(projectPath,
 
99
                                                              QLatin1String("index"),
 
100
                                                              QLatin1String("html"));
 
101
        } else {
 
102
            mainFileName = Core::BaseFileWizard::buildFileName(projectPath,
 
103
                                                                         projectName,
 
104
                                                                         QLatin1String(Constants::UBUNTU_QML_TYPE));
 
105
        }
 
106
        QJsonValue tmp_mainFile = m_obj.value(QLatin1String(Constants::UBUNTU_PROJECTJSON_MAINFILE));
 
107
 
 
108
        if (tmp_mainFile.isUndefined() == false && tmp_folder.isUndefined() == false) {
 
109
            QString errorMsg;
 
110
            QString fileName = tmp_mainFile.toString();
 
111
 
 
112
            if (readFile(QString(QLatin1String("%0/%1")).arg(UbuntuProjectApplicationWizard::templatesPath(folder)).arg(fileName),&contents, &errorMsg) == false) {
 
113
                contents = errorMsg.toAscii();
 
114
                qDebug() << __PRETTY_FUNCTION__ << contents;
 
115
            }
 
116
        }
 
117
 
 
118
        contents = processReservedWords(contents,projectPath,projectName);
 
119
        mainFileName = processReservedWordsInFileName(mainFileName,projectName);
 
120
 
 
121
        Core::GeneratedFile generatedMainFile(mainFileName);
 
122
        generatedMainFile.setContents(QString::fromLatin1(contents));
 
123
        generatedMainFile.setAttributes(Core::GeneratedFile::OpenEditorAttribute);
 
124
 
 
125
        // create the project file
 
126
        QByteArray projectContents;
 
127
        {
 
128
            QTextStream out(&projectContents);
 
129
 
 
130
            QDeclarativeEngine engine; // QQmlEngine engine;
 
131
 
 
132
            out << "/* File generated by Qt Creator (with Ubuntu Plugin), version " << Core::Constants::IDE_VERSION_LONG << " */" << endl
 
133
                << endl
 
134
                << "import QmlProject 1.1" << endl
 
135
                << endl
 
136
                << "Project {" << endl
 
137
                << "    mainFile: \"" << QDir(projectPath).relativeFilePath(mainFileName) << '"' << endl
 
138
                << endl
 
139
                << "    /* Include .qml, .js, and image files from current directory and subdirectories */" << endl
 
140
                << "    QmlFiles {" << endl
 
141
                << "        directory: \".\"" << endl
 
142
                << "    }" << endl
 
143
                << "    JavaScriptFiles {" << endl
 
144
                << "        directory: \".\"" << endl
 
145
                << "    }" << endl
 
146
                << "    ImageFiles {" << endl
 
147
                << "        directory: \".\"" << endl
 
148
                << "    }" << endl
 
149
                << "    Files {" << endl
 
150
                << "        filter: \"*.desktop\"" << endl
 
151
                << "    }" << endl
 
152
                << "    Files {" << endl
 
153
                << "        filter: \"Makefile\"" << endl
 
154
                << "    }" << endl;
 
155
 
 
156
                out << "    Files {" << endl
 
157
                    << "        directory: \"html\"" << endl
 
158
                    << "        filter: \"*\"" << endl
 
159
                    << "    }" << endl;
 
160
 
 
161
                out << "    Files {" << endl
 
162
                    << "        directory: \"img/\"" << endl
 
163
                    << "        filter: \"*\"" << endl
 
164
                    << "    }" << endl;
 
165
 
 
166
                out << "    Files {" << endl
 
167
                    << "        directory: \"css/\"" << endl
 
168
                    << "        filter: \"*\"" << endl
 
169
                    << "    }" << endl;
 
170
 
 
171
                out << "    Files {" << endl
 
172
                    << "        directory: \"tests/\"" << endl
 
173
                    << "        filter: \"*\"" << endl
 
174
                    << "    }" << endl;
 
175
           // }
 
176
            out << "    Files {" << endl
 
177
                << "        directory: \"debian\"" << endl
 
178
                << "        filter: \"*\"" << endl
 
179
                << "    }" << endl
 
180
                << "    /* List of plugin directories passed to QML runtime */" << endl
 
181
                << "    importPaths: [ \".\" ,\""
 
182
 
 
183
                // FIX ME: use QQmlEngine instead of QDeclarativeEngine. Then remove the replace.
 
184
                <<  engine.importPathList().join(QLatin1String("\",\"")).replace(QLatin1String("imports"),QLatin1String("qml"))
 
185
 
 
186
                << "\" ]" << endl
 
187
 
 
188
            << "}" << endl;
 
189
        }
 
190
 
 
191
        setProjectFileName(creatorFileName);
 
192
        Core::GeneratedFile generatedCreatorFile(creatorFileName);
 
193
        generatedCreatorFile.setContents(QLatin1String(projectContents));
 
194
        generatedCreatorFile.setAttributes(Core::GeneratedFile::OpenProjectAttribute);
 
195
 
 
196
        // add created files
 
197
        files.append(generatedMainFile);
 
198
        files.append(generatedCreatorFile);
 
199
    } else {
 
200
        QString errorMsg;
 
201
        QJsonValue tmp_mainFile = m_obj.value(QLatin1String(Constants::UBUNTU_PROJECTJSON_MAINFILE));
 
202
        if (tmp_mainFile.isUndefined() == false) {
 
203
            QString fileName_target = Core::BaseFileWizard::buildFileName(projectPath, tmp_mainFile.toString(),QString());
 
204
            QString fileName_source = tmp_mainFile.toString();
 
205
            if (readFile(QString(QLatin1String("%0/%1")).arg(UbuntuProjectApplicationWizard::templatesPath(folder)).arg(fileName_source),&contents, &errorMsg) == false) {
 
206
                contents = errorMsg.toAscii();
 
207
                qDebug() << __PRETTY_FUNCTION__ << contents;
 
208
            }
 
209
 
 
210
            contents = processReservedWords(contents,projectPath,projectName);
 
211
 
 
212
            fileName_target = processReservedWordsInFileName(fileName_target,projectName);
 
213
 
 
214
 
 
215
            Core::GeneratedFile generatedMainFile(fileName_target);
 
216
            generatedMainFile.setContents(QLatin1String(contents));
 
217
            generatedMainFile.setAttributes(Core::GeneratedFile::OpenEditorAttribute);
 
218
            files.append(generatedMainFile);
 
219
        }
 
220
 
 
221
        QJsonValue tmp_projectFile = m_obj.value(QLatin1String(Constants::UBUNTU_PROJECTJSON_PROJECTFILE));
 
222
        if (tmp_projectFile.isUndefined() == false) {
 
223
            QString fileName_target = Core::BaseFileWizard::buildFileName(projectPath, QString(QLatin1String("%0.%1")).arg(projectName).arg(QLatin1String(Constants::UBUNTU_QTPROJECT_TYPE)),QString());
 
224
            QString fileName_source = tmp_projectFile.toString();
 
225
            if (readFile(QString(QLatin1String("%0/%1")).arg(UbuntuProjectApplicationWizard::templatesPath(folder)).arg(fileName_source),&contents, &errorMsg) == false) {
 
226
                contents = errorMsg.toAscii();
 
227
                qDebug() << __PRETTY_FUNCTION__ << contents;
 
228
            }
 
229
 
 
230
            contents = processReservedWords(contents,projectPath,projectName);
 
231
 
 
232
            fileName_target = processReservedWordsInFileName(fileName_target,projectName);
 
233
 
 
234
            setProjectFileName(fileName_target);
 
235
 
 
236
            Core::GeneratedFile generatedCreatorFile(fileName_target);
 
237
            generatedCreatorFile.setContents(QLatin1String(contents));
 
238
            generatedCreatorFile.setAttributes(Core::GeneratedFile::OpenProjectAttribute);
 
239
            files.append(generatedCreatorFile);
 
240
        }
 
241
    }
 
242
 
 
243
    // create and add the other files
 
244
    QJsonValue tmp = m_obj.value(QLatin1String(Constants::UBUNTU_PROJECTJSON_FILES));
 
245
    if (tmp.isUndefined() == false && tmp.isArray() ) {
 
246
        QJsonArray jsonFiles = tmp.toArray();
 
247
        for (int idx = 0; idx < jsonFiles.size(); idx++) {
 
248
            QJsonValue tmp_value = jsonFiles.at(idx);
 
249
            if (tmp_value.isObject()) {
 
250
                QJsonValue tmp_fileName = tmp_value.toObject().value(QLatin1String(Constants::UBUNTU_PROJECTJSON_FILENAME));
 
251
                if (tmp_fileName.isUndefined() == false) {
 
252
                    QString fileName = tmp_fileName.toString();
 
253
                    QString errorMsg;
 
254
                    QByteArray contents;
 
255
                    if (readFile(QString(QLatin1String("%0/%1")).arg(UbuntuProjectApplicationWizard::templatesPath(folder)).arg(fileName),&contents, &errorMsg) == false) {
 
256
                        contents = errorMsg.toAscii();
 
257
                        qDebug() << __PRETTY_FUNCTION__ << contents;
 
258
                    } else {
 
259
                        contents = processReservedWords(contents,projectPath,projectName);
 
260
 
 
261
                        fileName = processReservedWordsInFileName(fileName,projectName);
 
262
 
 
263
                        Core::GeneratedFile generatedFile(Core::BaseFileWizard::buildFileName(projectPath,fileName,QString()));
 
264
                        generatedFile.setBinaryContents(contents);
 
265
                        files.append(generatedFile);
 
266
                    }
 
267
                }
 
268
            }
 
269
        }
 
270
    }
 
271
    return files;
 
272
}
 
273
 
 
274
QByteArray UbuntuProjectApp::processReservedWordsInFileName(QByteArray data, QString projectName) {
 
275
    data = data.replace(Constants::UBUNTU_FILENAME_DISPLAYNAME_UPPER,projectName.toUpper().toLatin1());
 
276
    data = data.replace(Constants::UBUNTU_FILENAME_DISPLAYNAME_LOWER,projectName.toLower().toLatin1());
 
277
    data = data.replace(Constants::UBUNTU_FILENAME_DISPLAYNAME_CAPITAL,Utils::matchCaseReplacement(QLatin1String("Capitalize"),projectName).toLatin1());
 
278
    data = data.replace(Constants::UBUNTU_FILENAME_DISPLAYNAME,projectName.toLatin1());
 
279
    return data;
 
280
}
 
281
 
 
282
QByteArray UbuntuProjectApp::processReservedWords(QByteArray data, QString projectPath, QString projectName) {
 
283
    QString folderName = QFileInfo(projectPath).baseName();
 
284
    data = data.replace(Constants::UBUNTU_ACTION_FOLDERNAME,folderName.toLatin1());    
 
285
    data = data.replace(Constants::UBUNTU_ACTION_DISPLAYNAME_LOWER,projectName.toLower().toLatin1());
 
286
    data = data.replace(Constants::UBUNTU_ACTION_DISPLAYNAME_UPPER,projectName.toUpper().toLatin1());
 
287
    data = data.replace(Constants::UBUNTU_ACTION_DISPLAYNAME_CAPITAL,Utils::matchCaseReplacement(QLatin1String("Capitalize"),projectName).toLatin1());
 
288
    data = data.replace(Constants::UBUNTU_ACTION_DISPLAYNAME,projectName.toLatin1());
 
289
    data = data.replace(Constants::UBUNTU_ACTION_SHAREDIRECTORY,Constants::UBUNTU_SHAREPATH.toLatin1());
 
290
    return data;
 
291
}
 
292
 
 
293
Core::BaseFileWizardParameters UbuntuProjectApp::parameters(QJsonObject params) {
 
294
    QString displayName, id, description, category, displayCategory;
 
295
    category = QLatin1String(Ubuntu::Constants::UBUNTU_PROJECT_WIZARD_CATEGORY);
 
296
    displayCategory = QLatin1String(Ubuntu::Constants::UBUNTU_PROJECT_WIZARD_CATEGORY_DISPLAY);
 
297
 
 
298
    QJsonValue tmp = params.value(QLatin1String(Constants::UBUNTU_PROJECTJSON_DISPLAYNAME));
 
299
    if (tmp.isUndefined() == false) {
 
300
        displayName = tmp.toString();
 
301
    }
 
302
 
 
303
    tmp = params.value(QLatin1String(Constants::UBUNTU_PROJECTJSON_ID));
 
304
    if (tmp.isUndefined() == false) {
 
305
        id = tmp.toString();
 
306
    }
 
307
 
 
308
    tmp = params.value(QLatin1String(Constants::UBUNTU_PROJECTJSON_DESCRIPTION));
 
309
    if (tmp.isUndefined() == false) {
 
310
        description = tmp.toString();
 
311
    }
 
312
 
 
313
    tmp = params.value(QLatin1String(Constants::UBUNTU_PROJECTJSON_CATEGORY));
 
314
    if (tmp.isUndefined() == false) {
 
315
        category = tmp.toString();
 
316
    }
 
317
 
 
318
    tmp = params.value(QLatin1String(Constants::UBUNTU_PROJECTJSON_CATEGORY_DISPLAY));
 
319
    if (tmp.isUndefined() == false) {
 
320
        displayCategory = tmp.toString();
 
321
    }
 
322
 
 
323
    Core::BaseFileWizardParameters parameters;
 
324
    parameters.setIcon(QIcon(QLatin1String(QtSupport::Constants::QML_WIZARD_ICON)));
 
325
    parameters.setDisplayName(displayName);
 
326
    parameters.setId(id);
 
327
    parameters.setKind(Core::IWizard::ProjectWizard);
 
328
    parameters.setFlags(Core::IWizard::PlatformIndependent);
 
329
    parameters.setDescription(description);
 
330
    parameters.setCategory(category);
 
331
    parameters.setDisplayCategory(displayCategory);
 
332
    return parameters;
 
333
}
 
334
 
 
335
Core::Feature UbuntuProjectApp::requiredFeature() {
 
336
    QJsonValue tmp_feature = m_obj.value(QLatin1String(Constants::UBUNTU_PROJECTJSON_REQUIRED_FEATURE));
 
337
    QString feature;
 
338
    if (tmp_feature.isUndefined() == false) {
 
339
        feature = tmp_feature.toString();
 
340
    }
 
341
    if (!feature.isEmpty()) {
 
342
        return Core::Feature(feature.toLatin1().constData());
 
343
    }
 
344
    return Core::Feature(0);
 
345
}