~oif-team/ubuntu/natty/qt4-x11/xi2.1

<td width="1">  </td><td class="postheader" valign="center"><a href="index.html"><font color="#004faf">Home</font></a> · <a href="classes.html"><font color="#004faf">All Classes</font></a> · <a href="mainclasses.html"><font color="#004faf">Main Classes</font></a> · <a href="annotated.html"><font color="#004faf">Annotated</font></a> · <a href="groups.html"><font color="#004faf">Grouped Classes</font></a> · <a href="functions.html"><font color="#004faf">Functions</font></a></td>

<td align="right" valign="top" width="230"><img src="images/trolltech-logo.png" align="right" width="203" height="32" border="0" /></td></tr></table><h1 align="center">calculator.cpp Example File<br /><small><small>widgets/calculator/calculator.cpp</small></small></h1>

<pre>  /****************************************************************************

** This file is part of the documentation of the Qt Toolkit.

** This file may be distributed under the terms of the Q Public License

** as defined by Trolltech AS of Norway and appearing in the file

** LICENSE.QPL included in the packaging of this file.

** This file may be distributed and/or modified under the terms of the

** GNU General Public License version 2 as published by the Free Software

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

** packaging of this file.

** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for

** information about Qt Commercial License Agreements.

** See http://www.trolltech.com/qpl/ for QPL licensing information.

** See http://www.trolltech.com/gpl/ for GPL licensing information.

** Contact info@trolltech.com if any conditions of this licensing are

** not clear to you.

** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE

** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

****************************************************************************/

#include <QtGui>

#include <math.h>

#include "button.h"

#include "calculator.h"

Calculator::Calculator(QWidget *parent)

: QDialog(parent)

{

sumInMemory = 0.0;

sumSoFar = 0.0;

factorSoFar = 0.0;

waitingForOperand = true;

display = new QLineEdit("0");

display->setReadOnly(true);

display->setAlignment(Qt::AlignRight);

display->setMaxLength(15);

display->installEventFilter(this);

QFont font = display->font();

font.setPointSize(font.pointSize() + 8);

display->setFont(font);

QColor digitColor(150, 205, 205);

QColor backspaceColor(225, 185, 135);

QColor memoryColor(100, 155, 155);

QColor operatorColor(155, 175, 195);

for (int i = 0; i < NumDigitButtons; ++i) {

digitButtons[i] = createButton(QString::number(i), digitColor,

SLOT(digitClicked()));

}

pointButton = createButton(tr("."), digitColor, SLOT(pointClicked()));

changeSignButton = createButton(tr("�"), digitColor, SLOT(changeSignClicked()));

backspaceButton = createButton(tr("Backspace"), backspaceColor,

SLOT(backspaceClicked()));

clearButton = createButton(tr("Clear"), backspaceColor, SLOT(clear()));

clearAllButton = createButton(tr("Clear All"), backspaceColor.light(120),

SLOT(clearAll()));

clearMemoryButton = createButton(tr("MC"), memoryColor,

SLOT(clearMemory()));

readMemoryButton = createButton(tr("MR"), memoryColor, SLOT(readMemory()));

setMemoryButton = createButton(tr("MS"), memoryColor, SLOT(setMemory()));

addToMemoryButton = createButton(tr("M+"), memoryColor,

SLOT(addToMemory()));

divisionButton = createButton(tr("�"), operatorColor,

100

SLOT(multiplicativeOperatorClicked()));

101

timesButton = createButton(tr("�"), operatorColor,

102

SLOT(multiplicativeOperatorClicked()));

103

minusButton = createButton(tr("-"), operatorColor,

104

SLOT(additiveOperatorClicked()));

105

plusButton = createButton(tr("+"), operatorColor,

106

SLOT(additiveOperatorClicked()));

107

108

squareRootButton = createButton(tr("Sqrt"), operatorColor,

109

SLOT(unaryOperatorClicked()));

110

powerButton = createButton(tr("x�"), operatorColor,

111

SLOT(unaryOperatorClicked()));

112

reciprocalButton = createButton(tr("1/x"), operatorColor,

113

SLOT(unaryOperatorClicked()));

114

equalButton = createButton(tr("="), operatorColor.light(120),

115

SLOT(equalClicked()));

116

117

QGridLayout *mainLayout = new QGridLayout;

118

mainLayout->setSizeConstraint(QLayout::SetFixedSize);

119

120

mainLayout->addWidget(display, 0, 0, 1, 6);

121

mainLayout->addWidget(backspaceButton, 1, 0, 1, 2);

122

mainLayout->addWidget(clearButton, 1, 2, 1, 2);

123

mainLayout->addWidget(clearAllButton, 1, 4, 1, 2);

124

125

mainLayout->addWidget(clearMemoryButton, 2, 0);

126

mainLayout->addWidget(readMemoryButton, 3, 0);

127

mainLayout->addWidget(setMemoryButton, 4, 0);

128

mainLayout->addWidget(addToMemoryButton, 5, 0);

129

130

for (int i = 1; i < NumDigitButtons; ++i) {

131

int row = ((9 - i) / 3) + 2;

132

int column = ((i - 1) % 3) + 1;

133

mainLayout->addWidget(digitButtons[i], row, column);

134

}

135

136

mainLayout->addWidget(digitButtons[0], 5, 1);

137

mainLayout->addWidget(pointButton, 5, 2);

138

mainLayout->addWidget(changeSignButton, 5, 3);

139

140

mainLayout->addWidget(divisionButton, 2, 4);

141

mainLayout->addWidget(timesButton, 3, 4);

142

mainLayout->addWidget(minusButton, 4, 4);

143

mainLayout->addWidget(plusButton, 5, 4);

144

145

mainLayout->addWidget(squareRootButton, 2, 5);

146

mainLayout->addWidget(powerButton, 3, 5);

147

mainLayout->addWidget(reciprocalButton, 4, 5);

148

mainLayout->addWidget(equalButton, 5, 5);

149

setLayout(mainLayout);

150

151

setWindowTitle(tr("Calculator"));

152

}

153

154

bool Calculator::eventFilter(QObject *target, QEvent *event)

155

{

156

if (target == display) {

157

if (event->type() == QEvent::MouseButtonPress

158

|| event->type() == QEvent::MouseButtonDblClick

159

|| event->type() == QEvent::MouseButtonRelease

160

|| event->type() == QEvent::ContextMenu) {

161

QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);

162

if (mouseEvent->buttons() & Qt::LeftButton) {

163

QPalette newPalette = palette();

164

newPalette.setColor(QPalette::Base,

165

display->palette().color(QPalette::Text));

166

newPalette.setColor(QPalette::Text,

167

display->palette().color(QPalette::Base));

168

display->setPalette(newPalette);

169

} else {

170

display->setPalette(palette());

171

}

172

return true;

173

}

174

}

175

return QDialog::eventFilter(target, event);

176

}

177

178

void Calculator::digitClicked()

179

{

180

Button *clickedButton = qobject_cast<Button *>(sender());

181

int digitValue = clickedButton->text().toInt();

182

if (display->text() == "0" && digitValue == 0.0)

183

return;

184

185

if (waitingForOperand) {

186

display->clear();

187

waitingForOperand = false;

188

}

189

display->setText(display->text() + QString::number(digitValue));

190

}

191

192

void Calculator::unaryOperatorClicked()

193

{

194

Button *clickedButton = qobject_cast<Button *>(sender());

195

QString clickedOperator = clickedButton->text();

196

double operand = display->text().toDouble();

197

double result;

198

199

if (clickedOperator == tr("Sqrt")) {

200

if (operand < 0.0) {

201

abortOperation();

202

return;

203

}

204

result = sqrt(operand);

205

} else if (clickedOperator == tr("x�")) {

206

result = pow(operand, 2.0);

207

} else if (clickedOperator == tr("1/x")) {

208

if (operand == 0.0) {

209

abortOperation();

210

return;

211

}

212

result = 1.0 / operand;

213

}

214

display->setText(QString::number(result));

215

waitingForOperand = true;

216

}

217

218

void Calculator::additiveOperatorClicked()

219

{

220

Button *clickedButton = qobject_cast<Button *>(sender());

221

QString clickedOperator = clickedButton->text();

222

double operand = display->text().toDouble();

223

224

if (!pendingMultiplicativeOperator.isEmpty()) {

225

if (!calculate(operand, pendingMultiplicativeOperator)) {

226

abortOperation();

227

return;

228

}

229

display->setText(QString::number(factorSoFar));

230

operand = factorSoFar;

231

factorSoFar = 0.0;

232

pendingMultiplicativeOperator.clear();

233

}

234

235

if (!pendingAdditiveOperator.isEmpty()) {

236

if (!calculate(operand, pendingAdditiveOperator)) {

237

abortOperation();

238

return;

239

}

240

display->setText(QString::number(sumSoFar));

241

} else {

242

sumSoFar = operand;

243

}

244

245

pendingAdditiveOperator = clickedOperator;

246

waitingForOperand = true;

247

}

248

249

void Calculator::multiplicativeOperatorClicked()

250

{

251

Button *clickedButton = qobject_cast<Button *>(sender());

252

QString clickedOperator = clickedButton->text();

253

double operand = display->text().toDouble();

254

255

if (!pendingMultiplicativeOperator.isEmpty()) {

256

if (!calculate(operand, pendingMultiplicativeOperator)) {

257

abortOperation();

258

return;

259

}

260

display->setText(QString::number(factorSoFar));

261

} else {

262

factorSoFar = operand;

263

}

264

265

pendingMultiplicativeOperator = clickedOperator;

266

waitingForOperand = true;

267

}

268

269

void Calculator::equalClicked()

270

{

271

double operand = display->text().toDouble();

272

273

if (!pendingMultiplicativeOperator.isEmpty()) {

274

if (!calculate(operand, pendingMultiplicativeOperator)) {

275

abortOperation();

276

return;

277

}

278

operand = factorSoFar;

279

factorSoFar = 0.0;

280

pendingMultiplicativeOperator.clear();

281

}

282

if (!pendingAdditiveOperator.isEmpty()) {

283

if (!calculate(operand, pendingAdditiveOperator)) {

284

abortOperation();

285

return;

286

}

287

pendingAdditiveOperator.clear();

288

} else {

289

sumSoFar = operand;

290

}

291

292

display->setText(QString::number(sumSoFar));

293

sumSoFar = 0.0;

294

waitingForOperand = true;

295

}

296

297

void Calculator::pointClicked()

298

{

299

if (waitingForOperand)

300

display->setText("0");

301

if (!display->text().contains("."))

302

display->setText(display->text() + tr("."));

303

waitingForOperand = false;

304

}

305

306

void Calculator::changeSignClicked()

307

{

308

QString text = display->text();

309

double value = text.toDouble();

310

311

if (value > 0.0) {

312

text.prepend(tr("-"));

313

} else if (value < 0.0) {

314

text.remove(0, 1);

315

}

316

display->setText(text);

317

}

318

319

void Calculator::backspaceClicked()

320

{

321

if (waitingForOperand)

322

return;

323

324

QString text = display->text();

325

text.chop(1);

326

if (text.isEmpty()) {

327

text = "0";

328

waitingForOperand = true;

329

}

330

display->setText(text);

331

}

332

333

void Calculator::clear()

334

{

335

if (waitingForOperand)

336

return;

337

338

display->setText("0");

339

waitingForOperand = true;

340

}

341

342

void Calculator::clearAll()

343

{

344

sumSoFar = 0.0;

345

factorSoFar = 0.0;

346

pendingAdditiveOperator.clear();

347

pendingMultiplicativeOperator.clear();

348

display->setText("0");

349

waitingForOperand = true;

350

}

351

352

void Calculator::clearMemory()

353

{

354

sumInMemory = 0.0;

355

}

356

357

void Calculator::readMemory()

358

{

359

display->setText(QString::number(sumInMemory));

360

waitingForOperand = true;

361

}

362

363

void Calculator::setMemory()

364

{

365

equalClicked();

366

sumInMemory = display->text().toDouble();

367

}

368

369

void Calculator::addToMemory()

370

{

371

equalClicked();

372

sumInMemory += display->text().toDouble();

373

}

374

375

Button *Calculator::createButton(const QString &text, const QColor &color,

376

const char *member)

377

{

378

Button *button = new Button(text, color);

379

connect(button, SIGNAL(clicked()), this, member);

380

return button;

381

}

382

383

void Calculator::abortOperation()

384

{

385

clearAll();

386

display->setText(tr("####"));

387

}

388

389

bool Calculator::calculate(double rightOperand, const QString &pendingOperator)

390

{

391

if (pendingOperator == tr("+")) {

392

sumSoFar += rightOperand;

393

} else if (pendingOperator == tr("-")) {

394

sumSoFar -= rightOperand;

395

} else if (pendingOperator == tr("�")) {

396

factorSoFar *= rightOperand;

397

} else if (pendingOperator == tr("�")) {

398

if (rightOperand == 0.0)

399

return false;

400

factorSoFar /= rightOperand;

401

}

402

return true;

403

}</pre>

404

405

406

407

<td width="40%" align="center"><a href="trademarks.html">Trademarks</a></td>

408

409

</tr></table></div></address></body>

410

</html>

Older »