Coordinate System

  QPainter painter(this);

  painter.setPen(Qt::darkGreen);
  painter.drawRect(1, 2, 6, 4);

  QPainter painter(this);

  painter.setPen(Qt::darkGreen);
  painter.drawLine(2, 7, 6, 1);

  QPainter painter(this);
  painter.setRenderHint(
      QPainter::Antialiasing);
  painter.setPen(Qt::darkGreen);
  painter.drawRect(1, 2, 6, 4);

  QPainter painter(this);
  painter.setRenderHint(
      QPainter::Antialiasing);
  painter.setPen(Qt::darkGreen);
  painter.drawLine(2, 7, 6, 1);

  void AnalogClockWindow::render(QPainter *p)
  {
      static const QPoint hourHand[3] = {
          QPoint(7, 8),
          QPoint(-7, 8),
          QPoint(0, -40)
      };
      static const QPoint minuteHand[3] = {
          QPoint(7, 8),
          QPoint(-7, 8),
          QPoint(0, -70)
      };

      QColor hourColor(127, 0, 127);
      QColor minuteColor(0, 127, 127, 191);

      p->setRenderHint(QPainter::Antialiasing);
      p->translate(width() / 2, height() / 2);

      int side = qMin(width(), height());
      p->scale(side / 200.0, side / 200.0);

We translate the coordinate system so that point (0, 0) is in the widget's center, instead of being at the top-left corner. We also scale the system by side / 100, where side is either the widget's width or the height, whichever is shortest. We want the clock to be square, even if the device isn't.

This will give us a 200 x 200 square area, with the origin (0, 0) in the center, that we can draw on. What we draw will show up in the largest possible square that will fit in the widget.

See also the Window-Viewport Conversion section.

      QTime time = QTime::currentTime();

      p->save();
      p->rotate(30.0 * ((time.hour() + time.minute() / 60.0)));
      p->drawConvexPolygon(hourHand, 3);
      p->restore();

We draw the clock's hour hand by rotating the coordinate system and calling QPainter::drawConvexPolygon(). Thank's to the rotation, it's drawn pointed in the right direction.

The polygon is specified as an array of alternating x, y values, stored in the hourHand static variable (defined at the beginning of the function), which corresponds to the four points (2, 0), (0, 2), (-2, 0), and (0, -25).

The calls to QPainter::save() and QPainter::restore() surrounding the code guarantees that the code that follows won't be disturbed by the transformations we've used.

      p->save();
      p->rotate(6.0 * (time.minute() + time.second() / 60.0));
      p->drawConvexPolygon(minuteHand, 3);
      p->restore();

We do the same for the clock's minute hand, which is defined by the four points (1, 0), (0, 1), (-1, 0), and (0, -40). These coordinates specify a hand that is thinner and longer than the minute hand.

      p->setPen(minuteColor);

      for (int j = 0; j < 60; ++j) {
          if ((j % 5) != 0)
              p->drawLine(92, 0, 96, 0);
          p->rotate(6.0);
      }

Finally, we draw the clock face, which consists of twelve short lines at 30-degree intervals. At the end of that, the painter is rotated in a way which isn't very useful, but we're done with painting so that doesn't matter.