1
00:00:00,000 --> 00:00:00,260

2
00:00:00,260 --> 00:00:02,980
>> COLUNA 1: Vamos agora escrever um programa
que de alguma forma interage com o meu mouse.

3
00:00:02,980 --> 00:00:06,150
Em particular, vamos instanciar,
ou criar uma janela.

4
00:00:06,150 --> 00:00:09,700
E, em seguida, vamos ouvir, por assim dizer,
dentro dessa janela para cliques do mouse.

5
00:00:09,700 --> 00:00:12,940
E assim que detectar um clique do mouse,
vamos imprimir com printf o

6
00:00:12,940 --> 00:00:17,830
coordena x vírgula y desse rato
clique, em relação a essa janela.

7
00:00:17,830 --> 00:00:18,880
>> Aqui vamos nós.

8
00:00:18,880 --> 00:00:24,670
Vamos incluir gevents.h primeiro, o que é
outro arquivo de cabeçalho no Stanford

9
00:00:24,670 --> 00:00:27,670
biblioteca portátil que relaciona
para eventos gráficas.

10
00:00:27,670 --> 00:00:33,480
Vamos também incluir gwindow.h, que
contém funções relacionadas ao Windows.

11
00:00:33,480 --> 00:00:37,390
Vamos agora declarar principal
da maneira usual.

12
00:00:37,390 --> 00:00:39,680
>> E vamos agora instanciar essa janela.

13
00:00:39,680 --> 00:00:40,830
Gwindow -

14
00:00:40,830 --> 00:00:42,180
vamos chamá-lo janela -

15
00:00:42,180 --> 00:00:44,710
é igual newGwindow.

16
00:00:44,710 --> 00:00:49,150
E eu vou especificar arbitrariamente um
largura de 320 pixels e uma altura de

17
00:00:49,150 --> 00:00:51,460
240 pixels.

18
00:00:51,460 --> 00:00:54,380
>> Agora precisamos continuar a ouvir
para eventos do mouse, por assim

19
00:00:54,380 --> 00:00:56,020
falar, dentro dessa janela.

20
00:00:56,020 --> 00:00:59,450
Agora eventos podem incluir cliques
ou arrasta ou movimentos.

21
00:00:59,450 --> 00:01:01,400
Mas, por agora vamos nos concentrar
apenas em cliques.

22
00:01:01,400 --> 00:01:05,740
Eu estou indo para induzir intencionalmente um
ciclo infinito com uma construção de tempo,

23
00:01:05,740 --> 00:01:08,770
simplesmente para que este programa é executado
para sempre, ou pelo menos até que eu clique no

24
00:01:08,770 --> 00:01:10,450
X no canto superior direito.

25
00:01:10,450 --> 00:01:13,670
>> Para isso, vamos fazer enquanto verdade.

26
00:01:13,670 --> 00:01:16,900
E, em seguida, no interior do referido circuito,
vamos primeiro cheque para a

27
00:01:16,900 --> 00:01:18,430
evento de mouse como se segue.

28
00:01:18,430 --> 00:01:21,200
Vamos declarar uma GEvent, por assim dizer.

29
00:01:21,200 --> 00:01:22,920
>> Vamos chamar o evento variável.

30
00:01:22,920 --> 00:01:27,740
E nós estamos indo para armazenar em que o
valor de GetNextEvent retornar, passando

31
00:01:27,740 --> 00:01:31,970
em especial uma constante, a qual por
convenção está escrito em letras maiúsculas,

32
00:01:31,970 --> 00:01:34,060
chamado mouse_event.

33
00:01:34,060 --> 00:01:36,800
Em outras palavras, algures nesta
Stanford biblioteca portátil, há um

34
00:01:36,800 --> 00:01:39,120
constante chamada MOUSE_CLICED.

35
00:01:39,120 --> 00:01:43,040
E não é uma função definida que é
chamado GetNextEvent, cuja finalidade em

36
00:01:43,040 --> 00:01:44,360
a vida é para fazer exatamente isso.

37
00:01:44,360 --> 00:01:48,330
Atentem para, em seguida, quando se ouve um,
retorna o próximo evento que é

38
00:01:48,330 --> 00:01:50,500
foi acionado pelo mouse do usuário.

39
00:01:50,500 --> 00:01:53,710
>> Agora vamos verificar se
esse evento é nulo.

40
00:01:53,710 --> 00:01:57,400
Porque não é nulo, e isso é que
realmente ouviu algo do

41
00:01:57,400 --> 00:02:00,450
o mouse do usuário, vamos prosseguir
verificar agora que tipo

42
00:02:00,450 --> 00:02:03,001
do evento que foi.

43
00:02:03,001 --> 00:02:09,050
Se getEventType, passando um evento
como um argumento, é igual a iguais

44
00:02:09,050 --> 00:02:14,070
MOUSE_CLICKED, que passa a ser um
tipo específico de eventos, que é apenas

45
00:02:14,070 --> 00:02:17,110
outra constante declarada no
Stanford biblioteca portátil.

46
00:02:17,110 --> 00:02:21,400
Agora, como prometido, vamos agora imprimir o
coordenadas que clique do mouse.

47
00:02:21,400 --> 00:02:26,000
Printf "% .0 f.

48
00:02:26,000 --> 00:02:28,340
>> Em outras palavras, eu estou indo para imprimir
um valor de ponto flutuante.

49
00:02:28,340 --> 00:02:30,240
Mas eu não quero ver nada
depois do ponto decimal.

50
00:02:30,240 --> 00:02:32,260
Então, eu vou especificar 0,0.

51
00:02:32,260 --> 00:02:36,380
Vírgula,% .0 f para a coordenada y
bem.

52
00:02:36,380 --> 00:02:38,000
Barra invertida n quote perto.

53
00:02:38,000 --> 00:02:41,260
>> E agora vamos coordenada x do
desse evento.

54
00:02:41,260 --> 00:02:43,530
Essa é a coordenada x
do clique do mouse.

55
00:02:43,530 --> 00:02:46,990
E então vamos y do evento,
que é a coordenada y

56
00:02:46,990 --> 00:02:48,170
do clique do mouse.

57
00:02:48,170 --> 00:02:50,920
>> Vamos agora salvar, compilar
e executar este programa.

58
00:02:50,920 --> 00:02:54,160
E quando eu fizer isso, ele deve ser o caso
que não importa onde eu clico dentro

59
00:02:54,160 --> 00:02:58,850
dos limites deste pixel de 320 por 240
janela, eu deveria então ver em minha

60
00:02:58,850 --> 00:03:03,570
janela do console x vírgula coordenadas y
de onde eu cliquei.

61
00:03:03,570 --> 00:03:05,430
Faça clique.

62
00:03:05,430 --> 00:03:07,890
. / Clique.

63
00:03:07,890 --> 00:03:09,630
E há essa janela previmos.

64
00:03:09,630 --> 00:03:14,300
>> Agora deixe-me clique aproximadamente no topo
canto esquerdo da janela.

65
00:03:14,300 --> 00:03:18,150
Na minha tela do console, eu vejo que eu
acontecer a clicar no coordenada x sete

66
00:03:18,150 --> 00:03:19,700
e coordenada y sete.

67
00:03:19,700 --> 00:03:22,840
Vamos clicar agora aproximadamente no fundo
canto direito da janela.

68
00:03:22,840 --> 00:03:27,890
E parece-me ter clicado
coordenar pixel de 314, 229.

69
00:03:27,890 --> 00:03:30,330
>> Vamos agora fazer o canto inferior esquerdo.

70
00:03:30,330 --> 00:03:32,430
E eu vejo 6, 233.

71
00:03:32,430 --> 00:03:35,680
E canto superior direito, 305, 4.

72
00:03:35,680 --> 00:03:38,810
>> Por outras palavras, parece ser o caso
que o canto superior esquerdo da

73
00:03:38,810 --> 00:03:40,655
a janela é 0, 0.

74
00:03:40,655 --> 00:03:46,080
E o canto inferior direito
da minha janela é de 320, 240.

75
00:03:46,080 --> 00:03:48,990
Em outras palavras, eu teria visto
precisamente esses valores, se eu tivesse apenas

76
00:03:48,990 --> 00:03:52,180
perfeitamente alinhados meu cursor do mouse
em cada um dos cantos.

77
00:03:52,180 --> 00:03:54,960
Isto é verdade, em geral, em gráfica
de programação, se utilizar o

78
00:03:54,960 --> 00:03:58,860
Stanford biblioteca portátil ou mais qualquer
outro, pelo qual representam o topo

79
00:03:58,860 --> 00:04:03,050
canto como 0, 0, e a parte inferior
canto direito, como a vírgula largura

80
00:04:03,050 --> 00:04:06,810
altura, usando números positivos, mesmo
mas é para baixo e para a direita.

81
00:04:06,810 --> 00:04:08,615