1
00:00:00,000 --> 00:00:00,490

2
00:00:00,490 --> 00:00:03,350
ALTAVOZ 1: Vamos a escribir un programa con
una interfaz gráfica de usuario que también

3
00:00:03,350 --> 00:00:04,580
incluye etiqueta.

4
00:00:04,580 --> 00:00:07,940
Y en esta etiqueta, que vamos a almacenar
número, aunque sea como una cadena.

5
00:00:07,940 --> 00:00:10,880
Y vamos a actualizar esa etiqueta
otra vez, y otra vez, y otra vez.

6
00:00:10,880 --> 00:00:15,040
Así que en última instancia contamos
desde 50 a cero.

7
00:00:15,040 --> 00:00:20,910
Glabel, llamándolo etiqueta, obtiene el
valor de la nueva glabel volver.

8
00:00:20,910 --> 00:00:22,900
Ahora, yo no voy a dar esta
valor de la etiqueta, sin embargo, así que voy a

9
00:00:22,900 --> 00:00:25,040
puesto en comillas, cierra.

10
00:00:25,040 --> 00:00:29,080
>> Siguiente llamémosle setFont, pasando
en la etiqueta, y vamos a pasar en

11
00:00:29,080 --> 00:00:32,910
específicamente una fuente llamada
SansSerif 36 puntos.

12
00:00:32,910 --> 00:00:36,370
Una fuente que pasa a existir
el interior del aparato CS50.

13
00:00:36,370 --> 00:00:41,940
Entonces, finalmente, vamos a añadir la etiqueta
a la ventana de la siguiente manera.

14
00:00:41,940 --> 00:00:44,580
Ahora, vamos a proceder a inducir un
bucle que va a contar

15
00:00:44,580 --> 00:00:46,400
de 50 a cero.

16
00:00:46,400 --> 00:00:49,520
Y dentro de ese bucle, vamos iterativa
actualizar la etiqueta y

17
00:00:49,520 --> 00:00:55,800
mostrarlo en la pantalla, para, int i
consigue 50, i es mayor que, o igual

18
00:00:55,800 --> 00:00:59,750
a cero, i menos, menos.

19
00:00:59,750 --> 00:01:02,090
>> Ahora las etiquetas, resulta que,
tienen que ser cadenas.

20
00:01:02,090 --> 00:01:04,110
Pero en realidad estoy contando,
el uso de números enteros.

21
00:01:04,110 --> 00:01:07,750
Así que de alguna manera me voy a tener que convertir
el número entero, i, a una cadena

22
00:01:07,750 --> 00:01:09,010
representación flecha.

23
00:01:09,010 --> 00:01:12,480
Para ello vamos a declarar
Char s abrazadera tres.

24
00:01:12,480 --> 00:01:15,500
Así que tenemos suficiente espacio de almacenamiento
para número de dos dígitos, seguido por una

25
00:01:15,500 --> 00:01:16,910
terminador nulo.

26
00:01:16,910 --> 00:01:22,480
Luego de dejar la llamada s print f paso
en s, pasando cita,

27
00:01:22,480 --> 00:01:24,220
ciento unquote i.

28
00:01:24,220 --> 00:01:26,960
Indicando que en verdad queremos
para dar formato a un número entero.

29
00:01:26,960 --> 00:01:29,420
Pasando Finalmente en i sí mismo.

30
00:01:29,420 --> 00:01:34,100
En otras palabras, s print f, o cadena
print f, al igual que la impresión f, espera un

31
00:01:34,100 --> 00:01:37,450
cadena de formato seguido de algunas variables
a sustituir en esa

32
00:01:37,450 --> 00:01:38,430
cadena de formato.

33
00:01:38,430 --> 00:01:41,910
Pero también acepta es su primera
argumento, la ubicación en la que

34
00:01:41,910 --> 00:01:44,400
le gustaría almacenar la cadena
que ha representado

35
00:01:44,400 --> 00:01:45,830
con la cadena de formato.

36
00:01:45,830 --> 00:01:52,540
>> Así que la próxima, vamos a seguir adelante y de establecimiento de llamada,
etiqueta, que pasa en la etiqueta, pasando s.

37
00:01:52,540 --> 00:01:56,430
Ahora, por fin, sólo porque este etiquetas
anchura va a cambiar con el tiempo como

38
00:01:56,430 --> 00:02:00,640
contamos abajo de 50, a 49, poner los puntos,
punto, punto, a nueve a ocho.

39
00:02:00,640 --> 00:02:03,170
Que no son tan amplias como
un número de dos dígitos es.

40
00:02:03,170 --> 00:02:05,570
Vamos a proceder a calcular de forma dinámica
lo que la anchura de esta

41
00:02:05,570 --> 00:02:08,930
etiqueta debe ser y luego asegurarse de que
que siempre ha centrado en la pantalla.

42
00:02:08,930 --> 00:02:12,390
Estoy primero va a declarar un matrimonio,
llamándolo X, y luego me voy a

43
00:02:12,390 --> 00:02:16,880
almacenar en el interior de x, el resultado de get
anchura, que pasa en la anchura de la

44
00:02:16,880 --> 00:02:22,120
toda la ventana, menos conseguir la anchura,
que pasa en la etiqueta.

45
00:02:22,120 --> 00:02:24,880
Entonces dividiendo todo por dos.

46
00:02:24,880 --> 00:02:29,660
Del mismo modo que voy a declarar y para ser
igual para conseguir la altura del conjunto

47
00:02:29,660 --> 00:02:37,280
altura de la ventana, menos get de sólo el
etiqueta, y dividir que por dos.

48
00:02:37,280 --> 00:02:40,680
Por último, voy a llamar a SetLocation,
que pasa en la etiqueta,

49
00:02:40,680 --> 00:02:43,180
pasando en x, que pasa en y.

50
00:02:43,180 --> 00:02:45,970
Hay por el posicionamiento de la
etiquetar en x coma y.

51
00:02:45,970 --> 00:02:49,290
>> Por último, de manera que esta cuenta atrás no se
suceder demasiado rápido dejar de

52
00:02:49,290 --> 00:02:53,350
hacer una pausa, para decir, 100 milisegundos entre
cada actualización de la etiqueta.

53
00:02:53,350 --> 00:02:56,320
Para ello, podemos llamar a la pausa
función, que está definido en el

54
00:02:56,320 --> 00:03:00,390
Stanford biblioteca portátil,
simplemente de la siguiente manera.

55
00:03:00,390 --> 00:03:04,230
>> Ahora vamos a guardar, compilar,
y ejecutar este programa.

56
00:03:04,230 --> 00:03:08,320
Hacer etiqueta, barra de punto, etiqueta.

57
00:03:08,320 --> 00:03:11,000
Ahí está mi interfaz de usuario
la cuenta regresiva desde 50.

58
00:03:11,000 --> 00:03:14,570
Cuenta abajo, y hacia abajo,
y abajo, y hecho.

59
00:03:14,570 --> 00:03:16,992