/home/roberto/qt5_coco/qtsdk/qtbase/src/corelib/kernel/qsignalmapper.cpp

kernel/qsignalmapper.cpp

Source code

Switch to Preprocessed file

Line Source Code Coverage

1 /**************************************************************************** -

2 ** -

4 ** Contact: http://www.qt-project.org/legal -

5 ** -

6 ** This file is part of the QtCore module of the Qt Toolkit. -

7 ** -

8 ** $QT_BEGIN_LICENSE:LGPL$ -

9 ** Commercial License Usage -

10 ** Licensees holding valid commercial Qt licenses may use this file in -

11 ** accordance with the commercial license agreement provided with the -

12 ** Software or, alternatively, in accordance with the terms contained in -

13 ** a written agreement between you and Digia. For licensing terms and -

14 ** conditions see http://qt.digia.com/licensing. For further information -

15 ** use the contact form at http://qt.digia.com/contact-us. -

16 ** -

17 ** GNU Lesser General Public License Usage -

18 ** Alternatively, this file may be used under the terms of the GNU Lesser -

19 ** General Public License version 2.1 as published by the Free Software -

20 ** Foundation and appearing in the file LICENSE.LGPL included in the -

21 ** packaging of this file. Please review the following information to -

22 ** ensure the GNU Lesser General Public License version 2.1 requirements -

23 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. -

24 ** -

25 ** In addition, as a special exception, Digia gives you certain additional -

26 ** rights. These rights are described in the Digia Qt LGPL Exception -

27 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. -

28 ** -

29 ** GNU General Public License Usage -

30 ** Alternatively, this file may be used under the terms of the GNU -

31 ** General Public License version 3.0 as published by the Free Software -

32 ** Foundation and appearing in the file LICENSE.GPL included in the -

33 ** packaging of this file. Please review the following information to -

34 ** ensure the GNU General Public License version 3.0 requirements will be -

35 ** met: http://www.gnu.org/copyleft/gpl.html. -

36 ** -

37 ** -

38 ** $QT_END_LICENSE$ -

39 ** -

40 ****************************************************************************/ -

41 -

42 #include "qsignalmapper.h" -

43 #include "qhash.h" -

44 #include "qobject_p.h" -

45 -

46 QT_BEGIN_NAMESPACE -

47 -

48 class QSignalMapperPrivate : public QObjectPrivate -

49 { -

50 Q_DECLARE_PUBLIC(QSignalMapper) -

51 public: -

52 void _q_senderDestroyed() { -

Q_Q(QSignalMapper);

executed (the execution status of this line is deduced): QSignalMapper * const q = q_func();

q->removeMappings(q->sender());

executed (the execution status of this line is deduced): q->removeMappings(q->sender());

}

executed: }

Execution Count:5

56 QHash<QObject *, int> intHash; -

57 QHash<QObject *, QString> stringHash; -

58 QHash<QObject *, QWidget*> widgetHash; -

59 QHash<QObject *, QObject*> objectHash; -

60 -

61 }; -

62 -

63 -

64 /*! -

65 \class QSignalMapper -

66 \inmodule QtCore -

67 \brief The QSignalMapper class bundles signals from identifiable senders. -

68 -

69 \ingroup objectmodel -

70 -

71 -

72 This class collects a set of parameterless signals, and re-emits -

73 them with integer, string or widget parameters corresponding to -

74 the object that sent the signal. -

75 -

76 The class supports the mapping of particular strings or integers -

77 with particular objects using setMapping(). The objects' signals -

78 can then be connected to the map() slot which will emit the -

79 mapped() signal with the string or integer associated with the -

80 original signalling object. Mappings can be removed later using -

81 removeMappings(). -

82 -

83 Example: Suppose we want to create a custom widget that contains -

84 a group of buttons (like a tool palette). One approach is to -

85 connect each button's \c clicked() signal to its own custom slot; -

86 but in this example we want to connect all the buttons to a -

87 single slot and parameterize the slot by the button that was -

88 clicked. -

89 -

90 Here's the definition of a simple custom widget that has a single -

91 signal, \c clicked(), which is emitted with the text of the button -

92 that was clicked: -

93 -

94 \snippet qsignalmapper/buttonwidget.h 0 -

95 \snippet qsignalmapper/buttonwidget.h 1 -

96 -

97 The only function that we need to implement is the constructor: -

98 -

99 \snippet qsignalmapper/buttonwidget.cpp 0 -

100 \snippet qsignalmapper/buttonwidget.cpp 1 -

101 \snippet qsignalmapper/buttonwidget.cpp 2 -

102 -

103 A list of texts is passed to the constructor. A signal mapper is -

104 constructed and for each text in the list a QPushButton is -

105 created. We connect each button's \c clicked() signal to the -

106 signal mapper's map() slot, and create a mapping in the signal -

107 mapper from each button to the button's text. Finally we connect -

108 the signal mapper's mapped() signal to the custom widget's \c -

109 clicked() signal. When the user clicks a button, the custom -

110 widget will emit a single \c clicked() signal whose argument is -

111 the text of the button the user clicked. -

112 -

113 \sa QObject, QButtonGroup, QActionGroup -

114 */ -

115 -

116 /*! -

117 Constructs a QSignalMapper with parent \a parent. -

118 */ -

119 QSignalMapper::QSignalMapper(QObject* parent) -

120 : QObject(*new QSignalMapperPrivate, parent) -

121 { -

122

}

executed: }

Execution Count:1

123 -

124 /*! -

125 Destroys the QSignalMapper. -

126 */ -

127 QSignalMapper::~QSignalMapper() -

128 { -

129 } -

130 -

131 /*! -

132 Adds a mapping so that when map() is signalled from the given \a -

133 sender, the signal mapped(\a id) is emitted. -

134 -

135 There may be at most one integer ID for each sender. -

136 -

137 \sa mapping() -

138 */ -

139 void QSignalMapper::setMapping(QObject *sender, int id) -

140 { -

141

Q_D(QSignalMapper);

executed (the execution status of this line is deduced): QSignalMapperPrivate * const d = d_func();

142

d->intHash.insert(sender, id);

executed (the execution status of this line is deduced): d->intHash.insert(sender, id);

143

connect(sender, SIGNAL(destroyed()), this, SLOT(_q_senderDestroyed()));

executed (the execution status of this line is deduced): connect(sender, "2""destroyed()", this, "1""_q_senderDestroyed()");

144

}

executed: }

Execution Count:3

145 -

146 /*! -

147 Adds a mapping so that when map() is signalled from the \a sender, -

148 the signal mapped(\a text ) is emitted. -

149 -

150 There may be at most one text for each sender. -

151 */ -

152 void QSignalMapper::setMapping(QObject *sender, const QString &text) -

153 { -

154

Q_D(QSignalMapper);

executed (the execution status of this line is deduced): QSignalMapperPrivate * const d = d_func();

155

d->stringHash.insert(sender, text);

executed (the execution status of this line is deduced): d->stringHash.insert(sender, text);

156

connect(sender, SIGNAL(destroyed()), this, SLOT(_q_senderDestroyed()));

executed (the execution status of this line is deduced): connect(sender, "2""destroyed()", this, "1""_q_senderDestroyed()");

157

}

executed: }

Execution Count:2

158 -

159 /*! -

160 Adds a mapping so that when map() is signalled from the \a sender, -

161 the signal mapped(\a widget ) is emitted. -

162 -

163 There may be at most one widget for each sender. -

164 */ -

165 void QSignalMapper::setMapping(QObject *sender, QWidget *widget) -

166 { -

167

Q_D(QSignalMapper);

never executed (the execution status of this line is deduced): QSignalMapperPrivate * const d = d_func();

168

d->widgetHash.insert(sender, widget);

never executed (the execution status of this line is deduced): d->widgetHash.insert(sender, widget);

169

connect(sender, SIGNAL(destroyed()), this, SLOT(_q_senderDestroyed()));

never executed (the execution status of this line is deduced): connect(sender, "2""destroyed()", this, "1""_q_senderDestroyed()");

170

}

never executed: }

171 -

172 /*! -

173 Adds a mapping so that when map() is signalled from the \a sender, -

174 the signal mapped(\a object ) is emitted. -

175 -

176 There may be at most one object for each sender. -

177 */ -

178 void QSignalMapper::setMapping(QObject *sender, QObject *object) -

179 { -

180

Q_D(QSignalMapper);

never executed (the execution status of this line is deduced): QSignalMapperPrivate * const d = d_func();

181

d->objectHash.insert(sender, object);

never executed (the execution status of this line is deduced): d->objectHash.insert(sender, object);

182

connect(sender, SIGNAL(destroyed()), this, SLOT(_q_senderDestroyed()));

never executed (the execution status of this line is deduced): connect(sender, "2""destroyed()", this, "1""_q_senderDestroyed()");

183

}

never executed: }

184 -

185 /*! -

186 Returns the sender QObject that is associated with the \a id. -

187 -

188 \sa setMapping() -

189 */ -

190 QObject *QSignalMapper::mapping(int id) const -

191 { -

192

Q_D(const QSignalMapper);

never executed (the execution status of this line is deduced): const QSignalMapperPrivate * const d = d_func();

193

return d->intHash.key(id);

never executed: return d->intHash.key(id);

194 } -

195 -

196 /*! -

197 \overload mapping() -

198 */ -

199 QObject *QSignalMapper::mapping(const QString &id) const -

200 { -

201

Q_D(const QSignalMapper);

never executed (the execution status of this line is deduced): const QSignalMapperPrivate * const d = d_func();

202

return d->stringHash.key(id);

never executed: return d->stringHash.key(id);

203 } -

204 -

205 /*! -

206 \overload mapping() -

207 -

208 Returns the sender QObject that is associated with the \a widget. -

209 */ -

210 QObject *QSignalMapper::mapping(QWidget *widget) const -

211 { -

212

Q_D(const QSignalMapper);

never executed (the execution status of this line is deduced): const QSignalMapperPrivate * const d = d_func();

213

return d->widgetHash.key(widget);

never executed: return d->widgetHash.key(widget);

214 } -

215 -

216 /*! -

217 \overload mapping() -

218 -

219 Returns the sender QObject that is associated with the \a object. -

220 */ -

221 QObject *QSignalMapper::mapping(QObject *object) const -

222 { -

223

Q_D(const QSignalMapper);

never executed (the execution status of this line is deduced): const QSignalMapperPrivate * const d = d_func();

224

return d->objectHash.key(object);

never executed: return d->objectHash.key(object);

225 } -

226 -

227 /*! -

228 Removes all mappings for \a sender. -

229 -

230 This is done automatically when mapped objects are destroyed. -

231 */ -

232 void QSignalMapper::removeMappings(QObject *sender) -

233 { -

234

Q_D(QSignalMapper);

executed (the execution status of this line is deduced): QSignalMapperPrivate * const d = d_func();

235 -

236

d->intHash.remove(sender);

executed (the execution status of this line is deduced): d->intHash.remove(sender);

237

d->stringHash.remove(sender);

executed (the execution status of this line is deduced): d->stringHash.remove(sender);

238

d->widgetHash.remove(sender);

executed (the execution status of this line is deduced): d->widgetHash.remove(sender);

239

d->objectHash.remove(sender);

executed (the execution status of this line is deduced): d->objectHash.remove(sender);

240

}

executed: }

Execution Count:5

241 -

242 /*! -

243 This slot emits signals based on which object sends signals to it. -

244 */ -

245

void QSignalMapper::map() { map(sender()); }

executed: }

Execution Count:3

246 -

247 /*! -

248 This slot emits signals based on the \a sender object. -

249 */ -

250 void QSignalMapper::map(QObject *sender) -

251 { -

252

Q_D(QSignalMapper);

executed (the execution status of this line is deduced): QSignalMapperPrivate * const d = d_func();

253

if (d->intHash.contains(sender))

evaluated: d->intHash.contains(sender)

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:1

1-2

254

emit mapped(d->intHash.value(sender));

executed: mapped(d->intHash.value(sender));

Execution Count:2

255

if (d->stringHash.contains(sender))

evaluated: d->stringHash.contains(sender)

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:1

1-2

256

emit mapped(d->stringHash.value(sender));

executed: mapped(d->stringHash.value(sender));

Execution Count:2

257

if (d->widgetHash.contains(sender))

partially evaluated: d->widgetHash.contains(sender)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:3

0-3

258

emit mapped(d->widgetHash.value(sender));

never executed: mapped(d->widgetHash.value(sender));

259

if (d->objectHash.contains(sender))

partially evaluated: d->objectHash.contains(sender)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:3

0-3

260

emit mapped(d->objectHash.value(sender));

never executed: mapped(d->objectHash.value(sender));

261

}

executed: }

Execution Count:3

262 -

263 -

264 /*! -

265 \fn void QSignalMapper::mapped(int i) -

266 -

267 This signal is emitted when map() is signalled from an object that -

268 has an integer mapping set. The object's mapped integer is passed -

269 in \a i. -

270 -

271 \sa setMapping() -

272 */ -

273 -

274 /*! -

275 \fn void QSignalMapper::mapped(const QString &text) -

276 -

277 This signal is emitted when map() is signalled from an object that -

278 has a string mapping set. The object's mapped string is passed in -

279 \a text. -

280 -

281 \sa setMapping() -

282 */ -

283 -

284 /*! -

285 \fn void QSignalMapper::mapped(QWidget *widget) -

286 -

287 This signal is emitted when map() is signalled from an object that -

288 has a widget mapping set. The object's mapped widget is passed in -

289 \a widget. -

290 -

291 \sa setMapping() -

292 */ -

293 -

294 /*! -

295 \fn void QSignalMapper::mapped(QObject *object) -

296 -

297 This signal is emitted when map() is signalled from an object that -

298 has an object mapping set. The object provided by the map is passed in -

299 \a object. -

300 -

301 \sa setMapping() -

302 */ -

303 -

304 QT_END_NAMESPACE -

305 -

306 #include "moc_qsignalmapper.cpp" -

307 -

308 -

Source code

Switch to Preprocessed file