Internationalizing the editor and tutorials and translating them into Brazilian Portuguese

.gitignore

@@ -1,3 +1,8 @@
+# translations
+# *.mo  # NOTE: including the .mo in the repository to allow simple installation via: pip install git+<url>
+*.pot
+
+
 # demo and debug folders
 myTests/*
 __pycache__/
@@ -98,4 +103,4 @@ Temporary Items
 # swp files
 *.swp
 
-.idea/
+.idea/

FoxDot/demo/pt_BR/00_introdução.py

@@ -0,0 +1,21 @@
+# Tutorial 0: Introdução
+
+################
+# Executando  código
+
+# Para executar o código no FoxDot, vá com seu cursor de texto até o 'bloco' de código
+# (seção de texto não separada por linhas em branco) e pressione Ctrl+Enter
+
+# Para executar apenas uma linha ao invés do bloco, pressione Alt+Return
+
+# Tente isso agora, mova o cursor para a linha de código abaixo e pressione Ctrl+Enter
+
+print("Hello World")
+
+##############
+# Ajuda
+
+# Se você esquecer, ou quiser saber mais sobre a função ou classe
+# escreva help seguido pelo nome do objeto Python entre parênteses:
+
+help(object)

FoxDot/demo/pt_BR/01_primeiros_sons.py

@@ -0,0 +1,108 @@
+# Tutorial 1: Primeiros Sons
+
+# No FoxDot, todas as variáveis com dois caracteres são reservadas para os objetos players, por exe,plo, 'p1'
+# Criar um objeto Player sem parâmetros tocará uma única nota, C central por padrão, repetidamente até ser parada.
+# Use >> para pagar um desse sons para um objeto player, por exemplo:
+
+p1 >> pluck()
+
+# Para parar um objeto player individual, simplismente execute
+
+p1.stop()
+
+# Além das variáveis de dois caractes que que são pré-reservadas, você pode criar seus
+# próprios com um nome de sua escolha
+
+foo = Player()
+foo >> pluck()
+
+# O >> no Python normalmente é reservada para um tipo de operação, como + ou -, mas isso não é o caso no caso no FoxDot.
+# Se um usuário re-executar o código, FoxDot atualizará p1 instantaneamente criando um PlayerObject,
+# isso quer dizer que você pode fazer mudanças na sua música  usando apenas uma linha de código.
+
+# Agora se você passar um parâmetro para seu objeto player, você pode mudar a nota que será tocada.
+# O primeiro parâmetro deve ser o grau da nota a ser tocada
+# (por padrão é a nota mais baixa de 5 oitava da escala maior) e não precisa ser especificado pelo name.
+
+# Python, como muitas linguagens de programação, usa indexação-zero quando acessado valores em um array,
+# isso significa que 0 refere-se a primeira nota da escala.
+# Passe para o seu objeto player instruções para fazer música com seu Synth.
+# O primeiro parâmetro é a nota a da escala a ser tocada. O seguinte código
+# toca as 3 primeiras notas de escala padrão (maio) repetidamente.
+
+# Uma única nota
+p1 >> pluck(0)
+
+# Or a list of notes
+# Ou uma lista de notas
+p1 >> pluck([0,1,2])
+
+# Mas, você precisa especificar qualquer outra mudança...
+
+# Como as durações das notas, ou o tamanho de cada nota
+p1 >> pluck([0,0,0], dur=[1,2,3])
+
+# Ou a amplitude, o "volume" de cada nota
+p1 >> pluck([0,0,0], amp=[1,2,3])
+
+# Se a segunda lista, o amp, por exemplo, for mais longa, então, a primeira lista (os graus) apenas voltará ao começo, e será pareados com os elementos restantes da segunda lista (a amplitude).
+p1 >> pluck([0,2,4], amp=[1,2,3,1,5])
+
+# De modo geral, todas as listas são atravedas independente do seu tamanho
+p1 >> pluck([0,2,4], dur=[1,2], amp=[1,2,3,1,5])
+
+# Os parâmetros podem ser inteiro, ponto flutuante, fração, lista,
+# tuplas, ou um misto de todos os anteriores
+
+p1 >> pluck([0,0,0], dur=2)
+
+p1 >> pluck([0,0,0], dur=1.743)
+
+p1 >> pluck([0,0,0], dur=[0.25,0.5,0.75])
+
+p1 >> pluck([0,0,0], dur=[1/4,1/2,3/4])
+
+p1 >> pluck([0,0,0], dur=[1/4,0.25,3])
+
+# Listas de valoers são iteradas enquanto o Player toca as notas
+# A seguinte duração é igual a: 1,2,3,1,4,3
+# Se você não entender isso, não se preocupe, isso será abordado com mais detalhes no tutorial sobre Padrões
+p1 >> pluck([0,0,0], dur=[1,[2,4],3])
+
+# Valores in uma tuplas são usados simultaneamente, por exemplo, p1 tocará 3 notas individuais, então, um acordes de 3 notas tocadas juntas, ao mesmo tempo.
+p1 >> pluck([0,2,4,(0,2,4)])
+
+# Você pode passar valores para os atributos do objeto player diretamente
+p1.oct = 5
+
+# Para ver todos os nomes dos atriburos do Player, apenas execute
+print(Player.get_attributes())
+
+# Um tutorial sobre os atributos do Player irá abordar o assunto com mais detalhes
+
+# Você também pode armazenar diferentes players e usa-los em lugares diferentes
+proxy_1 = pads([0,1,2,3], dur=1/2)
+proxy_2 = pads([4,5,6,7], dur=1)
+
+p1 >> proxy_1 # Primeiro usando o p1 
+
+p1 >> proxy_2 # Isso troca as instruções do p1
+
+# Para tocar varias sequencias juntas, basta fazer a mesma coisa com outro player
+# Player object:
+
+p1 >> pluck([0, 2, 3, 4], dur=1/2)
+
+p2 >> pads([(0, 2, 4), (3, 5, 7)], dur=8)
+
+# Toca apenas esse player, muta os outros
+p1.solo() # valor padrão é 1 (solo ativo)
+
+# E então desative o solo
+p1.solo(0)
+
+# Pare (não apenas mute) outros players
+p1.only()
+
+# Use Ctrl+. para limpar tudo que estiver agendado no relógio (parar o som de todos os players) ou execute
+Clock.clear()

FoxDot/demo/pt_BR/02_manipulação_algorítimica.py

@@ -0,0 +1,43 @@
+# Tutorial 2: Manipulação Algorítimica
+
+# O código a baixo toca as quatro primeiras notas da escala padrão repetidamente:
+p1 >> pads([0,1,2,3])
+
+# É posível manipular isso, por exemplo, adicionando uma lista de números para o objeto Player
+# isso adiciona 2 graus à 4 nota tocada
+p1 >> pads([0,1,2,3]) + [0,0,0,2]
+
+# e isso adiciona 2 graus a cada 3 notas tocadas
+p1 >> pads([0,1,2,3]) + [0,0,2]
+
+# os valores também podem ser entrelaçados ou agrupados
+p1 >> pads([0,1,2,3]) + [0,1,[0,(0,2)]]
+
+# esse comportamente é particularmente útil com o método follow.
+b1 >> bass([0,4,5,3], dur=2)
+p1 >> pads().follow(b1) + [2,4,7]
+
+# Você pode agendar ações para os players
+# isso dirá ao p1 para inverter as notas a cada 4 batidas
+p1 >> pads([0,2,4,6])
+p1.every(4, "reverse")
+
+# Você pode "encadear" o método junto do player adicionando-o ao final
+# da linha original:
+p1 >> pads([0,2,4,6]).every(4, "reverse")
+
+# Para cancelar o "reverse", use o método 'never':
+
+p1.never("reverse")
+
+# Aqui estão alguns outros métodos que você usar:
+
+# Usar "stutter" tocará a mesma nota 'n' vezes com diferentes atributes especificados
+
+p1.every(4, "stutter", 4, oct=4, pan=[-1,1])
+
+# Rotate moverá todos os valores em 1 em ordem
+p1.every(4, "rotate")
+
+# Para mudar a ordem das notas aleatóriamente, use "shuffle"
+p1.every(4, "shuffle")

FoxDot/demo/pt_BR/03_reproduzindo_samples.py

@@ -0,0 +1,84 @@
+# Tutorial 3: Reproduzindo Samples Embutidos
+
+
+# FoxDot também pode usar uma sequência e manipular samples de áudio.
+# Para fazer isso, tudo que o você precisa é usar SynthDef especial: o 'play'.
+# O primeiro parâmetro do SynthDef play deve ser uma string de caracteres
+# diferente de uma lista de números como você faria com outros SynthDef.
+# Cara caractere representa um arquico diferente de áudio, que está armazenado em um buffer no SuperCollider.
+
+# Para ver a relação do caracter com cada arquivo de áudio, execute
+print(Samples)
+
+# Você pode tocar arquivos de samples nos sub diretórios de FoxDot/snd/ usando o
+# Synth 'play' e usand uma string de caracteres ao invés de uma lista de notas.
+bd >> play("x")
+
+# Um caractere refere-se a um som e um espaço vazio (ou qualquer outro caractere que não tem uma sample mapeado) é  usado para silencio, então
+# você pode espalhar o som pelo tempo
+bd >> play("x  x  x  ")
+
+hh >> play(" -")
+
+# Você pode entrelaçar padrões usando parênteses
+# isso é equivalente a: "x o  xo "
+d1 >> play("(x )( x)o ")
+
+# O código a baixo é o mesmo que "-------="
+hh >> play("---(-=)")
+
+# Colocar caracteres entre colchetes tocará tudo em um espaço de uma batida
+# e tocará como um caracter, não simultaneamente, mas, em uma rapida subsequência
+d1 >> play("x-o[-o]")
+
+d1 >> play("x-o[---]")
+
+d1 >> play("x-o[-----]")
+
+d1 >> play("x-o[--------------]")
+
+# e podem ser colocados entre parênteses como se fosse um único caracter.
+d1 >> play("x[--]o(=[-o])")
+
+# Você pode combinar parênteses como desejar: os padrões abaixo são identicos
+d1 >> play("x-o(-[-o])")
+
+d1 >> play("x-o[-(o )]")
+
+# As chaves selecionam um sample aleatóriamente, se você quiser mais variação
+d1 >> play("x-o{-=[--][-o]}")
+
+# Os colchetes angulares combinam padrões para serem tocados simultaneamente
+d1 >> play("<X   ><-   ><#   ><V   >")
+
+d1 >> play("<X   >< -  ><  # ><   V>")
+
+# Cara caracter é mapeado para uma pasta de arquivos se som e você pode selecionar diferentes
+# samples usando o parâmetro nomeado "sample"
+d1 >> play("(x[--])xu[--]")
+
+d1 >> play("(x[--])xu[--]", sample=1)
+
+d1 >> play("(x[--])xu[--]", sample=2)
+
+# Muda o sample a cada batida
+d1 >> play("(x[--])xu[--]", sample=[1,2,3])
+
+# Você pode criar duas camadas de padrões juntos - note o "P", veja o tutorial 4 para mais informações.
+d1 >> play(P["x-o-"] & P[" **"])
+
+# E mude efeitos aplicando-o para todas as camadas de padrões ao mesmo tempo
+d1 >> play(P["x-o-"] & P[" **"], room=0.5)
+
+# Exemplos com samples para o tutorial de players
+# Condicionais...
+d1 >> play("x[--]xu[--]x", sample=(d1.degree=="x"))
+
+# Ou mude para o 2 sample multiplicando
+d1 >> play("x[--]xu[--]x", sample=(d1.degree=="x")*2)
+
+# Encadeie multiplas condicionais
+d1 >> play("x[--]xu[--]x", sample=(d1.degree=="x")*2 + (d1.degree=="-")*5)
+
+# Isso é o mesmo que
+d1 >> play("x[--]xu[--]x", sample=d1.degree.map({"x":2, "-":5}))