path: root/tde-i18n-pt_BR/docs/tdeedu/kturtle/programming-reference.docbook

<!--Dear translator: please NEVER translate the id or anything inside the tags as they are needed in english by the application
     Thanks a lot in advance.-->
<chapter id="reference">
<title>Referência de Programação em &logo; do &kturtle;</title>
<para>Esta é a referência para o &logo; do &kturtle;. Neste capítulo iremos abordar brevemente todos os <link linkend="different-instructions">tipos de instruções diferentes</link>. Depois, serão explicados os <link linkend="commands">comandos</link>, um por um. Em seguida, serão explicados os <link linkend="containers">recipientes</link>, a <link linkend="math">matemática</link>, as <link linkend="questions">questões</link> e os <link linkend="controlling-execution">controladores de execução</link>. Por último, será mostrado como criar os seus próprios comandos com o <link linkend="learn">learn</link>.</para>

<sect1 id="different-instructions">
<title>Tipos Diferentes de Instruções</title>
<para>Como em qualquer linguagem, o LOGO possui diferentes tipos de palavras e símbolos. Aqui as diferenças entre os tipos serão brevemente explanadas.</para>

<sect2 id="command">
<title>Comandos</title>
<para>Usando comandos, você diz à tartaruga ou ao &kturtle; para fazer algo. Alguns comandos precisam de dados de entrada, enquanto outros fornecem resultados ou dados de saída. <screen># o 'forward' é um comando que necessita de dados de entrada, neste caso o número 100:
forward 100
</screen>
</para>
<para>Para uma idéia geral de todos os comandos que o &kturtle; suporta, vá para <link linkend="commands">aqui</link>.</para>
</sect2>

<sect2 id="number">
<title>Números</title>
<para>Muito provavelmente você já conhece alguma coisa sobre os números. A forma como eles são usados no &kturtle; não é muito diferente do idioma falado ou da matemática. </para>
<para>Temos então os números conhecidos por naturais: <userinput>0</userinput>, <userinput>1</userinput>, <userinput>2</userinput>, <userinput>3</userinput>, <userinput>4</userinput>, <userinput>5</userinput>, etc. Os números negativos: <userinput>-1</userinput>, <userinput>-2</userinput>, <userinput>-3</userinput>, etc. Finalmente, os números decimais ou fracionários, como por exemplo: <userinput>0.1</userinput>, <userinput>3.14</userinput>, <userinput>33.3333</userinput>, <userinput>-5.05</userinput>, <userinput>-1.0</userinput>. </para>
<para>Os números podem ser usados em <link linkend="math">cálculos matemáticos</link> e <link linkend="questions">perguntas</link>. Eles também podem ser colocados em <link linkend="containers">recipientes</link>.</para>
<para>Os números ficam <glossterm>realçados</glossterm> em azul no <link linkend="the-code-editor">editor de código</link>.</para>
</sect2>

<sect2 id="string">
<title>Cadeias de caracteres</title>
<para>Primeiro um exemplo: <screen>
print "Olá, sou uma cadeia de caracteres."
</screen> Neste exemplo, o <userinput>print</userinput> é um comando, enquanto o <userinput>"Olá, sou uma cadeia de caracteres."</userinput> é, de fato, uma cadeia de caracteres. Elas começam e terminam com o símbolo <userinput>"</userinput>; através destes símbolos, o &kturtle; sabe que é uma cadeia de caracteres.</para>
<para>As cadeias de caracteres podem ser colocadas em <link linkend="containers">recipientes</link>. Porém, não podem ser usadas em <link linkend="math">cálculos matemáticos</link> nem em <link linkend="questions">questões</link>.</para>
<para>As cadeias de caracteres ficam <glossterm>realçadas</glossterm> em vermelho escuro no <link linkend="the-code-editor">editor de código</link>.</para>
</sect2>


<sect2 id="name">
<title>Nomes</title>
<para>Ao usar a linguagem de programação &logo;, você pode criar coisas novas. Se criar um programa irá necessitar normalmente de <link linkend="containers">recipientes</link> e, em alguns casos, do <link linkend="learn">learn</link> para criar novos comandos. Ao criar um <link linkend="containers">recipiente</link> ou um novo comando com o <link linkend="learn">learn</link>, você terá que especificar um nome.</para>
<para>Você poderá escolher qualquer nome, desde que ele não tenha já algum significado. Por exemplo, não poderá chamar um recipiente de <link linkend="forward">forward</link>, uma vez que esse nome já é usado para um comando e, assim, já tem um significado.<screen>
# Aqui o forward é usado como recipiente, mas já tem um significado
# assim irá produzir um erro:
forward = 20

# isto funciona:
forward 20
</screen> Os nomes só poderão conter letras, números e sublinhados (_). De qualquer forma, devem começar por uma letra. </para>
<para>Por favor, leia a documentação sobre os <link linkend="containers">recipientes</link> e o comando <link linkend="learn">learn</link> para uma melhor explicação e mais exemplos. </para>
</sect2>

<sect2 id="assignment">
<title>Atribuições</title>
<para>As atribuições são feitas com o símbolo <userinput>=</userinput>. Nas linguagens de programação é melhor ler o <userinput>=</userinput> simples não como um 'é igual a' mas sim como um 'ficar igual a'. O termo 'é igual a' é mais apropriado para o <userinput>==</userinput>, que é uma <link linkend="questions">pergunta</link>.</para>
<para>As atribuições são usadas normalmente por duas razões, (1) para adicionar conteúdo aos <link linkend="containers">recipientes</link> e (2) para modificar o conteúdo de um recipiente. Por exemplo: <screen>x = 10
# o recipiente 'x' contém agora o número 10
W = "A minha idade é: "
# o recipiente W contém agora o texto "A minha idade é: "
# isto imprime o conteúdo dos recipientes 'W' e 'x' na área de desenho
print W + x
</screen>
</para>
<para>Para mais exemplos, veja a seção que explica os <link linkend="containers">recipientes</link>.</para>
</sect2>

<sect2 id="math-symbols">
<title>Símbolos Matemáticos</title>
<para>O &kturtle; suporta todos os símbolos matemáticos básicos: a adição (<userinput>+</userinput>), a substração (<userinput>-</userinput>), a multiplicação (<userinput>*</userinput>), a divisão (<userinput>/</userinput>) e os parênteses <userinput>(</userinput> e <userinput>)</userinput>.</para>
<para>Para uma explicação completa e mais exemplos, veja a seção de <link linkend="math">matemática</link>.</para>
</sect2>

<sect2 id="question">
<title>Perguntas</title>
<para>Nós podem fazer perguntas simples onde a respostar será 'true' (verdadeiro) ou 'false' (falso).</para>
<para>O uso de perguntas é extensivamente explicado na seção <link linkend="questions">perguntas</link>.</para>
</sect2>

<sect2 id="questions-glue">
<title>Palavras de Colagem de Perguntas</title>
<para>As perguntas podem ser coladas juntas com o que se denomina por 'cola das perguntas'. As palavas de colagem são o <userinput>and</userinput> (e), o <userinput>or</userinput> (ou) e uma palavra especial: a <userinput>not</userinput> (não).</para>
<para>A utilização da colagem de perguntas é explicada na seção de <link linkend="question-glue">Colagem de Perguntas</link>.</para>
</sect2>


<sect2 id="comment">
<title>Comentários</title>
<para>Comentários são linhas que iniciam com um <userinput>#</userinput>. Por exemplo: <screen>
# isto é um comentário!
print "isto não é um comentário"
# a linha anterior não é um comentário, mas a próxima é:
# print "isto não é um comentário"
</screen> Nós podemos adicionar comentários ao código para nós mesmos ou para que alguém os leia. Comentários são usados para: (1) adicionar uma pequena descrição ao programa, (2) explanar como um pedaço do código funciona se ele for um pouco complicado, e (3) para 'comentar' linhas de código que devem ser (temporariamente) ignoradas (veja a última linha do exemplo).</para>
<para>As linhas comentadas ficam <glossterm>realçadas</glossterm> em amarelo escuro no <link linkend="the-code-editor">editor de código</link>.</para>
</sect2>

</sect1>


<sect1 id="commands">
<title>Comandos</title>
<para>Ao usar os comandos, você diz à tartaruga ou ao &kturtle; para fazer algo. Alguns comandos precisam de dados de entrada, enquanto outros fornecem resultados ou dados de saída. Nesta seção iremos explicar todos os comandos que podem ser usados no &kturtle;. Observe que todos os comandos incorporados ficam <glossterm>realçados</glossterm> em verde escuro no <link linkend="the-code-editor">editor de código</link>, para que possa ajudar a distinguí-los.</para>

<sect2 id="moving-the-turtle">
<title>Movendo a tartaruga</title>
<para>Existem vários comandos para mover a tartaruga pela tela.</para>
  
<sect3 id="forward">
  <title>forward (fw)</title>
  <variablelist>
    <varlistentry> 
      <term>forward</term>
      <listitem><para><screen>forward X</screen>
O <userinput>forward</userinput> move a tartaruga para a frente X pixels. Quando o traço está em baixo, a tartaruga irá deixar um rastro. O <userinput>forward</userinput> pode ser abreviado para <userinput>fw</userinput></para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
<sect3 id="backward">
  <title>backward (bw)</title>
  <variablelist>
    <varlistentry>  
      <term>backward</term>
      <listitem><para><screen>backward X</screen>
O <userinput>backward</userinput> move a tartaruga para trás X pixels. Quando o traço está em baixo, a tartaruga irá deixar um rastro. O <userinput>backward</userinput> pode ser abreviado para <userinput>bw</userinput>.</para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
<sect3 id="turnleft">
  <title>turnleft (tl)</title>
  <variablelist>
    <varlistentry> 
      <term>turnleft</term>
      <listitem><para><screen>turnleft X</screen>
O <userinput>turnleft</userinput> diz à tartaruga para se virar X graus para a esquerda. O <userinput>turnleft</userinput> pode ser abreviado para <userinput>tl</userinput>.</para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
<sect3 id="turnright">
  <title>turnright (tr)</title>
  <variablelist>
    <varlistentry> 
      <term>turnright</term>
      <listitem><para><screen>turnright X</screen>
O <userinput>turnright</userinput> diz à tartaruga para se virar X graus para a direita. O <userinput>turnright</userinput> pode ser abreviado para <userinput>tr</userinput>.</para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
<sect3 id="direction">
  <title>direction (dir)</title>
  <variablelist>
    <varlistentry> 
      <term>direction</term>
      <listitem><para><screen>direction X</screen>
O <userinput>direction</userinput> configura a direção da tartaruga para um ângulo de X graus a contar do zero, e isto não é relativo à direção anterior da tartaruga. O <userinput>direction</userinput> pode ser abreviado para <userinput>dir</userinput>.</para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
<sect3 id="center">
  <title>center</title>
  <variablelist>
    <varlistentry> 
      <term>center</term>
      <listitem><para><screen>center</screen>
O <userinput>center</userinput> move a tartaruga para o centro da área de desenho.</para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
<sect3 id="go">
  <title>go</title>
  <variablelist>
    <varlistentry> 
      <term>go</term>
      <listitem><para><screen>go X,Y</screen>
O <userinput>go</userinput> manda a tartaruga ir para um determinado local da área de desenho. Este local está a X <glossterm linkend="pixels">pixels</glossterm> do lado esquerdo da área de desenho e a Y <glossterm linkend="pixels">pixels</glossterm> do topo da área. Lembre-se que, ao usar o comando <userinput>go</userinput>, a tartaruga não irá desenhar nenhuma linha.</para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
<sect3 id="gox">
  <title>gox</title>
  <variablelist>
    <varlistentry> 
      <term>gox</term>
      <listitem><para><screen>gox X</screen>
Ao usar o comando <userinput>gox</userinput>, a tartaruga irá mover-se X <glossterm linkend="pixels">pixels</glossterm> a partir da esquerda da área de desenho, mantendo-se na mesma altura.</para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
<sect3 id="goy">
  <title>goy</title>
  <variablelist>
    <varlistentry> 
      <term>goy</term>
      <listitem><para><screen>goy Y</screen>
Ao usar o comando <userinput>goy</userinput>, a tartaruga irá mover-se Y <glossterm linkend="pixels">pixels</glossterm> a partir do topo da área de desenho, mantendo-se na mesma distância do lado esquerdo da área de desenho.</para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
</sect2>

<sect2 id="pen">
<title>A tartaruga tem um traço</title>
<para>A tartaruga tem um traço e vai desenhando uma linha à medida que a tartaruga se move. Existem alguns comandos para controlar o traço. Nesta seção iremos explicar estes comandos.</para>
<sect3 id="penup">
  <title>penup (pu)</title>
  <variablelist>
    <varlistentry> 
      <term>penup</term>
      <listitem><para><screen>penup</screen>
O <userinput>penup</userinput> levanta o traço da área de desenho. Quando o traço está <quote>em cima</quote>, não é desenhada nenhuma linha à medida que a tartaruga se move. Veja também o <userinput>pendown</userinput>. O <userinput>penup</userinput> pode ser abreviado para <userinput>pu</userinput>.</para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
<sect3 id="pendown">
  <title>pendown (pd)</title>
  <variablelist>
    <varlistentry> 
      <term>pendown</term>
      <listitem><para><screen>pendown</screen>
O <userinput>pendown</userinput> pressiona o traço para baixo na área de desenho. Quando o traço está <quote>em baixo</quote>, é desenhada uma linha à medida que a tartaruga se move. Veja também o <userinput>penup</userinput>. O <userinput>pendown</userinput> pode ser abreviado para <userinput>pd</userinput>.</para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
<sect3 id="setpenwidth">
  <title>penwidth (pw)</title>
  <variablelist>
    <varlistentry> 
      <term>penwidth</term>
      <listitem><para><screen>penwidth X</screen>
O <userinput>penwidth</userinput> configura a espessura do traço para X <glossterm linkend="pixels">pixels</glossterm>. O <userinput>penwidth</userinput> pode ser abreviado para <userinput>pw</userinput>.</para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
<sect3 id="setfgcolor">
  <title>pencolor (pc)</title>
  <variablelist>
    <varlistentry> 
      <term>pencolor</term>
      <listitem><para><screen>pencolor R,G,B</screen>
O <userinput>pencolor</userinput> configura a cor do traço. O <userinput>pencolor</userinput> recebe uma <glossterm linkend="rgb">combinação de RGB</glossterm> como parâmetro. O <userinput>pencolor</userinput> pode ser abreviado para <userinput>pc</userinput>.</para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
</sect2>

<sect2 id="canvas">
<title>Comandos para controlar a área de desenho</title>
<para>Existem vários comandos para controlar a área de desenho.</para>
<sect3 id="resizecanvas">
  <title>canvassize (cs)</title>
  <variablelist>
    <varlistentry>
      <term>canvassize</term>
      <listitem><para><screen>canvassize X,Y</screen>
Com o comando <userinput>canvassize</userinput> você poderá alterar o tamanho da área de desenho. Ele recebe dois parâmetros (X e Y) de entrada, em que o X é a nova largura da área de desenho em <glossterm linkend="pixels">pixels</glossterm>, e o Y é a nova altura da mesma área em <glossterm linkend="pixels">pixels</glossterm>. O <userinput>canvassize</userinput> pode ser abreviado para <userinput>cs</userinput>.</para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
<sect3 id="setbgcolor">
  <title>canvascolor (cc)</title>
  <variablelist>
    <varlistentry> 
      <term>canvascolor</term>
      <listitem><para><screen>canvascolor R,G,B</screen>
O <userinput>canvascolor</userinput> define a cor da área de desenho. O <userinput>canvascolor</userinput> recebe uma <glossterm linkend="rgb">combinação RGB</glossterm> como parâmetro. O <userinput>canvascolor</userinput> pode ser abreviado para <userinput>cc</userinput>.</para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
<sect3 id="wrapon">
  <title>wrapon</title>
  <variablelist>
    <varlistentry> 
      <term>wrapon</term>
      <listitem><para><screen>wrapon</screen>
Com o comando <userinput>wrapon</userinput> você poderá ativar a <glossterm linkend="wrapping">envolvência</glossterm> para a área de desenho. Por favor veja o glossário para saber o que é a <glossterm linkend="wrapping">envolvência</glossterm>.</para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
<sect3 id="wrapoff">
  <title>wrapoff</title>
  <variablelist>
    <varlistentry> 
      <term>wrapoff</term>
      <listitem><para><screen>wrapoff</screen>
Com o comando <userinput>wrapoff</userinput> você poderá desativar a <glossterm linkend="wrapping">envolvência</glossterm> para a área de desenho. Isto significa que a tartaruga poderá mover-se para fora da área de desenho e <quote>perder-se</quote>. Por favor veja o glossário se quiser saber o que é a <glossterm linkend="wrapping">envolvência</glossterm>.</para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
</sect2>

<sect2 id="clean">
<title>Comandos para limpar</title>
<para>Existem dois comandos para limpar a área de desenho, depois de você ter deixado tudo bagunçado.</para>
<sect3 id="clear">
  <title>clear (cr)</title>
  <variablelist>
    <varlistentry> 
      <term>clear</term>
      <listitem><para><screen>clear</screen>
Com o <userinput>clear</userinput>, você poderá limpar todos os desenhos da área de desenho. Todo o resto permanece igual: a posição e o ângulo da tartaruga, a cor da área de trabalho, a visibilidade da tartaruga e o tamanho da área de desenho. O <userinput>clear</userinput> pode ser abreviado para <userinput>cr</userinput>.</para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
<sect3 id="reset">
  <title>reset</title>
  <variablelist>
    <varlistentry> 
      <term>reset</term>
      <listitem><para><screen>reset</screen>
O <userinput>reset</userinput> limpa tudo de forma mais abrangente que o comando <userinput>clear</userinput>. Depois de um comando <userinput>reset</userinput>, tudo fica como estava quando você iniciou o &kturtle;. A tartaruga é posicionada no meio do tela, a cor da área de desenho é branca e a tartaruga irá desenhar uma linha preta na área de desenho.</para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
</sect2>

<sect2 id="sprites">
<title>A tartaruga é uma imagem móvel</title>
<para>Muitas pessoas não sabem o que são as imagens móveis ('sprites'), daí uma breve explicação: as imagens móveis são pequenas imagens que podem percorrer o tela (para mais informações, veja o glossário sobre as <glossterm linkend="sprites">imagens móveis</glossterm>). </para>
<para>A seguir você irá encontrar uma apresentação completa de todos os comandos que lidam com imagens móveis.</para>
<para>[A versão atual do &kturtle; não suporta ainda o uso de imagens móveis além da tartaruga. Nas versões futuras, você poderá mudar a tartaruga para outra coisa que desejar]</para>
<sect3 id="spriteshow">
  <title>show</title>
  <variablelist>
    <varlistentry> 
      <term>show (ss)</term>
      <listitem><para><screen>show</screen>
O <userinput>show</userinput> torna a tartaruga visível de novo depois de ter ficado escondida. O <userinput>show</userinput> pode ser abreviado para <userinput>ss</userinput>.</para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
<sect3 id="spritehide">
  <title>hide (sh)</title>
  <variablelist>
    <varlistentry> 
      <term>hide</term>
      <listitem><para><screen>hide</screen>
O <userinput>hide</userinput> esconde a tartaruga. Isto pode ser usado se a tartaruga não couber no seu desenho. O <userinput>hide</userinput> pode ser abreviado para <userinput>sh</userinput>.</para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
</sect2>

<sect2 id="writing">
<title>Será que as tartarugas sabem escrever?</title>
<para>A resposta é: <quote>sim</quote>. A tartaruga sabe escrever e pode escrever tudo o que lhe disser para escrever.</para>
<sect3 id="print">
  <title>print</title>
  <variablelist>
    <varlistentry> 
      <term>print</term>
      <listitem><para><screen>print X</screen>
O comando <userinput>print</userinput> é usado para dizer à tartaruga para escrever algo na área de desenho. O <userinput>print</userinput> recebe números e texto como parâmetros. Você poderá executar o <userinput>print</userinput> para vários parâmetros com o sinal <quote>+</quote>. Veja aqui um pequeno exemplo: <screen>ano = 2004
autor = "Ze"
print "O " + autor + " iniciou o projeto do KTurtle em " + ano + " e ainda continua gostando de trabalhar nele!"
</screen>
      </para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
<sect3 id="fontsize">
  <title>fontsize</title>
  <variablelist>
    <varlistentry> 
      <term>fontsize</term>
      <listitem><para><screen>fontsize X</screen>
O <userinput>fontsize</userinput> configura o tamanho da letra que é usado pelo <userinput>print</userinput>. O <userinput>fontsize</userinput> recebe um parâmetro que deverá ser um número. O tamanho é definido em <glossterm linkend="pixels">pixels</glossterm>.</para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
</sect2>

<sect2 id="random">
<title>Um comando que joga aos dados para você</title>
<para>Existe um comando que lança os dados para você, que se chama <userinput>random</userinput>; ele é muito útil para alguns resultados inesperados.</para>
  <variablelist>
    <varlistentry> 
      <term>random</term>
      <listitem><para><screen>random X,Y</screen>
O <userinput>random</userinput> é um comando que recebe parâmetros e devolve resultados. Como parâmetros são necessários dois números, onde o primeiro define o resultado mínimo (X) e o segundo o máximo (Y). O resultado é um número escolhido aleatoriamente que é maior ou igual ao mínimo e menor ou igual ao máximo. Aqui está um pequeno exemplo: <screen>
      repeat 500 [
        x = random 1,20
        forward x
        turnleft 10 - x
      ]
      </screen> Com o comando 'random', você poderá adicionar um pouco de confusão ao seu programa.</para></listitem>
    </varlistentry>
  </variablelist>
</sect2>

<sect2 id="dialogs">
<title>Entrada de dados e reação através de janelas</title>
<para>Uma janela poderá pedir alguma alguma reação em especial ou a introdução de determinados dados. O &kturtle; tem dois comandos para janelas, nomeadamente o <userinput>message</userinput> e o <userinput>inputwindow</userinput></para>
<sect3 id="message">
  <title>message</title>
  <variablelist>
    <varlistentry> 
      <term>message</term>
      <listitem><para><screen>message X</screen>
O comando <userinput>message</userinput> recebe uma <link linkend="string">cadeia de caracteres</link> como entrada. Mostra então uma janela que contém o texto da <link linkend="string">cadeia de caracteres</link>. <screen>ano = 2004
autor = "Ze"
print "O " + autor + " iniciou o projeto do KTurtle em " + ano + " e ainda continua gostando de trabalhar nele!"
</screen>
      </para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
<sect3 id="inputwindow">
  <title>inputwindow</title>
  <variablelist>
    <varlistentry> 
      <term>inputwindow</term>
      <listitem><para><screen>inputwindow X</screen>
O <userinput>inputwindow</userinput> recebe uma <link linkend="string">cadeia de caracteres</link> como entrada. Mostra uma janela que contém o texto da cadeia de caracteres, tal como acontece no <link linkend="message">message</link>. Contudo, além disso, também mostra um campo de texto na janela. Através deste campo, o usuário poderá introduzir um <link linkend="number">número</link> ou uma <link linkend="string">cadeia de caracteres</link> que poderá ser guardada num <link linkend="containers">recipiente</link>. Por exemplo <screen>
in = inputwindow "Que idade você tem?"
out = 2003 - in
print "Em 2003, você tinha " + out + " anos em determinado momento."
</screen> Quando um usuário cancelar a janela ou não inserir nenhuma informação, o <link linkend="containers">recipiente</link> fica vazio.</para></listitem>
    </varlistentry>
  </variablelist>
</sect3>
</sect2>

</sect1>



<sect1 id="containers">
<title>Recipientes</title>
<para>Os recipientes são letras ou palavras que podem ser usadas pelo programador para guardar algum número ou algum texto. Os recipientes que contém um número chamam-se <link linkend="variables">variáveis</link>, enquanto que os que contém texto chamam-se <link linkend="strings">cadeias de caracteres</link>.</para>

<para>Os recipientes que não são usados não contém nada. Por exemplo, um: <screen>
print N
</screen> Isto não irá imprimir nada. Se tentar fazer <link linkend="math">operações matemáticas</link> com recipientes vazios, irá obter erros. </para>

<sect2 id="variables">
<title>Variáveis: recipientes de números</title>
<para>Vamos começar com um exemplo: <screen>
x = 3
print x
</screen> Na primeira linha, a letra <userinput>x</userinput> passou a ser uma variável (um recipiente de números). Como você pode ver, o valor da variável <userinput>x</userinput> passou para 3. Na segunda linha, o valor é impresso.</para>
<para>Lembre-se que, se quisermos imprimir um <quote>x</quote>, então devemos escrever <screen>print "x"
</screen>
</para>
<para>Isso foi fácil, mas agora há um exemplo um pouco mais difícil: <screen>
A = 2004
B = 25
C = A + B

# o próximo comando imprime "2029"
print C
backward 30
# o próximo comando imprime "2004 mais 25"
print A + " mais " + B
backward 30
# o próximo comando imprime "1979"
print A - B
</screen> Nas duas primeiras linhas, as variáveis <userinput>A</userinput> e <userinput>B</userinput> são configuradas como sendo iguais a 2004 e 25. Na terceira linha, a variável <userinput>C</userinput> fica igual a <userinput>A + B</userinput>, o que dá 2029. O resto do exemplo consiste em 3 comandos <userinput>print</userinput> com <userinput>backward 30</userinput> no meio. O <userinput>backward 30</userinput> está lá para garantir que cada resultado fica numa linha diferente. Neste exemplo, você vê também que as variáveis podem ser usadas nos <link linkend="math">cálculos matemáticos</link>.</para>
</sect2>

<sect2 id="strings">
<title>Recipientes de texto (cadeias de caracteres)</title>
<para>No código do programa, o texto normal é iniciado e termina normalmente com aspas. Como já foi visto: <screen>
print "Olá programador!"
</screen> O texto fica delimitado com as aspas. Estes pedaços de texto normal são chamados então de <link linkend="strings">cadeias de caracteres</link>.</para>
<para>As cadeias de caracteres são bastante parecidas com as variáveis. A maior diferença é que as cadeias de caracteres não podem ser usadas em <link linkend="math">cálculos matemáticos</link> e <link linkend="questions">perguntas</link>. Um exemplo da utilização das cadeias de caracteres: <screen>
x = "Olá "
nome = inputwindow "por favor insira o seu nome..."
print x + nome + ", como está?
</screen> Na segunda linha, a cadeia de caracteres <userinput>x</userinput> fica igual a <quote>Olá </quote>. Na segunda linha, a cadeia de caracteres <userinput>nome</userinput> é configurada como o resultado do comando <userinput>inputwindow</userinput>. Na terceira linha, o programa imprime uma composição de três cadeias de caracteres na área de desenho.</para>
<para>Este programa pede para inserir o seu nome. Quando você, por exemplo, inserir o nome <quote>José</quote>, o programa irá imprimir <quote>Olá José, como está?</quote>. Lembre-se que o sinal de mais (+) é o único símbolo matemático que você poderá usar com as cadeias de caracteres.</para>
</sect2>
</sect1>

<sect1 id="math">
<title>Será que a Tartaruga sabe fazer contas?</title>
<para>Sim, o &kturtle; sabe fazer contas para você. Você poderá somar (+), subtrair (-), multiplicar (*) e dividir (/). Aqui está um exemplo no qual iremos usar todas as operações: <screen>
a = 20 - 5
b = 15 * 2
c = 30 / 30
d = 1 + 1
print "a: "+a+", b: "+b+", c: "+c+", d: "+d 
</screen> Será que você sabe o valor de 'a', 'b', 'c' e 'd'? Repare por favor no uso do símbolo <userinput>=</userinput> de <link linkend="assignment">atribuição</link>.</para>
<para>Se você somente queria fazer um cálculo simples, você poderá fazer algo semelhante a isto: <screen>print 2004-12
</screen></para>
<para>Agora, um exemplo com parênteses: <screen>
print ( ( 20 - 5 ) * 2 / 30 ) + 1
</screen> O que estiver entre parênteses será calculado em primeiro lugar. Neste exemplo, o 20-5 será calculado, depois será multiplicado por 2, dividido por 30 e depois é adicionado 1 (o que dá 2).</para>
</sect1>

<sect1 id="questions">
<title>Fazendo perguntas, obtendo respostas...</title>
<para>O <link linkend="if"><userinput>if</userinput></link> e o <link linkend="while"><userinput>while</userinput></link> são <link linkend="controlling-execution">controladores de execução</link> que iremos discutir na próxima seção. Nesta seção iremos usar o comando <userinput>if</userinput> para explicar as perguntas.</para>
<sect2 id="q">
<title>Perguntas</title>
<para>Um exemplo simples de pergunta: <screen>
x = 6
if x &gt; 5 [
  print "olá"
]
</screen> Neste exemplo, a pergunta é <userinput>x &gt; 5</userinput>, se a resposta a esta pergunta for <quote>true</quote> (verdadeira), o código entre colchetes será executado. As perguntas são uma parte importante da programação e são usadas normalmente em conjunto com os <link linkend="controlling-execution">controladores de execução</link>, como o <link linkend="if"><userinput>if</userinput></link>. Todos os números e <link linkend="variables">variáveis</link> (recipientes de números) poderão ser comparados uns com os outros nas perguntas.</para>
<para>Aqui estão todas as perguntas possíveis: <table>
<title>Tipos de perguntas</title>
<tgroup cols="3">
<tbody>
<row>
<entry><userinput>a == b</userinput></entry>
<entry>é igual a</entry>
<entry>a resposta é <quote>true</quote> (verdadeira) se o <userinput>a</userinput> for igual ao <userinput>b</userinput></entry>
</row>
<row>
<entry><userinput>a != b</userinput></entry>
<entry>é diferente de</entry>
<entry>a resposta é <quote>true</quote> (verdadeira) se o <userinput>a</userinput> não for igual ao <userinput>b</userinput></entry>
</row>
<row>
<entry><userinput>a &gt; b</userinput></entry>
<entry>maior que</entry>
<entry>a resposta é <quote>true</quote> (verdadeira) se o <userinput>a</userinput> for maior que o <userinput>b</userinput></entry>
</row>
<row>
<entry><userinput>a &lt; b</userinput></entry>
<entry>menor que</entry>
<entry>a resposta é <quote>true</quote> (verdadeira) se o <userinput>a</userinput> for menor que o <userinput>b</userinput></entry>
</row>
<row>
<entry><userinput>a &gt;= b</userinput></entry>
<entry>maior ou igual a</entry>
<entry>a resposta é <quote>true</quote> (verdadeira) se o <userinput>a</userinput> for maior ou igual ao <userinput>b</userinput></entry>
</row>
<row>
<entry><userinput>a &lt;= b</userinput></entry>
<entry>menor ou igual a</entry>
<entry>a resposta é <quote>true</quote> (verdadeira) se o <userinput>a</userinput> for menor ou igual ao <userinput>b</userinput></entry>
</row>
</tbody>
</tgroup>
</table>
</para>
<para>As perguntas ficam <glossterm>realçadas</glossterm> em azul claro no <link linkend="the-code-editor">editor de código</link>.</para> 
</sect2>

<sect2 id="question-glue">
<title>Colagem de Perguntas</title>
<para>As perguntas também podem ser coladas umas às outras com <quote>palavras de colagem de perguntas</quote> onde, desta forma, algumas perguntas tornam-se uma pergunta maior. <screen>
a = 1
b = 5
if (a &lt; 5) and (b == 5) [
  print "olá"
]
</screen> Neste exemplo, a palavra de colagem <userinput>and</userinput> é usada para colar 2 perguntas (<userinput>a &lt; 5</userinput>, <userinput>b == 5</userinput>) juntas. Se um lado do <userinput>and</userinput> der uma resposta <quote>false</quote> (falsa), a pergunta toda irá responder <quote>false</quote>, porque, com a palavra de colagem <userinput>and</userinput>, ambos os lados precisam ser <quote>true</quote> para que a resposta seja <quote>true</quote> (verdadeira). Por favor não se esqueça de usar os parênteses ao redor das perguntas!</para>

<para>Aqui está uma visão esquemática, bem como uma explicação mais detalhada: <table>
<title>Palavras de colagem de perguntas</title>
<tgroup cols="2">
<tbody>
<row>
<entry><userinput>and</userinput></entry>
<entry>ambos os lados têm que ser <quote>true</quote> (verdadeiros) para a resposta ser <quote>true</quote> (verdadeira)</entry>
</row>
<row>
<entry><userinput>or</userinput></entry>
<entry>se um dos lados for <quote>true</quote> (verdadeiros) a resposta é <quote>true</quote> (verdadeira)</entry>
</row>
<row>
<entry><userinput>not</userinput></entry>
<entry>Caso especial: só funciona com uma pergunta! Muda o 'true' para 'false' e o 'false' para 'true'.</entry>
</row>
</tbody>
</tgroup>
</table>
</para>
<para>As palavras de colagem ficam <glossterm>realçadas</glossterm> em púrpura no <link linkend="the-code-editor">editor de código</link>.</para>

<sect3 id="and">
<title>and</title>
<para>Quando são coladas duas perguntas juntas com o <userinput>and</userinput>, ambos os lados do <userinput>and</userinput> terão que ser 'true' para que o resultado também seja 'true' (verdadeiro). Por exemplo: <screen>
a = 1
b = 5
if ((a &lt; 10) and (b == 5)) and (a &lt; b) [
  print "olá"
]
</screen> Nestes exemplo, você poderá ver uma pergunta colada a outra pergunta também colada.</para>
</sect3>

<sect3 id="or">
<title>or</title>
<para>Se uma das duas perguntas coladas juntas com o <userinput>or</userinput> for 'true' (verdadeira), o resultado será também 'true'. Por exemplo: <screen>
a = 1
b = 5
if ((a &lt; 10) or (b == 10)) or (a == 0) [
  print "olá"
]
</screen> Neste exemplo, irá ver uma pergunta colada a outra pergunta, que também está colada.</para>
</sect3>

<sect3 id="not">
<title>not</title>
<para>O <userinput>not</userinput> é uma palavra de colagem especial porque somente funciona com uma pergunta de cada vez. <userinput>not</userinput> muda 'true' para 'false' e 'false' para 'true'. Um exemplo: <screen>
a = 1
b = 5
if not ((a &lt; 10) and (b == 5)) [
  print "olá"
]
else
[
  print "adeus ;-)"
]
</screen> Neste exemplo a pergunta colada é 'true' ainda que o <userinput>not</userinput> mude-a para 'false'. Assim, no final, <userinput>"adeus ;-)"</userinput> é impresso na <link linkend="the-canvas">área de desenho</link>.</para>
</sect3>

</sect2>

</sect1>

<sect1 id="controlling-execution">
<title>Controlando a execução</title>
<para>Os controladores de execução permitem-lhe &mdash; como o nome deles indica &mdash; controlar a execução.</para>
<para>Os comandos de controle de execução são <glossterm>realçados</glossterm> em verde escuro e negrito. Os colchetes são frequentemente usados juntamente com os controladores de execução e eles são <glossterm>realçados</glossterm> em verde claro.</para>

<sect2 id="wait">
<title>Fazendo a tartaruga esperar</title>
<para>Se você já tentou programar um pouco no &kturtle;, você já poderá ter reparado que a tartaruga pode ser bastante rápida desenhando. Este comando faz a tartaruga andar um pouco mais devagar.</para>
  <variablelist>
    <varlistentry>
      <term>wait</term>
      <listitem><para><screen>wait X</screen>
O <userinput>wait</userinput> faz a tartaruga esperar X segundos. <screen>
repeat 36 [
  forward 5
  turnright 10
  wait 0.5
]
</screen> Este código irá desenhar uma circunferência, mas a tartaruga irá esperar meio segundo a cada passo. Isto dá a noção de uma tartaruga vagarosa.</para></listitem>
    </varlistentry>
  </variablelist>
</sect2>

<sect2 id="if">
<title>Executar o "if"</title>
<para></para>
  <variablelist>
    <varlistentry>
      <term>if</term>
      <listitem><para><screen>if <link linkend="questions">pergunta</link> [ ... ]</screen>
O código que é colocado no <quote>...</quote> só será executado se (<userinput>if</userinput>) a resposta à <link linkend="questions">pergunta</link> for <quote>true</quote> (verdadeira). Por favor leia, para obter mais informações sobre perguntas, a <link linkend="questions">seção de perguntas</link>. <screen>
x = 6
if x &gt; 5 [
  print "O x é maior que cinco!"
]
</screen> Na primeira linha, o <userinput>x</userinput> é inicializado com 6. Na segunda linha, a <link linkend="questions">pergunta</link> <userinput>x &gt; 5</userinput> é feita. Uma vez que a resposta a esta pergunta é verdadeira, o controlador de execução <userinput>if</userinput> irá permitir que o código entre colchetes seja executado</para></listitem>
    </varlistentry>
  </variablelist>
</sect2>

<sect2 id="while">
<title>O ciclo "while"</title>
<para></para>
  <variablelist>
    <varlistentry>
      <term>while</term>
      <listitem><para><screen>while <link linkend="questions">pergunta</link> [ ... ]</screen>
O controlador de execução <userinput>while</userinput> é um pouco parecido com o <link linkend="if"><userinput>if</userinput></link>. A diferença é que o <userinput>while</userinput> fica repetindo (em ciclo) o código entre os colchetes até que a resposta à <link linkend="questions">pergunta</link> seja <quote>false</quote>. <screen>
x = 1
while x &lt; 5 [
  forward 10
  wait 1
  x = x + 1
]
</screen> Na primeira linha o <userinput>x</userinput> é inicializado com 1. Na segunda linha a <link linkend="questions">pergunta</link> <userinput>x &lt; 5</userinput> é feita. Uma vez que a resposta é <quote>verdadeiro</quote> o controlador de execução <userinput>while</userinput> inicia a execução do código entre colchetes até que a resposta à <link linkend="questions">pergunta</link> seja <quote>falso</quote>. Neste caso o código entre colchetes será executado 4 vezes, porque cada vez que a quinta linha é executada o <userinput>x</userinput> é aumentado de 1.</para></listitem>
    </varlistentry>
  </variablelist>
</sect2>

<sect2 id="else">
<title>Se não, em outras palavras: "else"</title>
<para></para>
  <variablelist>
    <varlistentry>
      <term>else</term>
      <listitem><para><screen>if pergunta [ ... ] else [ ... ]</screen>
O <userinput>else</userinput> pode ser usado em adição ao controlador de execução <link linkend="if"><userinput>if</userinput></link>. O código entre colchetes após o <userinput>else</userinput> só é executado se a resposta à <link linkend="questions">pergunta</link> feita é respondida como <quote>falso</quote>. <screen>
reset
x = 4
if x &gt; 5 [
  print "x é maior que cinco!"
]
else
[
  print "x é menor que seis!"
]
</screen> A <link linkend="questions">pergunta</link> feita é se <userinput>x</userinput> é maior que 5. Uma vez que <userinput>x</userinput> é inicializado com 4 na primeira linha a resposta à questão é <quote>falso</quote>. Isto significa que o código entre colchetes após o <userinput>else</userinput> será executado.</para></listitem>
    </varlistentry>
  </variablelist>
</sect2>

<sect2 id="for">
<title>O ciclo "for", um ciclo de contagem</title>
<para></para>
  <variablelist>
    <varlistentry>
      <term>for</term>
      <listitem><para><screen>for <userinput>ponto inicial</userinput> a <userinput>ponto final</userinput> [ ... ]</screen>
O ciclo <userinput>for</userinput> é um <quote>ciclo de contagem</quote>, ou seja, faz um contador para você. <screen>
for x = 1 to 10 [
  print x * 7
  forward 15
]
</screen> Cada vez que o código entre parênteses é executado, o <userinput>x</userinput> é incrementado de uma unidade, até que o valor do <userinput>x</userinput> chegue a 10. O código entre parênteses imprime o valor de <userinput>x</userinput> multiplicado por 7. Depois de este programa terminar a sua execução, você irá ver a tabuada dos 7 na área de desenho.</para></listitem>
    </varlistentry>
  </variablelist>
</sect2>

</sect1>


<sect1 id="learn">
<title>Crie os seus próprios comandos com o <quote>learn</quote></title>
<para>O <userinput>learn</userinput> é um comando muito especial, porque ele é usado para criar seus próprios comandos. O comando que você criar pode ter <glossterm linkend="input-output">valores de entrada</glossterm> e retornar <glossterm linkend="input-output">valores de saída</glossterm>. Vamos dar uma olhada em como um novo comando é criado: <screen>
learn circulo x [
  repeat 36 [
    forward x
    turnleft 10
  ]
]
</screen> O novo comando é chamado <userinput>circulo</userinput>. <userinput>circulo</userinput> recebe um <glossterm linkend="input-output">valore de entrada</glossterm>, um número, para configurar o tamanho do círculo. <userinput>circulo</userinput> não retorna nenhum <glossterm linkend="input-output">valor de saída</glossterm>. O comando <userinput>circulo</userinput> pode agora ser usado como um comando normal no resto do código. Veja este exemplo: <screen>learn circulo (x) [
  repeat 36 [
    forward x
    turnleft 10
  ]
]

go 30,30
circulo 20

go 40,40
circulo 50  
</screen>
</para>
<para>No próximo exemplo, um comando com valor de retorno é criado. <screen>
reset

learn multPorSi n [
  r = n * 1
  r = n * n
  return r
]
i = inputwindow "Por favor insira um número e pressione OK"
print i + " multiplicado por ele mesmo é: " + multPorSi i
</screen> Neste exemplo um novo comando chamado <userinput>multPorSi</userinput> é criado. A entrada deste comando é multiplicada por ela mesmo e então retornada, usando o comando <anchor id="return"/><userinput>return</userinput>. O comando <userinput>return</userinput> é a maneira de retornar um valor a partir de uma função que você criou. </para>
</sect1>

</chapter>