maemorunfactories.cpp 9.75 KB
Newer Older
1
2
/****************************************************************************
**
hjk's avatar
hjk committed
3
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Creator.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** 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, Nokia gives you certain additional
** rights.  These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "maemorunfactories.h"

#include "maemoconstants.h"
#include "maemomanager.h"
#include "maemorunconfiguration.h"
#include "maemoruncontrol.h"
40
#include "qt4projectmanagerconstants.h"
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

#include <projectexplorer/projectexplorer.h>
#include <projectexplorer/projectexplorerconstants.h>
#include <projectexplorer/session.h>
#include <qt4projectmanager/qt4project.h>

namespace Qt4ProjectManager {
namespace Internal {

using namespace ProjectExplorer;

namespace {

QString targetFromId(const QString &id)
{
    if (!id.startsWith(MAEMO_RC_ID_PREFIX))
        return QString();
    return id.mid(QString(MAEMO_RC_ID_PREFIX).size());
}

} // namespace

MaemoRunConfigurationFactory::MaemoRunConfigurationFactory(QObject *parent)
    : IRunConfigurationFactory(parent)
{
    ProjectExplorerPlugin *explorer = ProjectExplorerPlugin::instance();
    connect(explorer->session(), SIGNAL(projectAdded(ProjectExplorer::Project*)),
        this, SLOT(projectAdded(ProjectExplorer::Project*)));
    connect(explorer->session(), SIGNAL(projectRemoved(ProjectExplorer::Project*)),
        this, SLOT(projectRemoved(ProjectExplorer::Project*)));
71
72
73
    connect(explorer->session(),
        SIGNAL(startupProjectChanged(ProjectExplorer::Project*)), this,
        SLOT(projectChanged(ProjectExplorer::Project*)));
74
75
76
77
78
79
80
81
82
83
84
}

MaemoRunConfigurationFactory::~MaemoRunConfigurationFactory()
{
}

bool MaemoRunConfigurationFactory::canCreate(Target *parent,
    const QString &id) const
{
    Qt4Target *target = qobject_cast<Qt4Target *>(parent);
    if (!target
85
        || target->id() != QLatin1String(Constants::MAEMO_DEVICE_TARGET_ID)) {
86
87
        return false;
    }
88
    return id == MAEMO_RC_ID || id.startsWith(MAEMO_RC_ID_PREFIX);
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
}

bool MaemoRunConfigurationFactory::canRestore(Target *parent,
    const QVariantMap &map) const
{
    return canCreate(parent, ProjectExplorer::idFromMap(map));
}

bool MaemoRunConfigurationFactory::canClone(Target *parent,
    RunConfiguration *source) const
{
    return canCreate(parent, source->id());
}

QStringList MaemoRunConfigurationFactory::availableCreationIds(Target *parent) const
{
    if (Qt4Target *t = qobject_cast<Qt4Target *>(parent)) {
106
        if (t->id() == QLatin1String(Constants::MAEMO_DEVICE_TARGET_ID)) {
107
108
109
110
111
112
113
            return t->qt4Project()->
                applicationProFilePathes(QLatin1String(MAEMO_RC_ID_PREFIX));
        }
    }
    return QStringList();
}

Kai Koehne's avatar
Kai Koehne committed
114
QString MaemoRunConfigurationFactory::displayNameForId(const QString & /*id*/) const
115
{
kh1's avatar
kh1 committed
116
    Q_UNUSED(id)
117
    return tr("New Maemo Run Configuration");
118
119
120
121
122
123
124
125
}

RunConfiguration *MaemoRunConfigurationFactory::create(Target *parent,
    const QString &id)
{
    if (!canCreate(parent, id))
        return 0;
    Qt4Target *pqt4parent = static_cast<Qt4Target *>(parent);
126
    return new MaemoRunConfiguration(pqt4parent, targetFromId(id));
127
128
129
130
131
132
133
134

}

RunConfiguration *MaemoRunConfigurationFactory::restore(Target *parent,
    const QVariantMap &map)
{
    if (!canRestore(parent, map))
        return 0;
135
136
137
138
139
140
141
    Qt4Target *target = static_cast<Qt4Target *>(parent);
    MaemoRunConfiguration *rc = new MaemoRunConfiguration(target, QString());
    if (rc->fromMap(map))
        return rc;

    delete rc;
    return 0;
142
143
144
145
146
147
148
149
}

RunConfiguration *MaemoRunConfigurationFactory::clone(Target *parent,
    RunConfiguration *source)
{
    if (!canClone(parent, source))
        return 0;

150
151
    MaemoRunConfiguration *old = static_cast<MaemoRunConfiguration *>(source);
    return new MaemoRunConfiguration(static_cast<Qt4Target *>(parent), old);
152
153
}

154
void MaemoRunConfigurationFactory::projectAdded(ProjectExplorer::Project *project)
155
156
157
158
159
{
    connect(project, SIGNAL(addedTarget(ProjectExplorer::Target*)), this,
        SLOT(targetAdded(ProjectExplorer::Target*)));
    connect(project, SIGNAL(removedTarget(ProjectExplorer::Target*)), this,
        SLOT(targetRemoved(ProjectExplorer::Target*)));
160
161
    connect(project, SIGNAL(activeTargetChanged(ProjectExplorer::Target*)),
        this, SLOT(targetChanged(ProjectExplorer::Target*)));
162
163
164
165
166

    foreach (Target *target, project->targets())
        targetAdded(target);
}

167
void MaemoRunConfigurationFactory::projectRemoved(ProjectExplorer::Project *project)
168
169
170
171
172
{
    disconnect(project, SIGNAL(addedTarget(ProjectExplorer::Target*)), this,
        SLOT(targetAdded(ProjectExplorer::Target*)));
    disconnect(project, SIGNAL(removedTarget(ProjectExplorer::Target*)), this,
        SLOT(targetRemoved(ProjectExplorer::Target*)));
173
174
    disconnect(project, SIGNAL(activeTargetChanged(ProjectExplorer::Target*)),
        this, SLOT(targetChanged(ProjectExplorer::Target*)));
175
176
177
178
179

    foreach (Target *target, project->targets())
        targetRemoved(target);
}

180
181
182
void MaemoRunConfigurationFactory::projectChanged(ProjectExplorer::Project *project)
{
    if (project)
183
        updateMaemoEmulatorStarter(project->target(QLatin1String(Constants::MAEMO_DEVICE_TARGET_ID)));
184
185
}

186
187
void MaemoRunConfigurationFactory::targetAdded(ProjectExplorer::Target *target)
{
188
    if (!target || target->id() != QLatin1String(Constants::MAEMO_DEVICE_TARGET_ID))
189
190
        return;

191
    MaemoManager::instance().addQemuSimulatorStarter(target->project());
192
193
194
195
196
197
198
    foreach (RunConfiguration *runConfig, target->runConfigurations()) {
        if (MaemoRunConfiguration *mrc = qobject_cast<MaemoRunConfiguration *> (runConfig)) {
            connect(mrc, SIGNAL(deviceConfigurationChanged(ProjectExplorer::Target*)),
                this, SLOT(targetChanged(ProjectExplorer::Target*)));
        }
    }
    updateMaemoEmulatorStarter(target);
199
200
201
202
}

void MaemoRunConfigurationFactory::targetRemoved(ProjectExplorer::Target *target)
{
203
    if (!target || target->id() != QLatin1String(Constants::MAEMO_DEVICE_TARGET_ID))
204
205
        return;

206
    MaemoManager::instance().removeQemuSimulatorStarter(target->project());
207
208
209
210
211
212
213
    foreach (RunConfiguration *runConfig, target->runConfigurations()) {
        if (MaemoRunConfiguration *mrc = qobject_cast<MaemoRunConfiguration *> (runConfig)) {
            disconnect(mrc, SIGNAL(deviceConfigurationChanged(ProjectExplorer::Target*)),
                this, SLOT(targetChanged(ProjectExplorer::Target*)));
        }
    }
    updateMaemoEmulatorStarter(target);
214
215
}

216
void MaemoRunConfigurationFactory::targetChanged(ProjectExplorer::Target *target)
217
{
218
219
220
    if (target)
        updateMaemoEmulatorStarter(target);
}
221

222
223
224
void MaemoRunConfigurationFactory::updateMaemoEmulatorStarter(Target *target) const
{
    bool enable = false;
225
    bool isRunning = false;
226
227
228
229
230
231
232

    if (target) {
        MaemoRunConfiguration *mrc = 0;
        if (target->project()->activeTarget() == target)
            mrc = qobject_cast<MaemoRunConfiguration *> (target->activeRunConfiguration());

        if (mrc) {
233
            isRunning = mrc->isQemuRunning();
234
235
236
237
238
239
240
241
242
243
            const MaemoDeviceConfig &config = mrc ? mrc->deviceConfig() : MaemoDeviceConfig();

            ProjectExplorerPlugin *explorer = ProjectExplorerPlugin::instance();
            if (config.isValid()
                && !mrc->simulatorPath().isEmpty()
                && config.type == MaemoDeviceConfig::Simulator
                && explorer->startupProject() == target->project()) {
                enable = true;
            }
        }
244
    }
245

246
    MaemoManager::instance().updateQemuSimulatorStarter(isRunning);
247
    MaemoManager::instance().setQemuSimulatorStarterEnabled(enable);
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
}


// #pragma mark -- MaemoRunControlFactory


MaemoRunControlFactory::MaemoRunControlFactory(QObject *parent)
    : IRunControlFactory(parent)
{
}

MaemoRunControlFactory::~MaemoRunControlFactory()
{
}

bool MaemoRunControlFactory::canRun(RunConfiguration *runConfiguration,
    const QString &mode) const
{
    return qobject_cast<MaemoRunConfiguration *>(runConfiguration)
        && (mode == ProjectExplorer::Constants::RUNMODE
        || mode == ProjectExplorer::Constants::DEBUGMODE);
}

RunControl* MaemoRunControlFactory::create(RunConfiguration *runConfig,
    const QString &mode)
{
    MaemoRunConfiguration *rc = qobject_cast<MaemoRunConfiguration *>(runConfig);
    Q_ASSERT(rc);
    Q_ASSERT(mode == ProjectExplorer::Constants::RUNMODE
        || mode == ProjectExplorer::Constants::DEBUGMODE);
    if (mode == ProjectExplorer::Constants::RUNMODE)
        return new MaemoRunControl(rc);
    return new MaemoDebugRunControl(rc);
}

QString MaemoRunControlFactory::displayName() const
{
    return tr("Run on device");
}

288
QWidget *MaemoRunControlFactory::createConfigurationWidget(RunConfiguration *config)
289
290
291
292
293
294
295
{
    Q_UNUSED(config)
    return 0;
}

    } // namespace Internal
} // namespace Qt4ProjectManager