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

<td width="1">  </td><td class="postheader" valign="center"><a href="index.html">Home</a> · <a href="classes.html">All Classes</a> · <a href="mainclasses.html">Main Classes</a> · <a href="annotated.html">Annotated</a> · <a href="groups.html">Grouped Classes</a> · <a href="functions.html">Functions</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 Example</h1>

Files:

<ul>

<li><a href="widgets-calculator-button-cpp.html">widgets/calculator/button.cpp</a></li>

<li><a href="widgets-calculator-button-h.html">widgets/calculator/button.h</a></li>

<li><a href="widgets-calculator-calculator-cpp.html">widgets/calculator/calculator.cpp</a></li>

<li><a href="widgets-calculator-calculator-h.html">widgets/calculator/calculator.h</a></li>

<li><a href="widgets-calculator-main-cpp.html">widgets/calculator/main.cpp</a></li>

</ul>

The example shows how to use signals and slots to implement the functionality of a calculator widget, and how to use <a href="qgridlayout.html">QGridLayout</a> to place child widgets in a grid. This example also demonstrates how to use <a href="qobject.html#installEventFilter">event filters</a> to customize a widget's behavior.

<center><img src="images/calculator-example.png" alt="Screenshot of the Calculator example" /></center>The example consists of two classes:

<ul>

<li><tt>Calculator</tt> is the calculator widget, with all the calculator functionality.</li>

<li><tt>Button</tt> is the widget used for each of the calculator button. It derives from <a href="qtoolbutton.html">QToolButton</a>.</li>

</ul>

We will start by reviewing <tt>Calculator</tt>, then we will take a look at <tt>Button</tt>.

<h2>Calculator Class Definition</h2>

<pre>  class Calculator : public QDialog

{

Q_OBJECT

public:

Calculator(QWidget *parent = 0);

protected:

bool eventFilter(QObject *target, QEvent *event);

private slots:

void digitClicked();

void unaryOperatorClicked();

void additiveOperatorClicked();

void multiplicativeOperatorClicked();

void equalClicked();

void pointClicked();

void changeSignClicked();

void backspaceClicked();

void clear();

void clearAll();

void clearMemory();

void readMemory();

void setMemory();

void addToMemory();</pre>

The <tt>Calculator</tt> class provides a simple calculator widget. It inherits from <a href="qdialog.html">QDialog</a> and has several private slots associated with the calculator's buttons. <a href="qobject.html#eventFilter">QObject::eventFilter</a>() is reimplemented to handle mouse events on the calculator's display.

Buttons are grouped in categories according to their behavior. For example, all the digit buttons (labeled 0 to 9) append a digit to the current operand. For these, we connect multiple buttons to the same slot (e.g., <tt>digitClicked()</tt>). The categories are digits, unary operators (Sqrt, x�, 1/x), additive operators (+, -), and multiplicative operators (�, �). The other buttons have their own slots.

<pre>  private:

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

const char *member);

void abortOperation();

bool calculate(double rightOperand, const QString &pendingOperator);</pre>

The private <tt>createButton()</tt> function is used as part of the widget construction. <tt>abortOperation()</tt> is called whenever a division by zero occurs or when a square root operation is applied to a negative number. <tt>calculate()</tt> applies a binary operator (+, -, �, or �).

<pre>  double sumInMemory;

double sumSoFar;

double factorSoFar;

QString pendingAdditiveOperator;

QString pendingMultiplicativeOperator;

bool waitingForOperand;</pre>

These variables, together with the contents of the calculator display (a <a href="qlineedit.html">QLineEdit</a>), encode the state of the calculator:

<ul>

<li><tt>sumInMemory</tt> contains the value stored in the calculator's memory (using MS, M+, or MC).</li>

<li><tt>sumSoFar</tt> stores the value accumulated so far. When the user clicks =, <tt>sumSoFar</tt> is recomputed and shown on the display. Clear All resets <tt>sumSoFar</tt> to zero.</li>

<li><tt>factorSoFar</tt> stores a temporary value when doing multiplications and divisions.</li>

<li><tt>pendingAdditiveOperator</tt> stores the last additive operator clicked by the user.</li>

<li><tt>pendingMultiplicativeOperator</tt> stores the last multiplicative operator clicked by the user.</li>

<li><tt>waitingForOperand</tt> is <tt>true</tt> when the calculator is expecting the user to start typing an operand.</li>

</ul>

Additive and multiplicative operators are treated differently because they have different precedences. For example, 1 + 2 � 3 is interpreted as 1 + (2 � 3) because � has higher precedence than +.

The table below shows the evolution of the calculator state as the user enters a mathematical expression.

<tr valign="top" bgcolor="#a2c511"><th>User Input</th><th>Display</th><th>Sum so Far</th><th>Add. Op.</th><th>Factor so Far</th><th>Mult. Op.</th><th>Waiting for Operand?</th></tr>

<tr valign="top" bgcolor="#e0e0e0"><td>1</td><td>1</td><td>0</td><td></td><td></td><td></td><td><tt>false</tt></td></tr>

<tr valign="top" bgcolor="#e0e0e0"><td>1 + 2</td><td>2</td><td>1</td><td>+</td><td></td><td></td><td><tt>false</tt></td></tr>

<tr valign="top" bgcolor="#e0e0e0"><td>1 + 2 � 3</td><td>3</td><td>1</td><td>+</td><td>2</td><td>�</td><td><tt>false</tt></td></tr>

<tr valign="top" bgcolor="#e0e0e0"><td>1 + 2 � 3 - 4</td><td>4</td><td>1.66667</td><td>-</td><td></td><td></td><td><tt>false</tt></td></tr>

</table>

100

Unary operators, such as Sqrt, require no special handling; they can be applied immediately since the operand is already known when the operator button is clicked.

101

<pre>  QLineEdit *display;

102

103

enum { NumDigitButtons = 10 };

104

Button *digitButtons[NumDigitButtons];

105

106

Button *pointButton;

107

Button *changeSignButton;

108

Button *backspaceButton;

109

Button *clearButton;

110

Button *clearAllButton;

111

Button *clearMemoryButton;

112

Button *readMemoryButton;

113

Button *setMemoryButton;

114

Button *addToMemoryButton;

115

116

Button *divisionButton;

117

Button *timesButton;

118

Button *minusButton;

119

Button *plusButton;

120

Button *squareRootButton;

121

Button *powerButton;

122

Button *reciprocalButton;

123

Button *equalButton;

124

};</pre>

125

Finally, we declare the variables associated with the child widgets.

126

127

<h2>Calculator Class Implementation</h2>

128

<pre>  Calculator::Calculator(QWidget *parent)

129

: QDialog(parent)

130

{

131

sumInMemory = 0.0;

132

sumSoFar = 0.0;

133

factorSoFar = 0.0;

134

waitingForOperand = true;</pre>

135

In the constructor, we initialize the calculator's state. The <tt>pendingAdditiveOperator</tt> and <tt>pendingMultiplicativeOperator</tt> variables don't need to be initialized explicitly, because the <a href="qstring.html">QString</a> constructor initializes them to empty strings.

136

<pre>  display = new QLineEdit("0");

137

display->setReadOnly(true);

138

display->setAlignment(Qt::AlignRight);

139

display->setMaxLength(15);

140

display->installEventFilter(this);

141

142

QFont font = display->font();

143

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

144

display->setFont(font);</pre>

145

We create the <a href="qlineedit.html">QLineEdit</a> representing the calculator's display and set up some of its properties. In particular, we set it to be read-only. The <a href="qobject.html#installEventFilter">QObject::installEventFilter</a>() call installs the <tt>Calculator</tt> object (<tt>this</tt>) as an event filter for <tt>display</tt>; we will come back to it later.

146

We also enlarge <tt>display</tt>'s font by 8 points.

147

<pre>  QColor digitColor(150, 205, 205);

148

QColor backspaceColor(225, 185, 135);

149

QColor memoryColor(100, 155, 155);

150

QColor operatorColor(155, 175, 195);

151

152

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

153

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

154

SLOT(digitClicked()));

155

}

156

157

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

158

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

159

160

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

161

SLOT(backspaceClicked()));

162

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

163

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

164

SLOT(clearAll()));

165

166

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

167

SLOT(clearMemory()));

168

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

169

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

170

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

171

SLOT(addToMemory()));

172

173

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

174

SLOT(multiplicativeOperatorClicked()));

175

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

176

SLOT(multiplicativeOperatorClicked()));

177

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

178

SLOT(additiveOperatorClicked()));

179

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

180

SLOT(additiveOperatorClicked()));

181

182

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

183

SLOT(unaryOperatorClicked()));

184

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

185

SLOT(unaryOperatorClicked()));

186

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

187

SLOT(unaryOperatorClicked()));

188

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

189

SLOT(equalClicked()));</pre>

190

We define four colors by specifying the red, green, and blue components on a scale from 0 to 255. Then, for each button, we call the private <tt>createButton()</tt> function with the proper text label, the associated color, and a slot to connect to the button.

191

To make the Clear All and = buttons stand out, we call <a href="qcolor.html#light">QColor::light</a>() with a factor of 120%, making these buttons 20% brighter than their neighbors.

192

<pre>  QGridLayout *mainLayout = new QGridLayout;

193

mainLayout->setSizeConstraint(QLayout::SetFixedSize);

194

195

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

196

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

197

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

198

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

199

200

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

201

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

202

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

203

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

204

205

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

206

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

207

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

208

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

209

}

210

211

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

212

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

213

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

214

215

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

216

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

217

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

218

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

219

220

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

221

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

222

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

223

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

224

setLayout(mainLayout);

225

226

setWindowTitle(tr("Calculator"));

227

}</pre>

228

The layout is handled by a single <a href="qgridlayout.html">QGridLayout</a>. The <a href="qlayout.html#sizeConstraint-prop">QLayout::setSizeConstraint</a>() call ensures that the <tt>Calculator</tt> widget is always shown as its optimal size (its <a href="qwidget.html#sizeHint-prop">size hint</a>), preventing the user from resizing the calculator. The size hint is determined by the size and <a href="qwidget.html#sizePolicy-prop">size policy</a> of the child widgets.

229

Most child widgets occupy only one cell in the grid layout. For these, we only need to pass a row and a column to <a href="qgridlayout.html#addWidget">QGridLayout::addWidget</a>(). The <tt>display</tt>, <tt>backspaceButton</tt>, <tt>clearButton</tt>, and <tt>clearAllButton</tt> widgets occupy more than one column; for these we must also pass a row span and a column span.

230

<pre>  void Calculator::digitClicked()

231

{

232

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

233

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

234

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

235

return;

236

237

if (waitingForOperand) {

238

display->clear();

239

waitingForOperand = false;

240

}

241

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

242

}</pre>

243

Pressing one of the calculator's digit buttons will emit the button's <a href="qabstractbutton.html#clicked">clicked()</a> signal, which will trigger the <tt>digitClicked()</tt> slot.

244

First, we find out which button sent the signal using <a href="qobject.html#sender">QObject::sender</a>(). This function returns the sender as a <a href="qobject.html">QObject</a> pointer. Since we know that the sender is a <tt>Button</tt> object, we can safely cast the <a href="qobject.html">QObject</a>. We could have used a C-style cast or a C++ <tt>static_cast<>()</tt>, but as a defensive programming technique we use a <a href="qobject.html#qobject_cast">qobject_cast</a>(). The advantage is that if the object has the wrong type, a null pointer is returned. Crashes due to null pointers are much easier to diagnose than crashes due to unsafe casts. Once we have the button, we extract the operator using <a href="qabstractbutton.html#text-prop">QToolButton::text</a>().

245

The slot needs to consider two situations in particular. If <tt>display</tt> contains "0" and the user clicks the 0 button, it would be silly to show "00". And if the calculator is in a state where it is waiting for a new operand, the new digit is the first digit of that new operand; in that case, any result of a previous calculation must be cleared first.

246

At the end, we append the new digit to the value in the display.

247

<pre>  void Calculator::unaryOperatorClicked()

248

{

249

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

250

QString clickedOperator = clickedButton->text();

251

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

252

double result;

253

254

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

255

if (operand < 0.0) {

256

abortOperation();

257

return;

258

}

259

result = sqrt(operand);

260

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

261

result = pow(operand, 2.0);

262

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

263

if (operand == 0.0) {

264

abortOperation();

265

return;

266

}

267

result = 1.0 / operand;

268

}

269

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

270

waitingForOperand = true;

271

}</pre>

272

The <tt>unaryOperatorClicked()</tt> slot is called whenever one of the unary operator buttons is clicked. Again a pointer to the clicked button is retrieved using <a href="qobject.html#sender">QObject::sender</a>(). The operator is extracted from the button's text and stored in <tt>clickedOperator</tt>. The operand is obtained from <tt>display</tt>.

273

Then we perform the operation. If Sqrt is applied to a negative number or 1/x to zero, we call <tt>abortOperation()</tt>. If everything goes well, we display the result of the operation in the line edit and we set <tt>waitingForOperand</tt> to <tt>true</tt>. This ensures that if the user types a new digit, the digit will be considered as a new operand, instead of being appended to the current value.

274

<pre>  void Calculator::additiveOperatorClicked()

275

{

276

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

277

QString clickedOperator = clickedButton->text();

278

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

279

The <tt>additiveOperatorClicked()</tt> slot is called when the user clicks the + or - button.

280

Before we can actually do something about the clicked operator, we must handle any pending operations. We start with the multiplicative operators, since these have higher precedence than additive operators:

281

<pre>  if (!pendingMultiplicativeOperator.isEmpty()) {

282

if (!calculate(operand, pendingMultiplicativeOperator)) {

283

abortOperation();

284

return;

285

}

286

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

287

operand = factorSoFar;

288

factorSoFar = 0.0;

289

pendingMultiplicativeOperator.clear();

290

}</pre>

291

If � or � has been clicked earlier, without clicking = afterward, the current value in the display is the right operand of the � or � operator and we can finally perform the operation and update the display.

292

<pre>  if (!pendingAdditiveOperator.isEmpty()) {

293

if (!calculate(operand, pendingAdditiveOperator)) {

294

abortOperation();

295

return;

296

}

297

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

298

} else {

299

sumSoFar = operand;

300

}</pre>

301

If + or - has been clicked earlier, <tt>sumSoFar</tt> is the left operand and the current value in the display is the right operand of the operator. If there is no pending additive operator, <tt>sumSoFar</tt> is simply set to be the text in the display.

302

<pre>  pendingAdditiveOperator = clickedOperator;

303

waitingForOperand = true;

304

}</pre>

305

Finally, we can take care of the operator that was just clicked. Since we don't have the right-hand operand yet, we store the clicked operator in the <tt>pendingAdditiveOperator</tt> variable. We will apply the operation later, when we have a right operand, with <tt>sumSoFar</tt> as the left operand.

306

<pre>  void Calculator::multiplicativeOperatorClicked()

307

{

308

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

309

QString clickedOperator = clickedButton->text();

310

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

311

312

if (!pendingMultiplicativeOperator.isEmpty()) {

313

if (!calculate(operand, pendingMultiplicativeOperator)) {

314

abortOperation();

315

return;

316

}

317

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

318

} else {

319

factorSoFar = operand;

320

}

321

322

pendingMultiplicativeOperator = clickedOperator;

323

waitingForOperand = true;

324

}</pre>

325

The <tt>multiplicativeOperatorClicked()</tt> slot is similar to <tt>additiveOperatorClicked()</tt>. We don't need to worry about pending additive operators here, because multiplicative operators have precedence over additive operators.

326

<pre>  void Calculator::equalClicked()

327

{

328

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

329

330

if (!pendingMultiplicativeOperator.isEmpty()) {

331

if (!calculate(operand, pendingMultiplicativeOperator)) {

332

abortOperation();

333

return;

334

}

335

operand = factorSoFar;

336

factorSoFar = 0.0;

337

pendingMultiplicativeOperator.clear();

338

}

339

if (!pendingAdditiveOperator.isEmpty()) {

340

if (!calculate(operand, pendingAdditiveOperator)) {

341

abortOperation();

342

return;

343

}

344

pendingAdditiveOperator.clear();

345

} else {

346

sumSoFar = operand;

347

}

348

349

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

350

sumSoFar = 0.0;

351

waitingForOperand = true;

352

}</pre>

353

Like in <tt>additiveOperatorClicked()</tt>, we start by handing any pending multiplicative and additive operators. Then we display <tt>sumSoFar</tt> and reset the variable to zero. Resetting the variable to zero is necessary to avoid counting the value twice.

354

<pre>  void Calculator::pointClicked()

355

{

356

if (waitingForOperand)

357

display->setText("0");

358

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

359

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

360

waitingForOperand = false;

361

}</pre>

362

The <tt>pointClicked()</tt> slot adds a decimal point to the content in <tt>display</tt>.

363

<pre>  void Calculator::changeSignClicked()

364

{

365

QString text = display->text();

366

double value = text.toDouble();

367

368

if (value > 0.0) {

369

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

370

} else if (value < 0.0) {

371

text.remove(0, 1);

372

}

373

display->setText(text);

374

}</pre>

375

The <tt>changeSignClicked()</tt> slot changes the sign of the value in <tt>display</tt>. If the current value is positive, we prepend a minus sign; if the current value is negative, we remove the first character from the value (the minus sign).

376

<pre>  void Calculator::backspaceClicked()

377

{

378

if (waitingForOperand)

379

return;

380

381

QString text = display->text();

382

text.chop(1);

383

if (text.isEmpty()) {

384

text = "0";

385

waitingForOperand = true;

386

}

387

display->setText(text);

388

}</pre>

389

The <tt>backspaceClicked()</tt> removes the rightmost character in the display. If we get an empty string, we show "0" and set <tt>waitingForOperand</tt> to <tt>true</tt>.

390

<pre>  void Calculator::clear()

391

{

392

if (waitingForOperand)

393

return;

394

395

display->setText("0");

396

waitingForOperand = true;

397

}</pre>

398

The <tt>clear()</tt> slot resets the current operand to zero. It is equivalent to clicking Backspace enough times to erase the entire operand.

399

<pre>  void Calculator::clearAll()

400

{

401

sumSoFar = 0.0;

402

factorSoFar = 0.0;

403

pendingAdditiveOperator.clear();

404

pendingMultiplicativeOperator.clear();

405

display->setText("0");

406

waitingForOperand = true;

407

}</pre>

408

The <tt>clearAll()</tt> slot resets the calculator to its initial state.

409

<pre>  void Calculator::clearMemory()

410

{

411

sumInMemory = 0.0;

412

}

413

414

void Calculator::readMemory()

415

{

416

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

417

waitingForOperand = true;

418

}

419

420

void Calculator::setMemory()

421

{

422

equalClicked();

423

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

424

}

425

426

void Calculator::addToMemory()

427

{

428

equalClicked();

429

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

430

}</pre>

431

The <tt>clearMemory()</tt> slot erases the sum kept in memory, <tt>readMemory()</tt> displays the sum as an operand, <tt>setMemory()</tt> replace the sum in memory with the current sum, and <tt>addToMemory()</tt> adds the current value to the value in memory. For <tt>setMemory()</tt> and <tt>addToMemory()</tt>, we start by calling <tt>equalClicked()</tt> to update <tt>sumSoFar</tt> and the value in the display.

432

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

433

const char *member)

434

{

435

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

436

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

437

return button;

438

}</pre>

439

The private <tt>createButton()</tt> function is called from the constructor to create calculator buttons.

440

<pre>  void Calculator::abortOperation()

441

{

442

clearAll();

443

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

444

}</pre>

445

The private <tt>abortOperation()</tt> function is called whenever a calculation fails. It resets the calculator state and displays "####".

446

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

447

{

448

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

449

sumSoFar += rightOperand;

450

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

451

sumSoFar -= rightOperand;

452

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

453

factorSoFar *= rightOperand;

454

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

455

if (rightOperand == 0.0)

456

return false;

457

factorSoFar /= rightOperand;

458

}

459

return true;

460

}</pre>

461

The private <tt>calculate()</tt> function performs a binary operation. The right operand is given by <tt>rightOperand</tt>. For additive operators, the left operand is <tt>sumSoFar</tt>; for multiplicative operators, the left operand is <tt>factorSoFar</tt>. The function return <tt>false</tt> if a division by zero occurs.

462

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

463

{

464

if (target == display) {

465

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

466

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

467

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

468

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

469

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

470

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

471

QPalette newPalette = palette();

472

newPalette.setColor(QPalette::Base,

473

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

474

newPalette.setColor(QPalette::Text,

475

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

476

display->setPalette(newPalette);

477

} else {

478

display->setPalette(palette());

479

}

480

return true;

481

}

482

}

483

return QDialog::eventFilter(target, event);

484

}</pre>

485

The <tt>eventFilter()</tt> function is inherited from <a href="qobject.html">QObject</a>. In the constructor, we installed it on <tt>display</tt>. While the user holds the left mouse button pressed, we use an inverted color scheme. Any other events are ignored and simply passed on to the base class's <a href="qobject.html#eventFilter">eventFilter()</a> implementation.

486

487

<h2>Button Class Definition</h2>

488

Let's now take a look at the <tt>Button</tt> class:

489

<pre>  class Button : public QToolButton

490

{

491

Q_OBJECT

492

493

public:

494

Button(const QString &text, const QColor &color, QWidget *parent = 0);

495

496

QSize sizeHint() const;

497

};</pre>

498

The <tt>Button</tt> class has a convenience constructor that takes a text label and a color, and it reimplements <a href="qwidget.html#sizeHint-prop">QWidget::sizeHint</a>() to provide more space around the text than what <a href="qtoolbutton.html">QToolButton</a> normally provides.

499

500

<h2>Button Class Implementation</h2>

501

<pre>  Button::Button(const QString &text, const QColor &color, QWidget *parent)

502

: QToolButton(parent)

503

{

504

setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);

505

setText(text);

506

507

QPalette newPalette = palette();

508

newPalette.setColor(QPalette::Button, color);

509

setPalette(newPalette);

510

}</pre>

511

The buttons' appearance is determined by the layout of the calculator widget through the size and <a href="qwidget.html#sizePolicy-prop">size policy</a> of the layout's child widgets. The call to the <a href="qwidget.html#sizePolicy-prop">setSizePolicy()</a> function in the constructor ensures that the button will expand horizontally to fill all the available space; by default, <a href="qtoolbutton.html">QToolButton</a>s don't expand to fill available space. Without this call, the different buttons in a same column would have different widths.

512

<pre>  QSize Button::sizeHint() const

513

{

514

QSize size = QToolButton::sizeHint();

515

size.rheight() += 20;

516

size.rwidth() = qMax(size.width(), size.height());

517

return size;

518

}</pre>

519

In <a href="qwidget.html#sizeHint-prop">sizeHint()</a>, we try to return a size that looks good for most buttons. We reuse the size hint of the base class (<a href="qtoolbutton.html">QToolButton</a>) but modify it in the following ways:

520

<ul>

521

<li>We add 20 to the <a href="qsize.html#height">height</a> component of the size hint.</li>

522

<li>We make the <a href="qsize.html#width">width</a> component of the size hint at least as much as the <a href="qsize.html#width">height</a>.</li>

523

</ul>

524

This ensures that with most fonts, the digit and operator buttons will be square, without truncating the text on the Backspace, Clear, and Clear All buttons.

525

The screenshot below shows how the <tt>Calculator</tt> widget would would like if we didn't set the horizontal size policy to <a href="qsizepolicy.html#Policy-enum">QSizePolicy::Expanding</a> in the constructor and if we didn't reimplement <a href="qwidget.html#sizeHint-prop">QWidget::sizeHint</a>().

526

<center><img src="images/calculator-ugly.png" alt="The Calculator example with default size policies and size hints" /></center>This completes the Calculator example. Trolltech will send a T-shirt to the first finder of a bug in the example.

527

528

529

530

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

531

532

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

533

</html>

Older »