Reloj analógico
El ejemplo del reloj analógico muestra cómo dibujar el contenido de un widget personalizado.

Captura de pantalla del ejemplo del reloj analógico
Este ejemplo también muestra cómo se pueden utilizar las funciones de transformación y escalado de QPainter para facilitar el dibujo de widgets personalizados.
Definición de la clase AnalogClock
La clase ` AnalogClock ` proporciona un widget de reloj con manecillas de horas, minutos y segundos que se actualiza automáticamente cada segundo. Creamos una subclase de ` QWidget ` y reimplementamos la función estándar ` paintEvent()` para dibujar la esfera del reloj:
class AnalogClock : public QWidget
{
Q_OBJECT
public:
AnalogClock(QWidget *parent = nullptr);
protected:
void paintEvent(QPaintEvent *event) override;
};Implementación de la clase `AnalogClock`
Cuando se crea el widget, configuramos un temporizador de un segundo para llevar la cuenta de la hora actual y lo conectamos a la ranura estándar update(), de modo que la esfera del reloj se actualice cuando el temporizador emita la señal timeout(). Por último, redimensionamos el widget para que se muestre con un tamaño razonable.
AnalogClock::AnalogClock(QWidget *parent)
: QWidget(parent)
{
QTimer *timer = new QTimer(this);
connect(timer, &QTimer::timeout, this, QOverload<>::of(&AnalogClock::update));
timer->start(1000);
setWindowTitle(tr("Analog Clock"));
resize(200, 200);
}La función paintEvent() se invoca cada vez que es necesario actualizar el contenido del widget. Esto ocurre cuando el widget se muestra por primera vez y cuando se oculta y luego se vuelve a mostrar, pero también se ejecuta cuando se invoca la ranura update() del widget. Dado que hemos conectado la señal timeout() del temporizador a esta ranura, se invocará al menos una vez por segundo.
Antes de configurar el pintor y dibujar el reloj, definimos primero tres listas de « QPoint» y tres « QColor» que se utilizarán para las manecillas de las horas, los minutos y los segundos. Utilizamos la función palette() para obtener los colores adecuados que encajen con el resto de la ventana, tanto en modo claro como en modo oscuro. Las manecillas de las horas y los minutos se dibujan en el color de primer plano, mientras que la manecilla de los segundos se dibuja en el color de acento.
También determinamos la longitud del lado más corto del widget para que la esfera del reloj quepa dentro de él. Además, resulta útil determinar la hora actual antes de empezar a dibujar.
void AnalogClock::paintEvent(QPaintEvent *)
{
static const QPoint hourHand[4] = {
QPoint(5, 14),
QPoint(-5, 14),
QPoint(-4, -71),
QPoint(4, -71)
};
static const QPoint minuteHand[4] = {
QPoint(4, 14),
QPoint(-4, 14),
QPoint(-3, -89),
QPoint(3, -89)
};
static const QPoint secondsHand[4] = {
QPoint(1, 14),
QPoint(-1, 14),
QPoint(-1, -89),
QPoint(1, -89)
};
const QColor hourColor(palette().color(QPalette::Text));
const QColor minuteColor(palette().color(QPalette::Text));
const QColor secondsColor(palette().color(QPalette::Accent));
int side = qMin(width(), height());El contenido de los widgets personalizados se dibuja con un ` QPainter`. Los `painters` se pueden utilizar para dibujar en cualquier ` QPaintDevice`, pero suelen emplearse con widgets, por lo que pasamos la instancia del widget al constructor del `painter`.
Llamamos a ` QPainter::setRenderHint()` con ` QPainter::Antialiasing ` para activar el suavizado. Esto hace que el dibujo de las líneas diagonales sea mucho más fluido.
painter.setRenderHint(QPainter::Antialiasing);La traslación desplaza el origen al centro del widget, y la operación de escalado garantiza que las siguientes operaciones de dibujo se escalen para ajustarse al widget. Utilizamos un factor de escala que nos permite usar coordenadas x e y entre -100 y 100, y que garantiza que estas se encuentren dentro de la longitud del lado más corto del widget.
painter.translate(width() / 2, height() / 2);
painter.scale(side / 200.0, side / 200.0);Para simplificar nuestro código, dibujaremos una esfera de reloj de tamaño fijo que se colocará y escalará de manera que quede en el centro del widget.
El «painter» se encarga de todas las transformaciones realizadas durante el evento de pintura y garantiza que todo se dibuje correctamente. Dejar que el «painter» se ocupe de las transformaciones suele ser más sencillo que realizar cálculos manuales solo para dibujar el contenido de un widget personalizado.

Configuramos el lápiz como « Qt::NoPen » porque no queremos ningún contorno, y utilizamos un pincel sólido con el color adecuado para mostrar las horas. Los pinceles se utilizan para rellenar polígonos y otras formas geométricas.
painter.setPen(Qt::NoPen);
painter.setBrush(hourColor);Dibujamos primero la manecilla de las horas, utilizando una fórmula que gira el sistema de coordenadas en sentido antihorario un número de grados determinado por la hora y el minuto actuales. Esto significa que la manecilla se mostrará girada en sentido horario en la cantidad necesaria. Guardamos y restauramos la matriz de transformación antes y después de la rotación instanciando un ` QPainterStateGuard `, ya que queremos colocar la manecilla de los minutos sin tener que tener en cuenta ninguna rotación previa.
{
QPainterStateGuard guard(&painter);
painter.rotate(30.0 * ((time.hour() + time.minute() / 60.0)));
painter.drawConvexPolygon(hourHand, 4);
}Dibujamos marcadores alrededor del borde del reloj para cada hora, del mismo color que la manecilla de las horas. Dibujamos cada marcador y, a continuación, giramos el sistema de coordenadas para que el pintor esté listo para el siguiente.
for (int i = 0; i < 12; ++i) {
painter.drawRect(73, -3, 16, 6);
painter.rotate(30.0);
}La manecilla de los minutos se gira y se dibuja de forma similar a la manecilla de las horas.
painter.setBrush(minuteColor);
{
QPainterStateGuard guard(&painter);
painter.rotate(6.0 * time.minute());
painter.drawConvexPolygon(minuteHand, 4);
}Para la manecilla de los segundos hacemos lo mismo y añadimos dos círculos a modo de destaque visual.
painter.setBrush(secondsColor);
{
QPainterStateGuard guard(&painter);
painter.rotate(6.0 * time.second());
painter.drawConvexPolygon(secondsHand, 4);
painter.drawEllipse(-3, -3, 6, 6);
painter.drawEllipse(-5, -68, 10, 10);
}Por último, dibujamos marcadores alrededor del borde del reloj, indicando los minutos y los segundos. Esta vez los dibujamos como líneas y, por lo tanto, configuramos el lápiz con el color correspondiente.
painter.setPen(minuteColor);
for (int j = 0; j < 60; ++j) {
painter.drawLine(92, 0, 96, 0);
painter.rotate(6.0);
}© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.