1- Tkinter.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tkinter: Introdução"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neste aula vamos apredner como montar uma interface grafica (GUI) em Python usando o framework Tkinter. Essa tecnologia vem junto com o Python e não se precisa instalar separadamente. O processo basico de construir uma interface simples é demonstrado na seguinte figura\n",
    "\n",
    "\n",
    "![Construção em Tkinter](./image/tkinter.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos detalhar o diagrama de fluxo acima e entender o que cada componente está manipulando!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Primeiro, você importa o componente principal, ou seja, o módulo `Tkinter`.\n",
    "- Como a próxima etapa, você inicializa o gerenciador de janelas com o método `window = tkinter.Tk()` e o atribui uma variável. Esse método cria uma janela em branco com botões de fechar, maximizar e minimizar na parte superior, como um GUI comum deve ter.\n",
    "- Então, como uma etapa opcional, você renomeará o título da janela como desejar com `window.title (title_of_the_window)`.\n",
    "- Em seguida, você utiliza um `widget` chamado `Label`, que é usado para inserir algum texto na janela.\n",
    "- Em seguida, você usa o atributo de `gerenciamento de geometria` (geometry management) do Tkinter chamado `pack()` para exibir o `widget` no tamanho necessário.\n",
    "- Finalmente, como a última etapa, você usa o método `mainloop()` para exibir a janela até fechá-la manualmente. Ele executa um loop infinito no backend."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# primeiro, vamos chamar o pacote Tkinter\n",
    "import tkinter\n",
    "\n",
    "#inicilizar o Tkinter e criar uma janela vazia\n",
    "window = tkinter.Tk()\n",
    "\n",
    "# Para renomear o titulo da janela\n",
    "window.title(\"GUI\")\n",
    "\n",
    "#criar um rotulo\n",
    "label = tkinter.Label(window, text = \"Meu primeiro programa de Python usando Tkinter!\")\n",
    "\n",
    "# adicionar o label na janela\n",
    "label.pack()\n",
    "\n",
    "#apresentar a janela\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Gostou?! Agora vamos ver o que sifnifica cada linha do codigo acima. <br>\n",
    "- `import tkinter`: não é nada pratico inventar roda de novo para construir um carro! Na programação tambem essa logica continua valida! Não faz sentido sentar e escrever milhares de codigo para fazer um certo objetivo já que outra pessoa (mais professional do que nos) já escreveu e disponibilizou gratuitamente para a comunidade. `tkinter` é um pacote (um conjunto de milhares de codigos) para criar interfaces graficos. Para utilizar esse pacote dentro no nosso codigo temos que chamar ele. Usamos a palavra-chave `import` para chamar um pacote. Claro, primeiro temos que instalar um pacote para puder chamar! No caso do `tkinter` não foi necessario instalar porque está embutindo no Python. Para instalar um pacote que não seja embutido no Python (a maioria dos casos) na linha de comando digitamos `pip install <nome do pacote>`. Ou se voce tem Anaconda instalado pode usar o comando `conda install <nome do pacote>. \n",
    "- `window = tkinter.Tk()`: Depois de chamar o pacote `tkinter` temos que aprender como ele funciona. O(s) autor(es) de pacotes fornecem uma documentação para cada pacote (cada pacote tem um API para utilizar). Na documentação do `tkinter` está dizendo que para criar uma janela vazia temos que utiliar o comando `tkinter.TK()`. Mas não faz sentido criar uma janela sem nome! Se não tiver nome como vamos puder modifica-la e adicionar mais elementos nela? Os objetos no Python (igual qualquer linguagem de programação), como nos seres humanos devem ter nomes. Bom, as vezes não é necessario mas, neste caso, a gente precisa de um nome para a janela para chamar-la depois. Vamos chamar essa janela de `window`. A gente poderia chamar ela de outra coisa tambem, menos os nomes que o Python não permite! Em Python um nome NÃO pode começar com um digito (1window) e nem pode ter espaço no nome(first window).<br>\n",
    "- `window.title(\"GUI\")`: Cada janela pode ter um nome. Prestam atenção como o nome está sendo inserindo, dentro de `\" \"`. Quando a gente coloca uma expressão dentro de `\" \"`, na verdade, estamos criando um `string`. Um `string` é um tipo de variavel. Ao longo do curso vamos ver outras variaveis do Python.\n",
    "- `label = tkinter.Label(window, text = \"Meu primeiro programa de Python usando Tkinter!\")`: Cada pacote tem uma estrutura interna. Tem varios objetos dentro de pacote. Vamos chamar esses objetos de `class`. Mais na frente, vamos aprender como criar uma `class`. Para utilizar um `class` dentro de um pacote temos que mencionar o nome do pacote, ponto, nome da `class`. Nesta linha de codigo, queremos criar um rotulo, um espaço para escrever no texto dentro da nossa janela. Com o comando `tkinter.Label()` podemos criar um rotulo e o chamamos de `label`. Mas peraí, se a gente tiver mais de uma janela no nosso programa esse rotulo pertence a qual delas? E o texto dentro do rotulo? Para resolver essas questões inserimos os argumentos `window, text = \"Meu primeiro programa de Python usando Tkinter!\"` na hora de construir o rutulo. O `windows` quer dizer que esse rotulo pertence a janela `window`. Tem outros argumentos que podemos inserir dentro do `Label` para definir as suas caracteristicas tais como altura e largura. Mas aqui não queremos complicar demais no momento! \n",
    "- `label.pack()`: Agora é a hora de colocar o `label` na janela. Temos varias formar de organizar um elemento em uma janela. `pack()` é um deles. Esse comando cola o rotulo no centro da janela, na parte superior. \n",
    "- `window.mainloop()`: finalmente com esse comando, exibimos a janela `window`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Gostou?! \n",
    "Da mesma forma do programa acima, a gente pode ter um botão `Button`, e a GUI exibirá um botão em vez de algum texto de um rotulo. No codigo abaixo, a unica novidade é a classe `Button`. Como o nome se diz, cria um botão. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter\n",
    "\n",
    "window = tkinter.Tk()\n",
    "window.title(\"Button GUI\")\n",
    "\n",
    "button_widget = tkinter.Button(window,text=\"Meu primeiro programa de Python usando Tkinter!\")\n",
    "button_widget.pack()\n",
    "\n",
    "tkinter.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Outra coisa que vale a pena mencionar é que facilmente podemos mudar o tamanho da janela"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter\n",
    "\n",
    "window = tkinter.Tk()\n",
    "window.title(\"Button GUI\")\n",
    "window.geometry('400x250')\n",
    "\n",
    "button_widget = tkinter.Button(window,text=\"Meu primeiro programa de Python usando Tkinter!\")\n",
    "button_widget.pack()\n",
    "\n",
    "tkinter.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Embora a gente já tenha aprendido a usar `Widgets` no Tkinter, vamos descobrir quais outros widgets estão disponíveis no Tkinter e o funcionamento de cada um deles."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Widgets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os widgets são similares em espírito aos elementos que a gente ve em qualquer aplicativo ou pagina de web. Há diferentes tipos de widgets para diferentes tipos de elementos no Tkinter. Eles são elementos padrão de um GUI e fornecem ao usuário controles como botões, texto, menus e caixas de texto e etc.<br>\n",
    "Vamos entender alguns desses widgets no Tkinter, junto com um exemplo"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Button (Botão):** \n",
    "O widget de botão possui uma propriedade para ativar/desativar. Quando o usuário clica no botão, um evento é acionado no Tkinter. O que vai fazer esse evento? Deperende do que o programador tenha planejado.\n",
    "\n",
    "- Sintax: `button_widget = tkinter.Button(window, option = placeholder)`. O `window` é o argumento para determinar a janela/frame que o widget pertence, enquanto `option` é um placeholder (espaço reservado) que pode ter vários valores como a cor do background/foreground, fonte, comando (para chamada de função), imagem, altura e largura do botão. Nos exemplos acima, o texto do `Label` é um exemplo para os argumentos opcionais. \n",
    "\n",
    "\n",
    "#### **Canvas (Tela):** \n",
    "A tela é usada para desenhar formas em GUI e suporta vários métodos de desenho (se lembra do Paint do Windows?).\n",
    "\n",
    "- Sintax: `canvas_widget = tkinter.Canvas (window, option = placeholder)`. O `window` é o argumento para determinar a janela/frame que o widget pertence, enquanto `option` é um placeholder que pode ter vários valores, como largura da borda, cor do plano de fundo, altura e largura do widget.\n",
    "\n",
    "\n",
    "####  **Checkbutton (Botão de verificação):** \n",
    "o botão de verificação registra o estado ativado ou desativado. Permite selecionar mais de uma opção por vez e até deixá-la desmarcada.\n",
    "\n",
    "- Sintax: `checkbutton_widget = tkinter.CheckButton(window, option = placeholder)`. O `window` é o argumento para determinar a janela/frame que o widget pertence, enquanto `option` é um placeholder que pode ter vários valores como título, texto, a cor de background/foreground enquanto o widget está sob o cursor , fonte, imagem etc.\n",
    "\n",
    "#### **Entry (Entrada):** \n",
    "o widget de entrada é usado para criar campos de entrada ou obter texto de entrada do usuário no GUI. \n",
    "\n",
    "- Sintax: `entry_widget = tkinter.Entry(window, option = placeholder)`. O `window` é o argumento para determinar a janela/frame que o widget pertence, enquanto `option` é um placeholder que pode ter vários valores, como largura da borda, cor do plano de fundo (background), largura e altura do botão etc.\n",
    "\n",
    "#### **Text:**\t\n",
    "Parecido com o `Entry` mas permite varias linhas de texto.\n",
    "\n",
    "#### **Frame (Quadro):** \n",
    "O quadro é usado como contêiner no Tkinter para agrupar e organizar adequadamente os widgets. \n",
    "\n",
    "- Sintax: `frame_widget = tkinter.Frame(window, option = placeholder)`. O `window` é o argumento para determinar a janela/frame que o widget pertence, enquanto `option` é um placeholder que pode ter vários valores, como largura da borda, altura e largura do widget, a cor de destaque (cor quando widget deve ser focado).\n",
    "\n",
    "#### **Label (rotulo):** \n",
    "Label é usado para criar widgets de uma única linha, como texto, imagens, etc. <br>\n",
    "- Sintax: `label_widget = tkinter.Label(window, option = placeholder)`. O `window` é o argumento para determinar a janela/frame que o widget pertence, enquanto `option` é um espaço reservado que pode ter vários valores, como a fonte de um rotulo, a cor de fundo, imagem, largura e altura do rotulo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Você pode encontrar a lista completa de widgets no site oficial do Python [documentação](https://docs.python.org/3/library/tk.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gerenciamento de Geometria (Geometry Management)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Todos os widgets no Tkinter têm algumas medidas de geometria. Essas medidas de geometria permitem organizar os widgets dentro dos frames ou da área do widget (sim, pode ter um botão dentro de um rotulo!).\n",
    "\n",
    "Uma das classes de gerenciamento de geometria, a `pack()`, já foi abordada aqui.\n",
    "\n",
    "No total, para esse fim, o Tkinter fornece três classes principais de gerenciador de geometria:\n",
    "- **pack()**: organiza os widgets de maneira em bloco e a largura disponível completa é ocupada por ele. É um método convencional para mostrar os widgets na janela.\n",
    "\n",
    "\n",
    "- **grid():** organiza os widgets em uma estrutura em forma de tabela. Você aprenderá sobre isso em detalhes posteriormente neste tutorial.\n",
    "\n",
    "\n",
    "- **place():** O seu objetivo é colocar os widgets em uma posição específica, conforme instruído pelo usuário no widget."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Organização de Layout e Widgets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nesta seção do tutorial, a gente fará uso do `geometry` e dos `widgets`, e vamos ver a mágica do Tkinter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para organizar o layout no `window`, você utilizará uma classe de widget que se chama `Frame`. Vamos criar um programa simples para ver como o `Frame` funciona. O Frame (quadro) é uma forma de agrupar os widgets para serem mais organizados. Um tipo de \"janela\" dentra janela principal. \n",
    "- Vamos definir dois `Frame`s - superior e inferior com a ajuda da classe `pack`. A classe `Frame` ajudará na criação de uma divisão entre a janela. Basicamente, uma única janela será replicada duas vezes como superior e inferior na forma de um frame (quadro).\n",
    "- Por fim, a gente criará quatros botões na janela, dois para cada frame. a gente pode nomear e até colorir os seus botões como desejar usando os parâmetros opcionais na hora de os construir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter\n",
    "\n",
    "# Vamos criar uma janela (window).\n",
    "window = tkinter.Tk()\n",
    "window.title(\"GUI\")\n",
    "\n",
    "# primeiro vc cria a divisão com a ajuda da classe Frame e depois alinha eles (frames) no topo e baixo usando pack()\n",
    "top_frame = tkinter.Frame(window).pack()\n",
    "bottom_frame = tkinter.Frame(window).pack(side = \"bottom\") #side =tkinter.BOTTOM\n",
    "\n",
    "#Uma vez que os frames (quadros) foram criados pode adicionar os seus widgets para cada um quadro\n",
    "btn1 = tkinter.Button(top_frame, text = \"Button1\", fg = \"red\").pack() #'fg ou foreground' é para colorir o conteudo dos botões(buttons)\n",
    "\n",
    "btn2 = tkinter.Button(top_frame, text = \"Button2\", fg = \"green\", bg = 'black').pack() # 'bg ou background' é a cor do fundo\n",
    "\n",
    "btn3 = tkinter.Button(bottom_frame, text = \"Button3\", fg = \"purple\").pack(side = \"left\") \n",
    "\n",
    "btn4 = tkinter.Button(bottom_frame, text = \"Button4\", fg = \"orange\").pack(side = \"left\") #side =tkinter.LEFT\n",
    "\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Diferentes tipos de variaveis do Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Antes de continuar a nossa discussão sobre a organização de uma janela vamos olhar com mais detalhes para diferentes tipos de variaveis que exitem no Python\n",
    "- Numerico (integer e float): um numero, tipo 0, 2.2, 3.0 ,-1, -24.003\n",
    "- String: um texto ou um conjunto de letras \"oi\", \"pyThOOOOn\", \"2\" (prestem atenão que um string tem `\"  \"`)\n",
    "- Booleanos: False e True\n",
    "<br>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para criar uma varivel no Python não é necessario a declarar primeiro, só criando e usando que o Python vai descobrir o seu tipo! (É facil, né?!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2\n",
    "y = -3.004\n",
    "z = 'oi'\n",
    "w = True # or False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para verificar o tipo de uma variavel usamos da função `type()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ver o conteudo dentro de uma variavel usamos da função `print()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos somar e subtrair as variaveis numericas facilmente. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.004"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x+y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No Python, diferente de muitas linguagem de programação, podemos somar dois strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'oioi'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z+z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos multiplicar um numero por um string tambem (preste atenção no espaço no inicio do string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' oi oi oi oi oi'"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 * \" oi\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma coisa muito importante é que o Python não está nos vigiando quando alteramos o tipo ou conteudo de uma variavel! Somos compeletamete livres! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 'oi'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "oi\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mas essa liberdade tem um preço! Muitas vezes precisamos rastrear (tracing) o conteudo de uma variavel para ver como está sendo modificado. O `Tkinter` tem uma solução para isso que vamos ver na proxima seção"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tkniter: Grid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assim como um `Frame`, um grid (grade) é outra maneira de organizar os widgets. Ele usa o conceito de uma matriz (colunas e linhas). Vamos desenhar uma analogia entre a classe `Grid` e a idéia de coluna e linha com a ajuda do diagrama abaixo de uma matriz $2\\times2$.\n",
    "![alt text](./image/grid.png \"Uma matriz quadrada 2x2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O `Grid`, primeiramente, pega parâmetros de `row` (linha) e `column` (coluna). Como foi mostrado na figura acima,  `00` corresponde ao primeiro botão enquanto `01` ao segundo. E para colocar dois botões lado a lado, o `Grid` assumirá os parâmetros de linha e coluna como `00` e `01`, respectivamente.\n",
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "\n",
    "window = tk.Tk()\n",
    "window.title(\"GRID\")\n",
    "window.geometry('200x300')\n",
    "\n",
    "b1 = tk.Button(window, text = \"00\")\n",
    "b1.grid(row=0, column=0)\n",
    "\n",
    "b2 = tk.Button(window, text = \"01\").grid(row=0, column=1)\n",
    "\n",
    "b3 = tk.Button(window, text = \"10\").grid(row=1, column=0)\n",
    "\n",
    "b4 = tk.Button(window, text = \"11\").grid(row=1, column=1)\n",
    "\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O exemplo acima foi completamente ilustrativo e sem graça! Escolhendo opções diferentes nada acontecia. Agora vamos ver um exemplo melhor que ajuda agente entender melhor as variaveis rastreadas do `Tkinter`. Mas antes disso, como foi prometido, vamos ver os diferentes tipos de variaveis do `tkinter`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# As variaveis monitoradas do Tkinter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " O Tkinter suporta algumas variáveis usadas para manipular os valores dos widgets do Tkinter. Essas variáveis funcionam como variáveis normais, mas estão sendo monitorados.\n",
    "Os métodos `set()` e `get()` são usados para definir e recuperar os valores dessas variáveis.\n",
    "Os valores dessas variáveis podem ser configurados usando o método set() ou usando o construtor dessas variáveis:\n",
    "- BooleanVar()\n",
    "- StringVar()\n",
    "- IntVar()\n",
    "- DoubleVar()\n",
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "\n",
    "\n",
    "window = tk.Tk() \n",
    "\n",
    "# variaveis do Tkinter \n",
    "\n",
    "intvar = tk.IntVar(window, value = 25) \n",
    "strvar = tk.StringVar(window, \"Hello !\") \n",
    "boolvar = tk.BooleanVar(window, True) \n",
    "doublevar = tk.DoubleVar(window, 10.25) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para verificar o conteudo dessas variaveis usamos o metodo `get()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello !\n"
     ]
    }
   ],
   "source": [
    "print(strvar.get())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tem outra forma de associar um valor em uma variavel do Tkinter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "\n",
    "master = tk.Tk() \n",
    "\n",
    "# Declarando as  variaveis \n",
    "intvar = tk.IntVar() \n",
    "strvar = tk.StringVar() \n",
    "boolvar = tk.BooleanVar() \n",
    "doublevar = tk.DoubleVar() \n",
    "\n",
    "\n",
    "# usando set() para inserir um valor dentro das variaveis\n",
    "intvar.set(100) \n",
    "strvar.set(\"GFG\") \n",
    "boolvar.set(False) \n",
    "doublevar.set(10.36) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GFG\n"
     ]
    }
   ],
   "source": [
    "print(strvar.get())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exemplo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora vamos ver um exemplo intressante do funcionamento das variaveis monitoradas. Aqui usamos um argumento novo das classe `Label` e `Entry`. Esse argumento nos permita alterar o texto dessas classe dinamicamente. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "\n",
    "root = Tk()\n",
    "var = StringVar()\n",
    "var.set('hello')\n",
    "\n",
    "l = Label(root, textvariable = var)\n",
    "l.pack()\n",
    "\n",
    "t = Entry(root, textvariable = var)\n",
    "t.pack()\n",
    "\n",
    "root.mainloop() # the window is now displayed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos dar outro exemplo para entender melhor o `Grid`. Neste exemplo, a gente passará uma coluna (`column`) como parâmetro junto com a linha (`row`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter\n",
    "# Vamos criar uma janela de Tkinter\n",
    "window = tkinter.Tk()\n",
    "window.title(\"GUI\")\n",
    "\n",
    "# aqui vamos criar dois rotulos, 'username' e 'password' e dois rotulos de entrada para eles\n",
    "tkinter.Label(window, text = \"Username\").grid(row = 0) #'username' é colocado na posição 00 (row - 0 e column - 0)\n",
    "\n",
    "# A classe 'Entry' é usada para exibir um campo para que o usuario possa inserir os dados. Esse widget vai ficar do lado do rotulo acima\n",
    "tkinter.Entry(window).grid(row = 0, column = 1) # first input-field is placed on position 01 (row - 0 and column - 1)\n",
    "\n",
    "tkinter.Label(window, text = \"Password\").grid(row = 1) #'password' é posicionado na 10 (row - 1 e column - 0)\n",
    "\n",
    "tkinter.Entry(window).grid(row = 1, column = 1) #o segundo \"input field\" é posicionado na 11 (row - 1 e column - 1)\n",
    "\n",
    "# A classe 'Checkbutton' é usado para criar um checkbutton que pega um 'columnspan' no valor 2 (cobre as duas colunas)\n",
    "tkinter.Checkbutton(window, text = \"Keep Me Logged In\").grid(columnspan = 2)                 \n",
    "\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Opcional - Tkinter: `CheckBoxes`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aqui vamos ver um exemplo de como construir um `checkBox` no `tkinter` usando `grid()`. A gente definirá dois botões de verificação e colocamos um texto para dos dois botões. O estado dos `CheckButton`s será decidido pelo `onvalue` e `offvalue`, enquanto o estado atual do checkbottun será rastreado por `IntVar()`, que será armazenado em uma variável separada. Quando `offvalue = 1` e `onvalue = 0`, o botão de verificação correspondente será marcado. Daqui a pouco vamos falar mais sobre as variaveis do `tkitner`\n",
    "<br>\n",
    "Agora, chegando à classe `Grid`, a gente passará um parâmetro de `row`, que posicionará o botão na primeira linha se `row = 0` e na segunda linha se `column = 1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "# assim podemos escolher um apelido para um pacote, por motivo de preguiça (ou estetica!)\n",
    "# a opção sticky pode os constantes S, N, E, and W, or NW, NE, SW, and SE.\n",
    "import tkinter as tk\n",
    "\n",
    "window = tk.Tk()\n",
    "\n",
    "CheckVar1 = tk.IntVar()\n",
    "CheckVar2 = tk.IntVar()\n",
    "\n",
    "check_button1 = tk.Checkbutton(window, text = \"Machine Learning\",variable = CheckVar1, onvalue = 1, offvalue =0)\n",
    "check_button1.grid(row=0, sticky = tk.W)\n",
    "\n",
    "check_button2 = tk.Checkbutton(window, text = \"Deep Learning\", variable = CheckVar2, onvalue = 1, offvalue =0)\n",
    "check_button2.grid(row=1, sticky = tk.W)\n",
    "\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tkinter: Place"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Você pode usar o metodo `place ()` para controlar o local preciso que um widget deve ocupar em uma janela ou frame. Você deve fornecer dois argumentos de palavra-chave, `x` e `y`, que especificam as coordenadas x e y para o canto superior esquerdo do widget. Ambos x e y são medidos em pixels, não em unidades de texto.\n",
    "<br>\n",
    "Lembre-se de que a origem (onde `x`e `y` são ambos `0`) é o canto superior esquerdo do quadro ou janela. Portanto, você pode pensar no argumento y de `place()` como o número de pixels da parte superior da janela e o argumento x como o número de pixels à esquerda da janela.\n",
    "<br>\n",
    "Aqui está um exemplo de como o gerenciador de geometria .place () funciona:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter\n",
    "\n",
    "#vamos criar uma janela\n",
    "window = tkinter.Tk()\n",
    "\n",
    "#vamos criar um frame com largura (width) e altura (height) determinada\n",
    "frame = tkinter.Frame(master=window, width=200, height=150)\n",
    "frame.pack()\n",
    "\n",
    "#criando um \"Label\" e colocar ele na posição (0,0)\n",
    "label1 = tkinter.Label(master=frame, text=\"Estou na (0, 0)\", bg=\"red\")\n",
    "label1.place(x=0, y=0)\n",
    "\n",
    "#criando um \"Label\" e colocar ele na posição (75,75)\n",
    "label2 = tkinter.Label(master=frame, text=\"Estou na (75, 75)\", bg=\"yellow\")\n",
    "label2.place(x=75, y=75)\n",
    "\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter\n",
    "\n",
    "#vamos criar uma janela\n",
    "window = tkinter.Tk()\n",
    "\n",
    "#vamos criar um frame com largura (width) e altura (height) determinada\n",
    "frame = tkinter.Frame(master=window, width=200, height=150)\n",
    "frame.pack()\n",
    "\n",
    "#criando um \"Label\" e colocar ele na posição (0,0)\n",
    "label1 = tkinter.Label(master=frame, text=\"Estou na (0, 0)\", bg=\"red\")\n",
    "label1.place(x=0, y=0)\n",
    "\n",
    "#criando um \"Label\" e colocar ele na posição (75,75)\n",
    "label2 = tkinter.Label(master=frame, text=\"Estou na (75, 75)\", bg=\"yellow\")\n",
    "label2.place(x=75, y=75)\n",
    "\n",
    "window.mainloop()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.15"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  },
  "vscode": {
   "interpreter": {
    "hash": "92b1d5f842d7c1e714e1ab666cefb8d1f75311aac337aae0336133957fcbf554"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}