Tkinter'a Giriş.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "fa7a7521",
   "metadata": {},
   "source": [
    "# Tkinter'a giriş:\n",
    "\n",
    "Bu dosyada, tkinter kütüphanesi içerisinde bulunan ve aşağıdaki başlıklarda belirtilen konular, örneklerle beraber açıklanmıştır. Dosya içerisindeki konu başlıkları aşağıdaki gibidir:\n",
    "\n",
    "### Konu Başlıkları:\n",
    "\n",
    "1-) [Widgets](#widgets)\n",
    "\n",
    "2-) [Settings and Getting Data](#settings)\n",
    "\n",
    "3-) [Variables](#variables)\n",
    "\n",
    "4-) [Buttons](#buttons)\n",
    "\n",
    "5-) [Buttons with Arguments](#buttons-arguments)\n",
    "\n",
    "[BMI Calculator](#bmi)\n",
    "\n",
    "6-) [Events](#events)\n",
    "\n",
    "7-) [Combobox and Spinbox](#combobox)\n",
    "\n",
    "8-) [Canvas](#canvas)\n",
    "\n",
    "[Simple Paint Application](#paint)\n",
    "\n",
    "9-) [Tables](#tables)\n",
    "\n",
    "10-) [Sliders](#sliders)\n",
    "\n",
    "11-) [Parenting Frames](#frames)\n",
    "\n",
    "12-) [Tabs](#tabs)\n",
    "\n",
    "13-) [Menus](#menu)\n",
    "\n",
    "14-) [Windows](#windows)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e11bea50",
   "metadata": {},
   "source": [
    "<a id=\"widgets\"></a>\n",
    "# 1-) Widgets"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "230e0dd3",
   "metadata": {},
   "source": [
    "İlk olarak; ihtiyaç duyduğumuz modülleri import ediyoruz:\n",
    "\n",
    "    import tkinter as tk\n",
    "    from tkinter import ttk\n",
    "\n",
    "Ardından; tuş, etiket vs. gibi araçlarımızı(**widget**) yerleştirmek için bir pencere oluşturuyoruz:\n",
    "\n",
    "    window = tk.Tk()\n",
    "    window.title(\"widgets\")\n",
    "    window.geometry(\"800x600\")\n",
    "    \n",
    "Bir adet `tk.Tk()` örneği(**instance**) oluşturup **window**, **root** veya **app** isimli bir değişkene atıyoruz. (Genelde ana pencere için kullanılan değişken isimleri bunlar.) Ardından oluşturduğumuz pencerenin `title` ve `geometry` metotlarını kullanarak penceremize bir isim veriyoruz ve penceremizin boyutunu belirliyoruz. \n",
    "\n",
    "**Not:** `geometry` metoduna boyutları girerken **string** değeri kullanıyoruz **integer** değil.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Pencere kurulumumuzu tamamladıktan sonra widgetlarımızı ekleyebiliriz.\n",
    "\n",
    "`tk.Text` metin girmemizi sağlayan geniş bir kutu oluşturuyor. Kendisini **text** isimli bir değişkene atadıktan sonra içerisine ilk parametremizi giriyoruz. Her **widget**, ilk parametre olarak bağlı olduğu pencereyi bekler. Yani **master=**. Bu örnekte ana penceremizi **window** diye tanımladığımız için onu giriyoruz. Ardından, oluşturulan widget'ı penceremizde görmek için `pack`, `grid` ya da `place` metodunu kullanmamız gerekiyor. Şimdilik `pack` metodunu kullanacağız.\n",
    "\n",
    "    text = tk.Text(master = window)\n",
    "    text.pack()\n",
    "\n",
    "**Not:** Oluşturulan pencerede, widget'ları yerleştirmek için seçilen metodun aynı olması lazım. Örneğin: Biz bu uygulamamızda `pack` metodunu kullanacağımız için **window** içerisinde `grid` ve `place` kullanamayız.\n",
    "\n",
    "<hr>\n",
    "\n",
    "`tk.Label` bir etiket görevi görmekte. İlk parametre olarak yine bağlı olduğu pencereyi giriyoruz. **text=** parametresi etiket üzerinde yazmasını istediğimiz yazıyı belirliyor.\n",
    "\n",
    "    label = ttk.Label(master = window, text = \"This is a test\")\n",
    "    label.pack()\n",
    "\n",
    "**Not:** tk yerine ttk kullandığımızda farklı olan şey, widget'ın görünümü. ttk daha modern bir görünüme sahip.\n",
    "\n",
    "<hr>\n",
    "\n",
    "`tk.Entry` widget'ını **input** olarak kullanıyoruz.\n",
    "\n",
    "    entry = ttk.Entry(master = window)\n",
    "    entry.pack()\n",
    "\n",
    "    label1 = ttk.Label(master = window, text = \"my label\")\n",
    "    label1.pack()\n",
    "    \n",
    "<hr>\n",
    "\n",
    "Adından da anlaşılacağı üzere, `tk.Button` ve `ttk.Button` bir tuş, buton oluşturuyor. Önceki widget'lardan ayrıca **command=** parametresine sahip. Bir butona tıkladığımızda bir görevi yerine getirmesini bekleriz, işte command parametresi bu amaçla kullanılıyor. Butonun yapmasını istediğimiz fonksiyonu, command parametresine atıyoruz.\n",
    "\n",
    "Aşağıdaki örnekte tanımladığımız **button**, yine bizim tanımladığımız `button_func` fonksiyonunu çalıştırıyor. Fark ettiğiniz üzere command kısmına fonksiyonu **button_func** diye girdik. **button_func()** şeklinde değil. Bunun sebebi, eklediğimiz parantez fonksiyonu çağırmak için, ama biz tuşa basılmadığı müddetçe fonksiyonun çalışmasını istemiyoruz. O yüzden command parametresine, fonksiyonlarımızın parantezlerini koymadan yazıyoruz.\n",
    "\n",
    "    def button_func():\n",
    "        print(\"a button was pressed.\")\n",
    "\n",
    "    button = ttk.Button(master = window, text = \"A button\", command = button_func)\n",
    "    button.pack()\n",
    "    \n",
    "Peki, command parametresine atamak istediğimiz fonksiyon, bizden argüman bekliyorsa ne yapacağız? Böyle bir durumda, önceki derslerde öğrendiğimiz **lambda** fonksiyonu devreye giriyor. Aşağıdaki örnekte gördüğümüz gibi:\n",
    "\n",
    "    button1 = ttk.Button(master = window, text = \"2nd button\", command = lambda: print(\"hello!\"))\n",
    "    button1.pack()\n",
    "    \n",
    "<hr>\n",
    "\n",
    "En sonunda, oluşturduğumuz pencereyi çalıştırmak için **window'a** ait `mainloop()` metodunu çağırıyoruz. Mainloop'u, projelerimizdeki **While True:** yapısı gibi düşünebilirsiniz.\n",
    "    \n",
    "    window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "419f7251",
   "metadata": {},
   "source": [
    "### 1 - Widgets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2699bc3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "from tkinter import ttk\n",
    "\n",
    "def button_func():\n",
    "    print(\"a button was pressed.\")\n",
    "    \n",
    "\n",
    "# create a window\n",
    "window = tk.Tk() # or `root`, `app` can be used as variable name\n",
    "window.title(\"widgets\")\n",
    "window.geometry(\"800x600\")\n",
    "\n",
    "# create widgets\n",
    "text = tk.Text(master = window)\n",
    "text.pack() # should use pack to see the widget on the window object\n",
    "\n",
    "# ttk widgets(more modern version of tkinter)\n",
    "label = ttk.Label(master = window, text = \"This is a test\")\n",
    "label.pack()\n",
    "\n",
    "# ttk entry\n",
    "entry = ttk.Entry(master = window)\n",
    "entry.pack()\n",
    "\n",
    "# ttk label1\n",
    "label1 = ttk.Label(master = window, text = \"my label\")\n",
    "label1.pack()\n",
    "\n",
    "# ttk button\n",
    "button = ttk.Button(master = window, text = \"A button\", command = button_func)\n",
    "button.pack()\n",
    "\n",
    "# ttk button1, lambda functions are very important for the buttons\n",
    "button1 = ttk.Button(master = window, text = \"2nd button\", command = lambda: print(\"hello!\"))\n",
    "button1.pack()\n",
    "\n",
    "# run\n",
    "window.mainloop() # updates the GUI and checks for the events\n",
    "print(\"hello\") # 'hello' can be seen only after exiting the mainloop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "178e4e0c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9dc4e149",
   "metadata": {},
   "source": [
    "<a id=\"settings\"></a>\n",
    "# 2-) Settings and Getting Data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee70d43e",
   "metadata": {},
   "source": [
    "Modüllerimizi import edip penceremizin kurulumunu yapalım:\n",
    "\n",
    "    import tkinter as tk\n",
    "    from tkinter import ttk\n",
    "    \n",
    "    window = tk.Tk()\n",
    "    window.title(\"Getting and setting widgets\")\n",
    "    window.geometry(\"640x480\")\n",
    "    \n",
    "<hr>\n",
    "    \n",
    "İhtiyaç duyduğumuz widget'ları hazırlayıp penceremize yerleştiriyoruz:\n",
    "\n",
    "    label = ttk.Label(master=window, text=\"My Label\")\n",
    "    label.pack()\n",
    "\n",
    "    entry = ttk.Entry(master=window)\n",
    "    entry.pack()\n",
    "\n",
    "    button = tk.Button(master=window, text=\"Simple button\", \n",
    "                      command=lambda: print(\"this is a 'tk' button\"))\n",
    "    button.pack()\n",
    "\n",
    "    button1 = ttk.Button(master=window, text=\"Modern button\", \n",
    "                        command=lambda: print(\"this is a 'ttk' button\"))\n",
    "    button1.pack()\n",
    "\n",
    "    entry_button = ttk.Button(master=window, text=\"Entry Button\", \n",
    "                             command=get_entry)\n",
    "    entry_button.pack()\n",
    "\n",
    "    reset_button = tk.Button(master=window, text=\"Reset\", command=reset_func)\n",
    "    reset_button.pack()\n",
    "    \n",
    "    \n",
    "4 adet buton tanımlayıp pencereye ekledik. İlk iki buton, **print** fonksiyonunu kullanarak standart bir mesaj yazıyor. 3'üncü buton `get_entry()` fonksiyonunu, 4'üncü buton ise `reset_func()` fonksiyonunu çağırıyor.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Bu iki fonksiyonu inceleyelim:\n",
    "\n",
    "    def get_entry():\n",
    "        entry_text = entry.get()\n",
    "        label.config(text = entry_text)\n",
    "        label[\"text\"] = entry_text\n",
    "        entry[\"state\"] = \"disabled\"\n",
    "\n",
    "    def reset_func():\n",
    "        label[\"text\"] = \"My Label\"\n",
    "        entry[\"state\"] = \"enabled\"\n",
    "        \n",
    "`get_entry()` fonksiyonu, **entry'de** girilen metni; `entry.get()` metodu ile **string** haline çeviriyor. Ardından **label** için girilen `label.config(text=entry_text)` metodu ile, label'ımızı modifiye ediyoruz. Yani kullanıcı bu butona bastığında, entry'e ne girdiyse onu label üzerinde görebiliyor. Ayrıca, config metodu yerine aynı işlemi `label[\"text\"]` ile de yapabiliyoruz. <br>Son olarak, `entry[\"state\"] = \"disabled\"` girdiğimizde entry kutusunu kullanıma kapalı duruma(**state**) getiriyoruz.\n",
    "\n",
    "`reset_func()` fonksiyonuna baktığımızda; az önce bahsi geçen metotlar tekrar kullanılıyor. Bu sefer **label** ilk haline dönüyor ve **entry** kutusu tekrar kullanılabilir duruma(**state**) dönüyor.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Son olarak pencereyi açık tutmak için döngüyü oluşturuyoruz:\n",
    "\n",
    "    window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91794072",
   "metadata": {},
   "source": [
    "### 2 - Settings and getting data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d3ca755",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "from tkinter import ttk\n",
    "\n",
    "def get_entry():\n",
    "    # get the content of the entry\n",
    "    entry_text = entry.get()\n",
    "    \n",
    "    # update the label\n",
    "    # config is the method to update widgets\n",
    "    label.config(text = entry_text)\n",
    "    # or this can be used either:\n",
    "    label[\"text\"] = entry_text\n",
    "    entry[\"state\"] = \"disabled\"\n",
    "\n",
    "def reset_func():\n",
    "    label[\"text\"] = \"My Label\"\n",
    "    entry[\"state\"] = \"enabled\"\n",
    "    \n",
    "\n",
    "# window\n",
    "window = tk.Tk()\n",
    "window.title(\"Getting and setting widgets\")\n",
    "window.geometry(\"640x480\")\n",
    "\n",
    "# widgets: label, entry, button\n",
    "# label\n",
    "label = ttk.Label(master = window, text = \"My Label\")\n",
    "label.pack()\n",
    "\n",
    "# entry\n",
    "entry = ttk.Entry(master = window)\n",
    "entry.pack()\n",
    "\n",
    "# tk button\n",
    "button = tk.Button(master = window, text = \"Simple button\", command=lambda: print(\"this is a 'tk' button\"))\n",
    "button.pack()\n",
    "\n",
    "# ttk button\n",
    "button1 = ttk.Button(master = window, text = \"Modern button\", command=lambda: print(\"this is a 'ttk' button\"))\n",
    "button1.pack()\n",
    "\n",
    "# a button to print entry\n",
    "entry_button = ttk.Button(master = window, text = \"Entry Button\", command=get_entry)\n",
    "entry_button.pack()\n",
    "\n",
    "# a button to enable entry again\n",
    "reset_button = tk.Button(master = window, text = \"Reset\", command=reset_func)\n",
    "reset_button.pack()\n",
    "\n",
    "# run\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2fc18e5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b8036543",
   "metadata": {},
   "source": [
    "<a id=\"variables\"></a>\n",
    "# 3-) Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "582954f8",
   "metadata": {},
   "source": [
    "İlk olarak kurulumu yapalım:\n",
    "\n",
    "    import tkinter as tk\n",
    "    from tkinter import ttk\n",
    "    \n",
    "    window = tk.Tk()\n",
    "    window.title(\"Variables\")\n",
    "    window.geometry(\"500x300\")\n",
    "    \n",
    "<hr>\n",
    "    \n",
    "Şimdi de widget'ları ekliyoruz:\n",
    "    \n",
    "    string_var = tk.StringVar(value = \"default string\")\n",
    "\n",
    "    label = ttk.Label(window, text = \"Label\", textvariable = string_var)\n",
    "    label.pack()\n",
    "\n",
    "    entry = ttk.Entry(window, textvariable = string_var)\n",
    "    entry.pack()\n",
    "\n",
    "    button = ttk.Button(window, text = \"button\", command = button_func)\n",
    "    button.pack()\n",
    "    \n",
    "Bu uygulamada yeni olarak gördüğümüz `tk.StringVar` var. StringVar'ın **value=** parametresine varsayılan bir string değeri giriyoruz. Peki ne işe yarıyor StringVar?<br> **entry** ve **label** widget'larındaki **textvariable=** parametresine **string_var'ı** atıyoruz. Entry içerisine girdiğimiz string değeri string_var'ın value'sunu değiştiriyor. Aynı string_var label'ın textvariable parametresinde de tanımlı olduğu için, entry'e girilen her değer aynı anda label üzerinde görüntülenebiliyor. Uygulama çalıştırıldığında daha net anlaşılacak.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Şimdi butona tanımlanan fonksiyona bakalım:\n",
    "\n",
    "    def button_func():\n",
    "        print(string_var.get())\n",
    "        string_var.set(\"button pressed\")\n",
    "        \n",
    "Fonksiyon içerisindeki `string_var.get()` metodu **string_var** içerisine girilen stringi döndürüyor. `string_var.set(\"button pressed\")` metodu ise **string_var** değişkenine \"button pressed\" stringini insert ediyor.\n",
    "\n",
    "**Not:** Bu uygulamada widget'ların **master** parametresini girmeden **window** değişkenini girdik. Widgetlar, ilk parametre olarak bağlı olduğu pencereyi(**parent, master**) beklediği için ayrıca master yazmaya gerek kalmıyor.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Son olarak, pencere için döngüyü oluşturuyoruz:\n",
    "\n",
    "    window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3102f241",
   "metadata": {},
   "source": [
    "### 3 - Variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b81cec3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "from tkinter import ttk\n",
    "\n",
    "def button_func():\n",
    "    print(string_var.get())\n",
    "    string_var.set(\"button pressed\")\n",
    "\n",
    "# window\n",
    "window = tk.Tk()\n",
    "window.title(\"Variables\")\n",
    "window.geometry(\"500x300\")\n",
    "\n",
    "# tkinter variable\n",
    "string_var = tk.StringVar(value = \"default string\")\n",
    "\n",
    "# widgets\n",
    "label = ttk.Label(window, text = \"Label\", textvariable = string_var)\n",
    "label.pack()\n",
    "\n",
    "entry = ttk.Entry(window, textvariable = string_var)\n",
    "entry.pack()\n",
    "\n",
    "button = ttk.Button(window, text = \"button\", command = button_func)\n",
    "button.pack()\n",
    "\n",
    "# run\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "692a2bf3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "d83388c8",
   "metadata": {},
   "source": [
    "<a id=\"buttons\"></a>\n",
    "# 4-) Buttons"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2d70e71",
   "metadata": {},
   "source": [
    "Bu örnekte, standart push button dışında **checkbutton** ve **radiobutton** mevcut.\n",
    "\n",
    "Checkbutton, True - False anlayışı ile çalıştığı için; `tk.BooleanVar()` kullanıyoruz. **value=** parametresine varsayılan değer olarak **True** atıyoruz. Pencereyi çalıştırdığımızda varsayılan değeri **True** olduğu için, checkbox içi dolu şekilde açılıyor. Üzerine tıkladığımızda sahip olduğu **boolean** değeri True ve False arasında güncelliyor.\n",
    "\n",
    "    check_var = tk.BooleanVar(value = True)\n",
    "    check = ttk.Checkbutton(\n",
    "        window, \n",
    "        text = \"checkbox 1\", \n",
    "        command = lambda: print(check_var.get()),\n",
    "        variable = check_var)\n",
    "    check.pack()\n",
    "    \n",
    "<hr>\n",
    "    \n",
    "Radiobutton; kendisinden en az iki adet mevcut olduğunda makul bir kullanıma sahip oluyor. Bağlı oldukları ortak bir `tk.StringVar()` var. Bu değer, **radio_var** isimli bir değişkene atanıyor. Radiobutton'ların ikisinin de command parametresine aynı fonksiyonu atıyoruz: `print(radio_var.get())`. Bu metot, seçili olan radiobutonun **value=** parametresindeki değeri bize döndürüyor.\n",
    "\n",
    "    radio_var = tk.StringVar()\n",
    "    radio1 = ttk.Radiobutton(\n",
    "        window, \n",
    "        text = \"Radiobutton 1\", \n",
    "        value = \"radio 1\", \n",
    "        variable = radio_var,\n",
    "        command = lambda: print(radio_var.get()))\n",
    "    radio1.pack()\n",
    "\n",
    "    radio2 = ttk.Radiobutton(\n",
    "        window, \n",
    "        text = \"Radiobutton 2\", \n",
    "        value = 2,\n",
    "        variable = radio_var,\n",
    "        command = lambda: print(radio_var.get()))\n",
    "    radio2.pack()\n",
    "    \n",
    "<hr>\n",
    "\n",
    "En son yine döngüyü başlatıyoruz:\n",
    "\n",
    "    window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04864d01",
   "metadata": {},
   "source": [
    "### 4 - Buttons:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3813baaa",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "from tkinter import ttk\n",
    "\n",
    "# window\n",
    "window = tk.Tk()\n",
    "window.title(\"buttons\")\n",
    "window.geometry(\"640x480\")\n",
    "\n",
    "# button\n",
    "button_string = tk.StringVar(value = \"button with a string var\")\n",
    "button = ttk.Button(window, text = \"button\", command = lambda: print(\"Button pressed!\"), \n",
    "                    textvariable = button_string)\n",
    "button.pack()\n",
    "\n",
    "# checkbutton\n",
    "check_var = tk.BooleanVar(value = True) # as the result is needed to be boolean, BooleanVar method is typed\n",
    "check = ttk.Checkbutton(\n",
    "    window, \n",
    "    text = \"checkbox 1\", \n",
    "    command = lambda: print(check_var.get()),\n",
    "    variable = check_var) # now it returns boolean expressions\n",
    "check.pack()\n",
    "\n",
    "# radio buttons\n",
    "radio_var = tk.StringVar()\n",
    "radio1 = ttk.Radiobutton(\n",
    "    window, \n",
    "    text = \"Radiobutton 1\", \n",
    "    value = \"radio 1\", \n",
    "    variable = radio_var,\n",
    "    command = lambda: print(radio_var.get()))\n",
    "radio1.pack()\n",
    "\n",
    "radio2 = ttk.Radiobutton(\n",
    "    window, \n",
    "    text = \"Radiobutton 2\", \n",
    "    value = 2,\n",
    "    variable = radio_var,\n",
    "    command = lambda: print(radio_var.get()))\n",
    "radio2.pack()\n",
    "\n",
    "# run\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60e31a9d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "17acb059",
   "metadata": {},
   "source": [
    "<a id=\"buttons-arguments\"></a>\n",
    "# 5-) Buttons with Arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a01fe70",
   "metadata": {},
   "source": [
    "Bu örnekte; butonların, farklı fonksiyonlar kullanarak benzer bir görevi yerine getirmesini sağlayacağız. \n",
    "\n",
    "    import tkinter as tk\n",
    "    from tkinter import ttk\n",
    "    \n",
    "    window = tk.Tk()\n",
    "    window.title(\"buttons, funcs and args\")\n",
    "    window.geometry(\"640x480\")\n",
    "    \n",
    "<hr>\n",
    "\n",
    "Modülleri import edip pencere kurulumunu tamamladıktan sonra yerleştirdiğimiz widget'ları inceleyelim:\n",
    "\n",
    "    entry_string = tk.StringVar(value = 'test')\n",
    "    entry = ttk.Entry(window, textvariable = entry_string)\n",
    "    entry.pack()\n",
    "\n",
    "İlk widget bir **entry**. **textvariable=** parametresine atanmış olan **entry_string** değişkeninin içeriğini belirliyor. Şu an için entry_string değişkeni kullanımda değil.\n",
    "\n",
    "<hr>\n",
    "\n",
    "    button = tk.Button(window, text = \"button with func\", \n",
    "                       command = lambda: button_func(entry_string))\n",
    "    button.pack()\n",
    "    \n",
    "Ardından, bir buton tanımlıyoruz. Butonun üzerinde **\"button with func\"** yazıyor ve `button_func(entry_string)` fonksiyonunu command olarak atıyoruz. Fonksiyona, argüman olarak **entry_string** değişkenini yazdık.\n",
    "\n",
    "<hr>\n",
    "\n",
    "    button1 = ttk.Button(window, text = \"button with outer func\", \n",
    "                         command = outer_func(entry_string))\n",
    "    button1.pack()\n",
    "    \n",
    "Daha sonra, bir buton daha tanımlıyoruz: **buton1**. Bu butonun üzerinde ise **\"button with outer func\"** yazıyor ve `outer_func(entry_string)` isimli **nested**, iç içe tanımlayacağımız fonksiyonu command olarak atıyoruz. Argüman aynı: **entry_string**\n",
    "\n",
    "<hr>\n",
    "\n",
    "    button2 = ttk.Button(window, text = \"button with lambda\", \n",
    "                         command = lambda: print(\"button with lambda pressed\\n\", \n",
    "                                                 entry_string.get(), sep = \"\"))\n",
    "    button2.pack()\n",
    "\n",
    "Son olarak, bir buton daha tanımlıyoruz: **buton2**. Üzerinde **\"button with lambda\"** yazıyor ve içerisinde `print()` fonksiyonunu çağırıyoruz. Print içerisinde ise **\"button with lambda pressed\\n\", entry_string.get(), sep = \"\")** yazıyoruz. <br> print'i kullanmak için parantez ekleyip içine yazdırmak istediğimiz değeri giriyoruz. Böyle bir durumda butona basmadan fonksiyonun otomatik çağrılmaması için **lambda** ekliyoruz. <br> Peki **button1**'in command parametresinde `outer_func(entry_string)` yazdığımızda **lambda** olmamasına rağmen neden sadece butona bastığımızda çalışıyor. Fonksiyonu **nested** şekilde oluşturduğumuz için bu fonksiyonda parametre girsek bile sadece butona bastığımızda çalışıyor:\n",
    "\n",
    "    def button_func(entry_string):\n",
    "        print(\"button with func pressed\")\n",
    "        print(entry_string.get())\n",
    "\n",
    "    def outer_func(parameter):\n",
    "        def inner_func():\n",
    "            print(\"button with outer func pressed\")\n",
    "            print(parameter.get())\n",
    "        return inner_func\n",
    "\n",
    "**Not:** İlk butonu `ttk` değil, `tk` üzerinden tanımladığımız için diğerlerinden farklı görünüyor."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87e535bd",
   "metadata": {},
   "source": [
    "### 5 - Buttons with Arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8977401",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "from tkinter import ttk\n",
    "\n",
    "def button_func(entry_string):\n",
    "    print(\"button with func pressed\")\n",
    "    print(entry_string.get())\n",
    "\n",
    "def outer_func(parameter):\n",
    "    def inner_func():\n",
    "        print(\"button with outer func pressed\")\n",
    "        print(parameter.get())\n",
    "    return inner_func\n",
    "\n",
    "# setup\n",
    "window = tk.Tk()\n",
    "window.title(\"buttons, funcs and args\")\n",
    "window.geometry(\"640x480\")\n",
    "\n",
    "# widgets\n",
    "entry_string = tk.StringVar(value = 'test')\n",
    "entry = ttk.Entry(window, textvariable = entry_string)\n",
    "entry.pack()\n",
    "\n",
    "button = tk.Button(window, text = \"button with func\", \n",
    "                   command = lambda: button_func(entry_string))\n",
    "button.pack()\n",
    "\n",
    "button1 = ttk.Button(window, text = \"button with outer func\", \n",
    "                     command = outer_func(entry_string))\n",
    "button1.pack()\n",
    "\n",
    "button2 = ttk.Button(window, text = \"button with lambda\", \n",
    "                     command = lambda: print(\"button with lambda pressed\\n\", \n",
    "                                             entry_string.get(), sep = \"\"))\n",
    "button2.pack()\n",
    "\n",
    "# run\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4233202e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9a0d3dea",
   "metadata": {},
   "source": [
    "<a id=\"bmi\"></a>\n",
    "# BMI Calculator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eba587ef",
   "metadata": {},
   "source": [
    "İlk derslerde öğrendiğimiz **vücut kitle indeksi** hesaplama fonksiyonunu **tkinter'dan** yararlanarak uygulama haline getirelim. \n",
    "\n",
    "<hr>\n",
    "\n",
    "İlk olarak modülleri import edip pencere kurulumunu yapıyoruz:\n",
    "\n",
    "    import tkinter as tk\n",
    "    from tkinter import ttk\n",
    "    \n",
    "    window = tk.Tk()\n",
    "    window.title(\"BMI calculator\")\n",
    "    window.geometry(\"440x240\")\n",
    "    window['padx'] = 50\n",
    "    window['pady'] = 50\n",
    "    \n",
    "<hr>\n",
    "    \n",
    "Ayrıca ekleyeceğimiz widget'lar birbirine çok yakın olmasın diye 15'e 15 **pad** ekliyoruz. Her birine 15 yazmak yerine önceden tanımlayacağımız **sabit(constant)** bir değişkene 15 değerini atıyoruz:\n",
    "\n",
    "    PADX = 15\n",
    "    PADY = 15\n",
    "\n",
    "<hr>\n",
    "\n",
    "Arayüzümüzde ihtiyaç duyacağımız widget'ları gözden geçirelim:\n",
    "\n",
    "* Ağırlığı gireceğimiz bir **entry**\n",
    "* Ağırlık entry'sinin ağırlık olduğunu ifade eden bir **label**\n",
    "* Ağırlığın birimini belirtecek bir **label**\n",
    "* Boyu gireceğimiz bir **entry**\n",
    "* Boy entry'sinin boy olduğunu ifade eden bir **label**\n",
    "* Boyun birimini belirtecek bir **label**\n",
    "* Hesaplama fonksiyonunu çağıracak bir **button**\n",
    "* Sonucu göreceğimiz bir **label**\n",
    "\n",
    "<hr>\n",
    "\n",
    "Widget'ları `grid()` metodu ile yerleştiriyoruz. <br>\n",
    "Ağırlık(weight) widget'larını hazırlıyoruz:\n",
    "\n",
    "    label_weight = tk.Label(window, text = \"Weight:  \", padx = PADX, pady = PADY)\n",
    "    label_weight.grid(row = 0, column = 0)\n",
    "    label_kg = tk.Label(window, text = \"kg\", padx = PADX, pady = PADY)\n",
    "    label_kg.grid(row = 0, column = 2)\n",
    "    weight = tk.IntVar(value = 0)\n",
    "    entry_weight = ttk.Entry(window, textvariable = weight)\n",
    "    entry_weight.grid(row = 0, column = 1)\n",
    "    \n",
    "weight değişkenini **integer** değer olarak beklediğimiz için `tk.IntVar()`'a atıyoruz. Aynı zamanda weight değişkenini, ilgili entry'nin(entry_weight) **textvariable=** parametresine atıyoruz. \n",
    "    \n",
    "<hr>\n",
    "\n",
    "Boy(height) widget'larını hazırlıyoruz:\n",
    "\n",
    "    label_height = tk.Label(window, text = \"Height:  \", padx = PADX, pady = PADY)\n",
    "    label_height.grid(row = 1, column = 0)\n",
    "    label_meters = tk.Label(window, text = \"meters\", padx = PADX, pady = PADY)\n",
    "    label_meters.grid(row = 1, column = 2)\n",
    "    height = tk.IntVar(value = 0)\n",
    "    entry_height = ttk.Entry(window, textvariable = height)\n",
    "    entry_height.grid(row = 1, column = 1)\n",
    "    \n",
    "weight için yaptığımız işlemlerin aynısını height için de yapıyoruz.\n",
    "    \n",
    "<hr>\n",
    "\n",
    "Hesaplama işlemi için butonu tanımlıyoruz:\n",
    "\n",
    "    button = ttk.Button(window, text=\"Calculate!\", command = lambda: bmi_calc(weight, height))\n",
    "    button.grid(row = 3, column = 0)\n",
    "    \n",
    "command'e atadığımız fonksiyon; `bmi_calc(weight, height)`. Şimdi bu fonksiyonu tanımlayalım:\n",
    "\n",
    "    def bmi_calc(weight, height):\n",
    "        weight = weight.get()\n",
    "        height = height.get()\n",
    "        sq_height = (height/100)**2\n",
    "        try:\n",
    "            result = weight/sq_height\n",
    "            result_label.config(text=(round(result, 2), \"kg/m2\"))\n",
    "        except ZeroDivisionError:\n",
    "            result_label.config(text=\"Height cannot be zero!\")\n",
    "        return\n",
    "        \n",
    "Fonksiyonda iki parametre tanımladık: weight => ağırlık, height => boy <br> Bu değerleri ilgili **entry'lerden** aldığımız için `get()` metodunu kullanıp **weight** ve **height** değişkenlerini yeniden tanımlıyoruz. Kullanıcının girdiği boyu metreye çevirmek için `sq_height = (height/100)**2` formülünü kullanıp yeni bir değişkene atıyoruz. Ağırlığı boya bölüp **result** değişkenine atıyoruz ve sonucu yazacak olan **label'ın** `config()` metodu içine bu sonucu yazıyoruz. Küsüratı kısmak için `round()` fonksiyonundan yararlanıyoruz. <br> Bir de, kullanıcının yanlışlıkla boyu 0 bıraktığını düşünerek bir **try - except** yapısı kuruyoruz.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Son olarak penceremizin döngüsünü oluşturuyoruz:\n",
    "\n",
    "    window.mainloop()\n",
    "    \n",
    "<hr>\n",
    "\n",
    "**Bu uygulama daha da geliştirilebilir elbette:**\n",
    "\n",
    "* Aralarında cinsiyet seçimi yapabileceğimiz bir widget.\n",
    "* Metre ölçü birimi ile Amerikan ölçü birimi arasında geçiş yapan iki adet radiobutton ve fonksiyonun buna göre güncellenmesi."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca175728",
   "metadata": {},
   "source": [
    "### BMI Calculator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15b65e33",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "from tkinter import ttk\n",
    "\n",
    "PADX = 15\n",
    "PADY = 15\n",
    "\n",
    "def bmi_calc(weight, height):\n",
    "    weight = weight.get()\n",
    "    height = height.get()\n",
    "    sq_height = (height/100)**2\n",
    "    try:\n",
    "        result = weight/sq_height\n",
    "        result_label.config(text=(round(result, 2), \"kg/m2\"))\n",
    "    except ZeroDivisionError:\n",
    "        result_label.config(text=\"Height cannot be zero!\")\n",
    "    return\n",
    "\n",
    "\n",
    "# setup\n",
    "window = tk.Tk()\n",
    "window.title(\"BMI calculator\")\n",
    "window.geometry(\"440x240\")\n",
    "window['padx'] = 50\n",
    "window['pady'] = 50\n",
    "\n",
    "# widgets\n",
    "label_weight = tk.Label(window, text = \"Weight:  \", padx = PADX, pady = PADY)\n",
    "label_weight.grid(row = 0, column = 0)\n",
    "label_kg = tk.Label(window, text = \"kg\", padx = PADX, pady = PADY)\n",
    "label_kg.grid(row = 0, column = 2)\n",
    "weight = tk.IntVar(value = 0)\n",
    "entry_weight = ttk.Entry(window, textvariable = weight)\n",
    "entry_weight.grid(row = 0, column = 1)\n",
    "\n",
    "label_height = tk.Label(window, text = \"Height:  \", padx = PADX, pady = PADY)\n",
    "label_height.grid(row = 1, column = 0)\n",
    "label_meters = tk.Label(window, text = \"centimeters\", padx = PADX, pady = PADY)\n",
    "label_meters.grid(row = 1, column = 2)\n",
    "height = tk.IntVar(value = 0)\n",
    "entry_height = ttk.Entry(window, textvariable = height)\n",
    "entry_height.grid(row = 1, column = 1)\n",
    "\n",
    "button = ttk.Button(window, text=\"Calculate!\", command = lambda: bmi_calc(weight, height))\n",
    "button.grid(row = 3, column = 0)\n",
    "\n",
    "result_label = tk.Label(window, text=\"\")\n",
    "result_label.grid(row = 3, column= 1)\n",
    "\n",
    "# run\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4bb5ed3b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "2322f973",
   "metadata": {},
   "source": [
    "<a id=\"events\"></a>\n",
    "# 6-) Events"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1df6745c",
   "metadata": {},
   "source": [
    "Bu örnekte **event** ve **bind**'dan yararlanacağız. Arayüz içerisindeki bir **widget'a** `bind()` metodunu uyguladığımızda, o widget'la alakalı tanımladığımız bir olay(**event**) ne ise, onu gerçekleştirdiğimiz takdirde bağlı olduğu fonksiyonu çağıracak. Örnek içerisinde daha net anlaşılıyor.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Modülleri import edip, pencereyi hazırlıyoruz:\n",
    "\n",
    "    import tkinter as tk\n",
    "    from tkinter import ttk\n",
    "\n",
    "    window = tk.Tk()\n",
    "    window.geometry(\"600x500\")\n",
    "    window.title(\"Event binding\")\n",
    "    \n",
    "<hr>\n",
    "    \n",
    "`bind()` metodunu uygulayacağımız widget'ları tanımlayıp pencereye ekliyoruz:\n",
    "\n",
    "    text = tk.Text(window)\n",
    "    text.pack()\n",
    "    entry = tk.Entry(window, width=30)\n",
    "    entry.pack()\n",
    "    button = tk.Button(window, text=\"A Button\", command= lambda: print(\"The button is pressed.\"))\n",
    "    button.pack()\n",
    "    \n",
    "Bir adet text, bir adet entry ve bir adet buton tanımladık. Şimdi tanımladığımız entry, text ve ana penceremiz için `bind()` metodunu uygulayacağız:\n",
    "\n",
    "    window.bind(\"<KeyPress>\", lambda event: print(f\"{event.char} is pressed.\"))\n",
    "    text.bind(\"<Motion>\", get_pos)\n",
    "    entry.bind(\"<FocusIn>\", lambda event: print(\"Entry is selected\"))\n",
    "    entry.bind(\"<FocusOut>\", lambda event: print(\"Entry is unselected\"))\n",
    "    text.bind(\"<Shift-MouseWheel>\", lambda event: print(\"mousewheel activated\"))\n",
    "    \n",
    "<hr>\n",
    "\n",
    "İlk binding'i ana pencere için uyguladık.(`window.bind`) bind metodu içerisinde ilk parametre olarak olayı yani **event'i** tanımlıyoruz. Tkinter modülü içerisindeki syntaxi bu şekilde olduğu için eventi string olarak ve < > işaretleri içerisinde yazıyoruz. Eventin ismi **KeyPress**; yani klavyemizde ne zaman bir tuşa basarsak olay gerçekleşmiş oluyor. Yalnız burada farklı olarak **lambda'ya** event adında bir argüman ekledik. Bunun sebebi, biz eventi tetiklediğimizde; bu event, argüman olarak bağlı olduğu fonksiyonu çağırıyor. Eğer lambda'ya argüman tanımlamazsak hata alacağımız için, event isminde bir argüman ekledik. <br> Bu event için çağırdığımız fonksiyon ise `print(f\"{event.char} is pressed.\")`. Bu şu anlama geliyor: fstring mantığıyla `event.char`'ı yazdırsın. Event neydi; bastığımız tuş, yani bize klavyede bastığımız tuşu yazdıracak.\n",
    "\n",
    "    window.bind(\"<KeyPress>\", lambda event: print(f\"{event.char} is pressed.\"))\n",
    "    text.bind(\"<Motion>\", get_pos)\n",
    "    \n",
    "<hr>\n",
    "\n",
    "İkinci ve üçüncü binding'i text için uyguladık.(`text.bind`) İlk tanımladığımız event `\"<Motion>\"` yani hareket. Adından da anlaşılacağı üzere faremizi hareket ettirdiğimiz takdirde tetiklenen bir event. <br> **Not:** Fareyi **pencerede** değil sadece **text kutusu** içerisinde hareket ettirdiğimiz takdirde çalışacak çünkü binding'i text üzerine yaptık. <br> Tetiklenen eventin çağıracağı fonksiyon da: `get_pos`. Neden lambda ve event argümanı eklemedik? Çünkü get_pos fonksiyonunu dışarıda tanımladık ve event argümanını parametre olarak fonksiyon kendisi alıyor. <br> Fonksiyonun içerisinde de print fonksiyonunu kullanarak, kartezyen düzlem içerisinde farenin koordinatını yazdırıyoruz.\n",
    "\n",
    "Üçüncü bindingde `\"<Shift-MouseWheel>\"` kullanıyoruz. Kullanıcı shifte basılı tutup fare çarkını aşağı ya da yukarı hareket ettirdiğinde tetiklenen bir event. Tetiklendiğinde takdirde de print fonksiyonu vasıtasıyla kullanıcı geri bildirimde bulunuyor.\n",
    "\n",
    "    def get_pos(event):\n",
    "        print(f\"x: {event.x}, y: {event.y}\")\n",
    "\n",
    "    text.bind(\"<Motion>\", get_pos)\n",
    "    text.bind(\"<Shift-MouseWheel>\", lambda event: print(\"mousewheel activated\"))\n",
    "    \n",
    "<hr>\n",
    "\n",
    "Ardından entry için de iki adet bind metodu uyguluyoruz. Bu ikisi birbirinin zıttı; ilki, entry kutusu seçildiğinde tetikleniyor, ikincisi ise entry kutusu seçiliyken kullanıcı başka bir şeyi seçerse tetikleniyor. Her birine uygun bir mesajı yazdırmaları için print fonksiyonu uyguluyoruz.\n",
    "\n",
    "    entry.bind(\"<FocusIn>\", lambda event: print(\"Entry is selected\"))\n",
    "    entry.bind(\"<FocusOut>\", lambda event: print(\"Entry is unselected\"))\n",
    "    \n",
    "<hr>\n",
    "\n",
    "Son olarak döngüyü çalıştırıyoruz.\n",
    "\n",
    "    window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1923b259",
   "metadata": {},
   "source": [
    "### 6 - Events:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c92bbef8",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "from tkinter import ttk\n",
    "\n",
    "def get_pos(event):\n",
    "    print(f\"x: {event.x}, y: {event.y}\")\n",
    "\n",
    "# window setup\n",
    "window = tk.Tk()\n",
    "window.geometry(\"600x500\")\n",
    "window.title(\"Event binding\")\n",
    "\n",
    "# widgets\n",
    "text = tk.Text(window)\n",
    "text.pack()\n",
    "entry = tk.Entry(window, width=30)\n",
    "entry.pack()\n",
    "button = tk.Button(window, text=\"A Button\", command= lambda: print(\"The button is pressed.\"))\n",
    "button.pack()\n",
    "\n",
    "# event bindings\n",
    "window.bind(\"<KeyPress>\", lambda event: print(f\"{event.char} is pressed.\"))\n",
    "text.bind(\"<Motion>\", get_pos)\n",
    "text.bind(\"<Shift-MouseWheel>\", lambda event: print(\"mousewheel activated\"))\n",
    "entry.bind(\"<FocusIn>\", lambda event: print(\"Entry is selected\"))\n",
    "entry.bind(\"<FocusOut>\", lambda event: print(\"Entry is unselected\"))\n",
    "\n",
    "# run\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8e9913e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1bf30461",
   "metadata": {},
   "source": [
    "<a id=\"combobox\"></a>\n",
    "# 7-) Combobox and Spinbox"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c0f70b8",
   "metadata": {},
   "source": [
    "Bu örnekte birçok masaüstü uygulamasında kullanılan **Combobox** ve **Spinbox**'ı inceleyeceğiz. Combobox: Kendisine verilen bir **liste** veya **tuple**'dan seçim yapmamızı sağlıyor. Spinbox ise: Aşağı ve yukarı ok tuşlarını kullanarak, kullanıcıya sunulan aralık veya liste içerisinden seçim hakkı sunuyor.\n",
    "\n",
    "<hr>\n",
    "\n",
    "İlk olarak yine pencere kurulumunu yapıyoruz:\n",
    "\n",
    "    import tkinter as tk\n",
    "    from tkinter import ttk\n",
    "\n",
    "    window = tk.Tk()\n",
    "    window.geometry(\"600x500\")\n",
    "    window.title(\"Combobox and Spinbox\")\n",
    "\n",
    "<hr>\n",
    "\n",
    "Combobox'ı pencere içerisinde tanımlayıp, pencereye ekleyelim:\n",
    "\n",
    "    items = (\"Tomato\", \"Pepper\", \"Eggplant\")\n",
    "    food_string = tk.StringVar(value=items[0])\n",
    "    combobox = ttk.Combobox(window, textvariable=food_string)\n",
    "    combobox['values'] = items\n",
    "    combobox.pack()\n",
    "    \n",
    "İlk olarak combobox içerisinden seçim yapacağımız **items** listesini tanımladık. Daha sonra, bu listeyi direkt combobox'a argüman olarak **atamıyoruz**. Onun yerine ara değişken kullanıyoruz. Hatırlarsanız, bir widget içerisindeki **textin** değişime açık olması için **textvariable=** parametresini kullanıyorduk ve bunu `tk.IntVar` veya `tk.StringVar` metotları ile yapıyorduk. Listemiz **string** barındırdığı için bu örnekte `tk.StringVar` kullancağız. İçerisine de varsayılan değişken olarak listedeki ilk item'ı ekliyoruz. Combobox'a alacağı değer olarak da listemizi ekliyoruz: `combobox['values'] = items`. Son olarak `pack()` metodu ile widgetı pencereye ekliyoruz.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Combobox'ta seçilen değerin bir **label'da** görünmesi için combobox'a ait bir **binding** kullanyoruz:\n",
    "\n",
    "    combobox.bind(\"<<ComboboxSelected>>\", \n",
    "    lambda event: combo_label.config(text=f\"Selected item: {food_string.get()}\"))\n",
    "    combo_label = ttk.Label(window, text=\"\")\n",
    "    combo_label.pack()\n",
    "    \n",
    "Normal bind'a göre farklı olarak iki adet '<' kullanıyoruz. bind içerisinde tanımladığımız lambda fonksiyonuna label'in `config()` metodunu uyguluyoruz. \n",
    "\n",
    "<hr>\n",
    "\n",
    "Şimdi Spinbox'ı tanımlayıp pencereye ekleyelim:\n",
    "\n",
    "    spin_label = ttk.Label(window, text=\"Spinbox of Numbers\")\n",
    "    spin_label.pack(pady=10)\n",
    "    spinbox_int = tk.IntVar(value=12)\n",
    "    spinbox = ttk.Spinbox(window, from_=1, to=20, increment=2, \n",
    "                          command= lambda: print(spinbox_int.get()), textvariable=spinbox_int)\n",
    "    spinbox.bind(\"<<Increment>>\", lambda event: print(\"up\"))\n",
    "    spinbox.bind(\"<<Decrement>>\", lambda event: print(\"down\"))\n",
    "    spinbox.pack()\n",
    "    \n",
    "Spinbox'tan önce bir label tanımlayıp, spinbox'a bir isim oluşturuyoruz. Spinbox içerisinde **from_=** ve **to=** parametrelerini giriyoruz. Bu sayede kullanıcının seçeceği aralığı belirliyoruz. **increment=** parametresi ise artış miktarını belirliyor. 2 yazdığımız için değerler ikişer ikişer artacak ya da azalacak. Bu değeri yine **textvariable=** parametresi ile getireceğiz. Bu sefer, değerimiz **integer** olduğu için, değişkenimizi `tk.StringVar` değil `tk.IntVar` ile oluşturuyoruz. <br> Spinbox, **Increment** ve **Decrement** bind'larına sahip. Combobox'ta olduğu gibi Spinbox'ta da iki adet '<' kullanıyoruz. Bu bindların amacı; spinbox, yukarı(Increment) veya aşağı(Decrement) yönlendirildiğinde tetiklenmesi için. Örnekte, sadece print fonksiyonu ile ilgili yönü yazdırdık.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Bir adet de **string** gösteren spinbox ekliyoruz.\n",
    "\n",
    "    spin_label1 = ttk.Label(window, text=\"Spinbox of Letters\")\n",
    "    spin_label1.pack(pady=10)\n",
    "    spinbox1_letter = tk.StringVar(value=\"A\")\n",
    "    letters = [\"A\", \"B\", \"C\", \"D\", \"E\"]\n",
    "    spinbox1 = ttk.Spinbox(window, values=letters, textvariable=spinbox1_letter)\n",
    "    spinbox1.bind(\"<<Decrement>>\", lambda event: print(spinbox1_letter.get()))\n",
    "    spinbox1.pack()\n",
    "    \n",
    "İlk Spinbox'tan farklı olarak **from_=** ve **to=** parametresi yerine **Combobox'ta** yaptığımız gibi bir listeden faydalanıyoruz.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Ve son olarak döngüyü oluşturuyoruz:\n",
    "\n",
    "    window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42857025",
   "metadata": {},
   "source": [
    "### 7 - Combobox and Spinbox:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b975dbff",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "from tkinter import ttk\n",
    "\n",
    "# window setup\n",
    "window = tk.Tk()\n",
    "window.geometry(\"600x500\")\n",
    "window.title(\"Combobox and Spinbox\")\n",
    "\n",
    "# Combobox\n",
    "items = (\"Tomato\", \"Pepper\", \"Eggplant\")\n",
    "food_string = tk.StringVar(value=items[0])\n",
    "combobox = ttk.Combobox(window, textvariable=food_string)\n",
    "combobox['values'] = items\n",
    "combobox.pack()\n",
    "\n",
    "combobox.bind(\"<<ComboboxSelected>>\", lambda event: combo_label.config(text=f\"Selected item: {food_string.get()}\"))\n",
    "combo_label = ttk.Label(window, text=\"\")\n",
    "combo_label.pack()\n",
    "\n",
    "# Spinbox\n",
    "spin_label = ttk.Label(window, text=\"Spinbox of Numbers\")\n",
    "spin_label.pack(pady=10)\n",
    "spinbox_int = tk.IntVar(value=12)\n",
    "spinbox = ttk.Spinbox(window, from_=1, to=20, increment=2, \n",
    "                      command= lambda: print(spinbox_int.get()), textvariable=spinbox_int)\n",
    "spinbox.bind(\"<<Increment>>\", lambda event: print(\"up\"))\n",
    "spinbox.bind(\"<<Decrement>>\", lambda event: print(\"down\"))\n",
    "spinbox.pack()\n",
    "\n",
    "# Spinbox1\n",
    "spin_label1 = ttk.Label(window, text=\"Spinbox of Letters\")\n",
    "spin_label1.pack(pady=10)\n",
    "spinbox1_letter = tk.StringVar(value=\"A\")\n",
    "letters = [\"A\", \"B\", \"C\", \"D\", \"E\"]\n",
    "spinbox1 = ttk.Spinbox(window, values=letters, textvariable=spinbox1_letter)\n",
    "spinbox1.bind(\"<<Decrement>>\", lambda event: print(spinbox1_letter.get()))\n",
    "spinbox1.pack()\n",
    "\n",
    "# run\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c81267d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4f3dc215",
   "metadata": {},
   "source": [
    "<a id=\"canvas\"></a>\n",
    "# 8-) Canvas"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdc48562",
   "metadata": {},
   "source": [
    "Her zaman olduğu gibi pencere kurulumu yapıyoruz ve bir adet tuval(Canvas) oluşturuyoruz:\n",
    "\n",
    "    import tkinter as tk\n",
    "    from tkinter import ttk\n",
    "\n",
    "    window = tk.Tk()\n",
    "    window.title(\"Canvas\")\n",
    "    window.geometry(\"600x500\")\n",
    "\n",
    "    canvas = tk.Canvas(window, bg=\"white\")\n",
    "    canvas.pack()\n",
    "\n",
    "<hr>\n",
    "\n",
    "Oluşturduğumuz canvas'ın `create` metodu ile birçok şekli yaratabiliyoruz:\n",
    "\n",
    "    canvas.create_rectangle((50, 20, 100, 150), fill=\"red\", \n",
    "                            width=10, dash=(2,2,1,1), outline=\"darkblue\")\n",
    "    canvas.create_oval((200, 10, 300, 100), fill=\"cyan1\")\n",
    "    canvas.create_arc((200, 10, 300, 100), fill=\"blue1\", start=45, extent=120)\n",
    "    canvas.create_arc((200, 10, 300, 100), fill=\"blue1\", width=5, start=270, \n",
    "                      extent=60, style=tk.ARC, outline=\"red2\")\n",
    "\n",
    "    canvas.create_line((200, 200, 150, 100), fill=\"blue\", width=3)\n",
    "    canvas.create_text((100, 200), text=\"Hello World!\", fill=\"darkgreen\")\n",
    "    canvas.create_window((75, 225), window=ttk.Label(window, text=\"Label in a canvas\"))\n",
    "    \n",
    "`create`'ten sonra yazdığımız ifade ne ise, tuvale o şekil çiziliyor. Şekillerin integer olarak aldıkları değerler, onların x1, y1, x2, y2 değerleri. Çizgi kalınlığı, kesikli çizgi, şeklin iç rengi, yarı çember genişliği gibi birçok özelliği parametre olarak girebiliyoruz. Örnek içerisinde değerleri değiştirerek, tuvale nasıl etki ettiğini görebiliyoruz.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Tabi ki son olarak döngümüzü oluşturuyoruz:\n",
    "\n",
    "    window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34f490fc",
   "metadata": {},
   "source": [
    "### 8 - Canvas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b893415",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "from tkinter import ttk\n",
    "\n",
    "# window setup\n",
    "window = tk.Tk()\n",
    "window.title(\"Canvas\")\n",
    "window.geometry(\"600x500\")\n",
    "\n",
    "# Canvas\n",
    "canvas = tk.Canvas(window, bg=\"white\")\n",
    "canvas.pack()\n",
    "\n",
    "# shapes\n",
    "canvas.create_rectangle((50, 20, 100, 150), fill=\"red\", width=10, dash=(2,2,1,1), outline=\"darkblue\")\n",
    "canvas.create_oval((200, 10, 300, 100), fill=\"cyan1\")\n",
    "canvas.create_arc((200, 10, 300, 100), fill=\"blue1\", start=45, extent=120)\n",
    "canvas.create_arc((200, 10, 300, 100), fill=\"blue1\", width=5, start=270, \n",
    "                  extent=60, style=tk.ARC, outline=\"red2\")\n",
    "\n",
    "canvas.create_line((200, 200, 150, 100), fill=\"blue\", width=3)\n",
    "canvas.create_text((100, 200), text=\"Hello World!\", fill=\"darkgreen\")\n",
    "canvas.create_window((75, 225), window=ttk.Label(window, text=\"Label in a canvas\"))\n",
    "# run\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb34495b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f6b8bb3f",
   "metadata": {},
   "source": [
    "<a id=\"paint\"></a>\n",
    "# Simple Paint Application"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72aafd9a",
   "metadata": {},
   "source": [
    "Şimdiki örnekte, şu ana kadar öğrendiklerimiz ile basit bir paint uygulaması yapalım. <br> Uygulamadan beklediğimiz özellikler:\n",
    "\n",
    "* Boş bir tuval üzerinde imlecimizin bulunduğu pozisyona göre boyama yapmak.\n",
    "* Fırça büyüklüğünü, '+' ve '-' tuşlarını kullanarak değiştirmek.\n",
    "* Tuvali, seçtiğimiz renge göre boyayabilmek.\n",
    "* Boyamayı yaptıktan sonra tuvali temizleyip baştan başlamak için bir tuş.\n",
    "\n",
    "<hr>\n",
    "\n",
    "İlk olarak modülleri import edip pencere kurulumunu yapalım:\n",
    "\n",
    "    import tkinter as tk\n",
    "    from tkinter import ttk\n",
    "    from tkinter import colorchooser\n",
    "\n",
    "    window = tk.Tk()\n",
    "    window.title(\"Simple Paint\")\n",
    "    window.geometry(\"800x600\")\n",
    "    \n",
    "Bu örnekte ekstra olarak **colorchooser** import ettik. Adından da anlaşılacağı üzere, renk seçimi için ihtiyaç duyacağımız widget'ı buradan çağıracağız. \n",
    "\n",
    "<hr>\n",
    "\n",
    "Pencere içerisindeki widget'larımız şu şekilde olacak:\n",
    "\n",
    "    canvas = tk.Canvas(window, bg=\"white\")\n",
    "    canvas.pack(fill=tk.BOTH, expand=True)\n",
    "\n",
    "    color_button = ttk.Button(window, text=\"Color\", command=choose_color)\n",
    "    color_button.pack(side=tk.LEFT)\n",
    "    clear_button = ttk.Button(window, text=\"Clear\", command=clear_canvas)\n",
    "    clear_button.pack(side=tk.LEFT)\n",
    "\n",
    "    window.bind(\"<plus>\", lambda event: brush_size_up(event))\n",
    "    window.bind(\"<minus>\", lambda event: brush_size_down(event))\n",
    "    window.bind(\"<Motion>\", lambda event: paint_on_canvas(event))\n",
    "    \n",
    "* **canvas:** Tuvalimizi oluşturup pencere içerisine yerleştirdik. **BOTH** sabiti ile ait olduğu pencereyi dolduracak ve **expand=True** ile kullanıcı pencereyi büyülttüğünde, tuval de büyüyecek.\n",
    "* **color_button:** Renk seçimi için butonumuzu oluşturup, pencere içerisine yerleştirdik. **command=** parametresine **choose_color** isminde birazdan tanımlayacağımız bir fonksiyon atadık.\n",
    "* **clear_button:** Tuvali temizlemek için butonumuzu oluşturuyoruz, **command=** olarak da **clear_canvas** isminde yine birazdan tanımlayacağımız bir fonksiyonu atıyoruz.\n",
    "* Penceremize 3 adet bind atıyoruz. **plus** ve **minus**, klavyemizdeki '+' ve '-' tuşlarına atama yapmamızı sağlıyor; bu iki bind'i fırça büyüklüğümüzü değiştirecek iki fonksiyona atadık. **Motion** bind'i da imlecimiz hareket ettikçe çalışıyor. Boyama fonksiyonumuzu da bu bind'a atıyoruz.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Uygulamamızda boyama işlemini, imlecimize bağlayacağımız fırça ile ve bir başlangıç rengi ile yapacağımız için, fırça büyüklüğünü ve varsayılan başlangıç rengini birer değişkene atıyoruz:\n",
    "\n",
    "    brush_size = 10\n",
    "    color = \"black\"\n",
    "\n",
    "<hr>\n",
    "\n",
    "Şimdi widgetlarımıza atadığımız fonksiyonları tanımlayalım:\n",
    "\n",
    "choose_color, renk seçmek için oluşturduğumuz fonksiyon. varsayılan **color** değişkenini dışarıda tanımladığımız için color'ı içeride global olarak çağırıyoruz. Rengimizi(**color**) `colorchooser.askcolor()[1]` metodu ile oluşturuyoruz. <br> **Not:** Neden en sonuna [1] ekleyip birinci indeksi döndürmesini istedik? Çünkü bu metot bize iki şekilde rengi döndürüyor. Mesela beyaz rengi için: ((255, 255, 255), '#ffffff') döndürüyor. Bize html renk kodu lazım olduğu için birinci indeksi döndürüyoruz.\n",
    "\n",
    "    def choose_color():\n",
    "        global color\n",
    "        color = colorchooser.askcolor()[1]\n",
    "        print(color)\n",
    "\n",
    "<hr>\n",
    "\n",
    "clear_canvas, tuval üzerinde yapılan değişiklikleri silmek için kullanacağımız fonksiyon. Bunun için canvasın `canvas.delete(\"all\")` metodundan yararlanıyoruz.\n",
    "\n",
    "    def clear_canvas():\n",
    "        canvas.delete(\"all\")\n",
    "\n",
    "<hr>\n",
    "\n",
    "paint_on_canvas ile boyama işlemini yapacağız. Fırçamızı daire şeklinde tanımlayacağız, bunun için hatırlarsanız `canvas.create_oval(x1,y1,x2,y2)` metodumuz vardı. Fırçanın büyüklüğünü dışarıdan aldığımız **brush_size** değişkeni ile yapacağız. Rengi de yine dışarıda tanımladığımız **color** değişkeni ile atıyoruz.\n",
    "\n",
    "    def paint_on_canvas(event):\n",
    "        x = event.x\n",
    "        y = event.y\n",
    "        canvas.create_oval((x - brush_size / 2, y - brush_size / 2, \n",
    "                            x + brush_size / 2, y + brush_size / 2), \n",
    "                            outline=color, fill=color)\n",
    "\n",
    "<hr>\n",
    "\n",
    "Fırça büyüklüğümüzü de brush_size_up ve brush_size_down fonksiyonları ile tanımlıyoruz. Basılan her '+' veya '-' için globaldeki **brush_size** değişkenimiz değişiyor. <br> **Not:** Neden brush_size_down fonksiyonu içi **if** şartı ekledik? Eğer fırça büyüklüğü eksi değere geçerse, fırçanın boyutu artmaya başlayacaktı. Çünkü `canvas.create_oval` metodu aldığı koordinat değerlerini **absolute** yani mutlak değer olarak alıyor.\n",
    "\n",
    "    def brush_size_up(event):\n",
    "        global brush_size\n",
    "        brush_size += 1\n",
    "        print(brush_size)\n",
    "\n",
    "    def brush_size_down(event):\n",
    "        global brush_size\n",
    "        if brush_size > 1:\n",
    "            brush_size -= 1\n",
    "            print(brush_size)\n",
    "            \n",
    "<hr>\n",
    "\n",
    "Son olarak döngümüzü oluşturuyoruz:\n",
    "\n",
    "    window.mainloop()\n",
    "    \n",
    "<hr>\n",
    "\n",
    "**Bu uygulama daha da geliştirilebilir:**\n",
    "\n",
    "* Fare ile otomatik olarak boyamaktansa, kullanıcı sol tuşa bastığında boyama yapmak.\n",
    "* Silgi butonu ekleyip, kullanıcının tuval üzerinde istediği yeri silebilmesi.\n",
    "* Oval fırça dışında fırça tipi eklemek."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "092f36e9",
   "metadata": {},
   "source": [
    "### Simple Paint Application"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7cea5064",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "from tkinter import ttk\n",
    "from tkinter import colorchooser\n",
    "\n",
    "# global variables\n",
    "brush_size = 10\n",
    "color = \"black\"\n",
    "\n",
    "# functions\n",
    "def choose_color():\n",
    "    global color\n",
    "    color = colorchooser.askcolor()[1]\n",
    "    print(color)\n",
    "\n",
    "def clear_canvas():\n",
    "    canvas.delete(\"all\")\n",
    "\n",
    "def paint_on_canvas(event):\n",
    "    x = event.x\n",
    "    y = event.y\n",
    "    canvas.create_oval((x - brush_size / 2, y - brush_size / 2, x + brush_size / 2, y + brush_size / 2), \n",
    "                      outline=color, fill=color)\n",
    "\n",
    "def brush_size_up(event):\n",
    "    global brush_size\n",
    "    brush_size += 1\n",
    "    print(brush_size)\n",
    "    \n",
    "def brush_size_down(event):\n",
    "    global brush_size\n",
    "    if brush_size > 1:\n",
    "        brush_size -= 1\n",
    "        print(brush_size)\n",
    "\n",
    "# window setup\n",
    "window = tk.Tk()\n",
    "window.title(\"Simple Paint\")\n",
    "window.geometry(\"800x600\")\n",
    "\n",
    "# widgets\n",
    "canvas = tk.Canvas(window, bg=\"white\")\n",
    "canvas.pack(fill=tk.BOTH, expand=True)\n",
    "\n",
    "color_button = ttk.Button(window, text=\"Color\", command=choose_color)\n",
    "color_button.pack(side=tk.LEFT)\n",
    "clear_button = ttk.Button(window, text=\"Clear\", command=clear_canvas)\n",
    "clear_button.pack(side=tk.LEFT)\n",
    "\n",
    "window.bind(\"<plus>\", lambda event: brush_size_up(event))\n",
    "window.bind(\"<minus>\", lambda event: brush_size_down(event))\n",
    "window.bind(\"<Motion>\", lambda event: paint_on_canvas(event))\n",
    "\n",
    "# run\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07e66158",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "30947a40",
   "metadata": {},
   "source": [
    "<a id=\"tables\"></a>\n",
    "# 9-) Tables"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44a88dcc",
   "metadata": {},
   "source": [
    "Tablolar, tkinter'ın önemli widget'larından birisi. Hemen modülleri import edip pencere kurulumunu yapalım:\n",
    "\n",
    "    import tkinter as tk\n",
    "    from tkinter import ttk\n",
    "\n",
    "    window = tk.Tk()\n",
    "    window.title(\"Tables\")\n",
    "    window.geometry(\"600x400\")\n",
    "    \n",
    "<hr>\n",
    "\n",
    "Tablo içerisine veri yazabilmek için iki adet liste oluşturalım:\n",
    "\n",
    "    first_name = [\"Jeffrey\", \"Britta\", \"Abed\", \"Annie\", \"Shirley\", \"Troy\", \"Pierce\", \n",
    "    \"Craig\", \"Benjamin\"]\n",
    "    last_name = [\"Winger\", \"Perry\", \"Nadir\", \"Edison\", \"Bennet\", \"Barnes\", \"Hawthorne\", \n",
    "    \"Pelton\", \"Chang\"]\n",
    "    \n",
    "<hr>\n",
    "\n",
    "Tablo oluşturmak için ihtiyaç duyduğumuz widget `ttk.Treeview()`. Hemen uygulama içerisine ekleyelim:\n",
    "\n",
    "    table = ttk.Treeview(window, columns=(\"First Name\", \"Last Name\", \"Email\"), show=\"headings\")\n",
    "    table.heading(\"First Name\", text=\"First Name\")\n",
    "    table.heading(\"Last Name\", text=\"Last Name\")\n",
    "    table.heading(\"Email\", text=\"Email\")\n",
    "    table.pack(fill=\"both\", expand=True)\n",
    "    \n",
    "Oluşturduğumuz tablo, ilk parametre olarak bağlı olduğu pencereyi bekliyor. Ardından **columns=** isimli parametreyi dolduruyoruz. Bu parametre; tablomuzdaki başlıkları oluşturmamızı sağlıyor. **show=** parametresi ile de tablomuz içinde yazacağımız başlıkları(**heading**) göstermesini istiyoruz. Daha sonra her bir başlık için, widget içerisinde ne yazacağına karar vermek adına `table.heading` metodunu kullanıyoruz. <br> `table.heading(\"First Name\", text=\"First Name\")`: First Name başlığı için, widget içerisinde First Name yazmasını istediğimiz için bu şekilde bir ifade kullanıyoruz.\n",
    "\n",
    "Her bir başlığı girdikten sonra tablomuzu pencereye yerleştiriyoruz. **fill=\"both\"** parametresi ile pencereyi doldurmasını, **expand=True** parametresi ile de pencere büyüklüğüne bağlı olarak tablomuzun genişlemesini istiyoruz.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Oluşturduğumuz tabloya, listelerimdeki verileri girmek için `insert` metodunu kullanacağız:\n",
    "\n",
    "    for i in range(len(first_name)):\n",
    "        table.insert(parent=\"\", index=tk.END, values=(first_name[i], last_name[i], \n",
    "                    (last_name[i]+first_name[i]+\"@gmail.com\")))\n",
    "                    \n",
    "Her değeri girmek için **for** döngüsü oluşturuyoruz. <br> **parent=** parametresinde bağlı olduğu bir yer olmadığı için boş bırakıyoruz. **index=** parametresi içerisine tkinter'ın **END** sabitini yazıyoruz. Bu sayede eklenen her veri, tablonun sonuna ekleniyor olacak. <br> **Not:** Onun yerine index için 0 integer'ını girip baştan sona da ekletebiliriz. <br> **values=** parametresine her bir başlık için tablo içerisine yazılacak değerleri giriyoruz: <br> **First Name** başlığı için `first_name[i]` <br> **Last Name** başlığı için `last_name[i]` <br> ve **Email** başlığı için de `last_name[i]+first_name[i]+\"@gmail.com\"` yazmasını istiyoruz.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Şimdi de tablo için iki adet bind giriyoruz:\n",
    "\n",
    "    table.bind(\"<<TreeviewSelect>>\", item_select)\n",
    "    table.bind(\"<Delete>\", delete_item)\n",
    "    \n",
    "İlki tablo içerisinde seçim yaptığımızda tetikleniyor, ikincisi ise klavyede **delete** tuşuna bastığımızda. Bu eventler için atadığımız `delete_item` ve `item_select` fonksiyonlarını tanımlayalım:\n",
    "\n",
    "    def item_select(_):\n",
    "        print(table.selection())\n",
    "        for i in table.selection():\n",
    "            print(table.item(i)[\"values\"])\n",
    "\n",
    "    def delete_item(_):\n",
    "        for i in table.selection():\n",
    "            table.delete(i)\n",
    "            \n",
    "`item_select` fonksiyonu seçtiğimiz her değeri bize **for** döngüsü içerisinde print ediyor. Bunu **table**'ın `selection` metodu ile yapıyoruz. `delete_item` ise yine **table**'ın `delete` metodu ile seçili olan değerleri tablodan siliyor. <br> **Not:** Neden fonksiyonları tanımlarken parametre olarak **event** değil de **_** girdik. Bu fonksiyonlarda girilen argümanın ne olduğu önemli olmadığı için alttan tire işaretini kullandık.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Her zaman olduğu gibi, döngümüzü oluşturuyoruz:\n",
    "\n",
    "    window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8686cece",
   "metadata": {},
   "source": [
    "### 9-) Tables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74d82561",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "from tkinter import ttk\n",
    "\n",
    "# functions\n",
    "def item_select(_):\n",
    "    print(table.selection())\n",
    "    for i in table.selection():\n",
    "        print(table.item(i)[\"values\"])\n",
    "        \n",
    "def delete_item(_):\n",
    "    for i in table.selection():\n",
    "        table.delete(i)\n",
    "\n",
    "# window setup\n",
    "window = tk.Tk()\n",
    "window.title(\"Tables\")\n",
    "window.geometry(\"600x400\")\n",
    "\n",
    "# lists\n",
    "first_name = [\"Jeffrey\", \"Britta\", \"Abed\", \"Annie\", \"Shirley\", \"Troy\", \"Pierce\", \"Craig\", \"Benjamin\"]\n",
    "last_name = [\"Winger\", \"Perry\", \"Nadir\", \"Edison\", \"Bennet\", \"Barnes\", \"Hawthorne\", \"Pelton\", \"Chang\"]\n",
    "\n",
    "# widgets\n",
    "table = ttk.Treeview(window, columns=(\"First Name\", \"Last Name\", \"Email\"), show=\"headings\")\n",
    "table.heading(\"First Name\", text=\"First Name\")\n",
    "table.heading(\"Last Name\", text=\"Last Name\")\n",
    "table.heading(\"Email\", text=\"Email\")\n",
    "table.pack(fill=\"both\", expand=True)\n",
    "\n",
    "for i in range(len(first_name)):\n",
    "    table.insert(parent=\"\", index=tk.END, values=(first_name[i], last_name[i], \n",
    "                                             (last_name[i]+first_name[i]+\"@gmail.com\")))\n",
    "    \n",
    "# bindings\n",
    "table.bind(\"<<TreeviewSelect>>\", item_select)\n",
    "table.bind(\"<Delete>\", delete_item)\n",
    "\n",
    "# run\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c166bddf",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "dbffd4b7",
   "metadata": {},
   "source": [
    "<a id=\"sliders\"></a>\n",
    "# 10-) Sliders"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbb79c15",
   "metadata": {},
   "source": [
    "Sliders; ekranı kaydırma, bir değeri ölçeklendirme veya ilerlemeyi takip amaçlı kullanılan bir widget.\n",
    "\n",
    "Yine modülleri import etme ve pencere kurulumu ile başlıyoruz:\n",
    "\n",
    "    import tkinter as tk\n",
    "    from tkinter import ttk\n",
    "    from tkinter import scrolledtext\n",
    "\n",
    "    window = tk.Tk()\n",
    "    window.title(\"Sliders\")\n",
    "    \n",
    "Ekstradan **scrolledtext** import ettik. Örnek içerisinde ne işe yaradığını göreceğiz.\n",
    "    \n",
    "<hr>\n",
    "\n",
    "Bir değeri ölçeklendirme içine `ttk.Scale` kullanıyoruz:\n",
    "\n",
    "    float_int = tk.DoubleVar(value=15)\n",
    "    scale = ttk.Scale(window, \n",
    "                      command= lambda value: progress.stop(), \n",
    "                      orient=\"vertical\", \n",
    "                      from_=0, to=25,\n",
    "                      length=300,\n",
    "                      variable=float_int)\n",
    "    scale.pack()\n",
    "    \n",
    "İlk parametre olarak yine bağlı olduğu pencereyi giriyoruz. **orient=**, scale'in dikey mi yatay mı olacağına karar veriyor. Daha önceden de kullandığımız **from_=** ve **to=** parametrelerine, scale'in minimum ve maksimum olabileceği değerleri giriyoruz. **length=**, widget'ın uzunluğuna karar veriyor. **variable=**'a, scale'in bir üst satırında tanımladığımız `tk.DoubleVar`'ı atıyoruz. (DoubleVar, float değer için kullanılıyor.) Bir de **command=** parametresi var. Butonda olduğu gibi, bir fonksiyonu çağırıyoruz. `progress.stop`'u, progress barı tanımladıktan sonra göreceğiz.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Progress bar, ilerleme barı anlamına geliyor.\n",
    "\n",
    "    progress = ttk.Progressbar(window,\n",
    "                               variable=float_int,\n",
    "                               maximum=25,\n",
    "                               orient=\"horizontal\",\n",
    "                               mode=\"indeterminate\",\n",
    "                               length=400)\n",
    "    progress.pack()\n",
    "    \n",
    "**variable=** parametresine yukarıda tanımladığımız **float_int** değişkenini atıyoruz. Biraz önce tanımladığımız scale'in, progres barı yönetmesini istediğimiz için **maximum=** parametresine 25 giriyoruz. (Scale'de de 0'dan 25'e yapmıştık değerleri.) **orient=** yine dikey veya yatay seçimi için kullanılıyor. **mode=** parametresine **\"indeterminate\"** yazdığımızda, yeşil değer progress barı doldurmak yerine, scale gibi bar içerisinde değere bağlı hareket etmeye başlıyor. (mode'u yazmadan denersek daha net anlaşılacak.) **length=** yine widget'ın uzunluğunu belirleyecek. progress'i tanımladıktan sonra, `pack()` metodu ile yerleştiriyoruz. <br> Progress'in stop metodunu da scale'in command'ine atadıktan sonra, scale'i hareket ettirdikçe, progress'te de aynı değeri göreceğiz.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Import ettiğimiz **scrolledtext** ile, daha önceden de yaptığımız bir text kutusu oluşturuyoruz. Metin sığmadığı zaman, kutunun sağında scrollbar oluşuyor.\n",
    "\n",
    "    scrolled_text = scrolledtext.ScrolledText(window, width=100, height=20)\n",
    "    scrolled_text.pack()\n",
    "    \n",
    "<hr>\n",
    "\n",
    "Yukarıda yaptığımız gibi bir **scalebar** ve bir **progressbar** daha yapıyoruz. Bu sefer birkaç farlılık var:\n",
    "\n",
    "    scale_int = tk.IntVar()\n",
    "    scale2 = ttk.Scale(window,\n",
    "                       command= lambda value: progress2.stop(),\n",
    "                       orient=\"horizontal\",\n",
    "                       from_=0, to=100,\n",
    "                       length=100,\n",
    "                       variable=scale_int)\n",
    "    scale2.pack()\n",
    "\n",
    "\n",
    "    progress2 = ttk.Progressbar(window,\n",
    "                                variable=scale_int,\n",
    "                                maximum=100,\n",
    "                                orient=\"vertical\",\n",
    "                                length=100)\n",
    "    progress2.pack()\n",
    "    \n",
    "Ayrıca aşağıdaki ifadeyi ekliyoruz:\n",
    "\n",
    "    progress2.start(250)\n",
    "\n",
    "    progress_label = ttk.Label(window,textvariable=scale_int)\n",
    "    progress_label.pack()\n",
    "    \n",
    "İlk yazdığımız `start(250)` metodu, progressbarın otomatik dolması için. Parantez içerisine saniyede ne kadar dolacağını giriyoruz. (1000 = 1 saniye) <br> İkinci ifade de progressbar'ın ve scalebar'ın bağlı olduğu **scale_int** değerini sayısal görmek için bir **label** widget'ı oluşturuyoruz.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Son olarak yine döngüyü oluşturuyoruz:\n",
    "\n",
    "    window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae32dfa6",
   "metadata": {},
   "source": [
    "### 10-) Sliders:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99c4bb53",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "from tkinter import ttk\n",
    "from tkinter import scrolledtext\n",
    "\n",
    "# window setup\n",
    "window = tk.Tk()\n",
    "window.title(\"Sliders\")\n",
    "\n",
    "# slider\n",
    "float_int = tk.DoubleVar(value=15)\n",
    "scale = ttk.Scale(window, \n",
    "                  command= lambda value: progress.stop(), \n",
    "                  orient=\"vertical\", \n",
    "                  from_=0, to=25,\n",
    "                  length=300,\n",
    "                  variable=float_int)\n",
    "scale.pack()\n",
    "\n",
    "# progress bar\n",
    "progress = ttk.Progressbar(window,\n",
    "                           variable=float_int,\n",
    "                           maximum=25,\n",
    "                           orient=\"horizontal\",\n",
    "                           mode=\"indeterminate\",\n",
    "                           length=400)\n",
    "progress.pack()\n",
    "\n",
    "# text scroll\n",
    "scrolled_text = scrolledtext.ScrolledText(window, width=100, height=20)\n",
    "scrolled_text.pack()\n",
    "\n",
    "# slider 2\n",
    "scale_int = tk.IntVar()\n",
    "scale2 = ttk.Scale(window,\n",
    "                   command= lambda value: progress2.stop(),\n",
    "                   orient=\"horizontal\",\n",
    "                   from_=0, to=100,\n",
    "                   length=100,\n",
    "                   variable=scale_int)\n",
    "scale2.pack()\n",
    "\n",
    "# progress bar 2\n",
    "progress2 = ttk.Progressbar(window,\n",
    "                            variable=scale_int,\n",
    "                            maximum=100,\n",
    "                            orient=\"vertical\",\n",
    "                            length=100)\n",
    "progress2.pack()\n",
    "progress2.start(250)\n",
    "\n",
    "# text label for progress bar 2\n",
    "progress_label = ttk.Label(window,textvariable=scale_int)\n",
    "progress_label.pack()\n",
    "\n",
    "# run\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1138cb1e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "72237128",
   "metadata": {},
   "source": [
    "<a id=\"frames\"></a>\n",
    "# 11-) Parenting Frames"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0769db5",
   "metadata": {},
   "source": [
    "Pencere içerisine birden fazla widget eklerken, penceremizi bir düzen(**layout**) içerisinde tutmak için çerçeve(**frame**) widget'ı kullanıyoruz. \n",
    "\n",
    "İlk olarak modülleri import edip, pencere kurulumunu yapalım:\n",
    "\n",
    "    import tkinter as tk\n",
    "    from tkinter import ttk\n",
    "\n",
    "    window = tk.Tk()\n",
    "    window.title(\"Frames\")\n",
    "    window.geometry(\"600x400\")\n",
    "    \n",
    "<hr>\n",
    "\n",
    "İlk frame'imizi tanımlayalım:\n",
    "\n",
    "    frame = ttk.Frame(window, width=200, height=200, borderwidth=10, relief=tk.GROOVE) \n",
    "    frame.pack_propagate(False)\n",
    "    frame.pack(side=\"left\")\n",
    "    \n",
    "frame için boyutları tanımladık: **width=**, **height=**, çerçevenin dış kenar genişliğini tanımladık: **borderwidth=** ve dış kenarın nasıl gözükeceğini tanımladık: **relief=**. Dış kenar görünümü için, `tk.GROOVE` dışında motifler de var: **RIDGE,FLOAT,SUNKEN,RAISED** <br> frame'in `pack_propagate()` metodu, pencereye yerleştirilirken, boyutunun widget'lara göre mi yoksa bizim tanımladığımız width ve height değerlerine göre mi olacağına karar verir. **True** girersek widget'lara göre, **False** girersek tanımladığımız boyutlara göre.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Daha sonra tanımladığımız frame içerisine herhangi bir işlevi olmayan birkaç widget ekliyoruz:\n",
    "\n",
    "    label = ttk.Label(frame, text=\"label in a frame\")\n",
    "    label.pack()\n",
    "\n",
    "    button = ttk.Button(frame, text=\"button in a frame\")\n",
    "    button.pack()\n",
    "\n",
    "    label2 = ttk.Label(window, text=\"label outside frame\")\n",
    "    label2.pack(side=\"left\")\n",
    "    \n",
    "<hr>\n",
    "\n",
    "Şimdi ikinci frame'i ekliyoruz:\n",
    "\n",
    "    frame2 = ttk.Frame(window, width=200, height=200, borderwidth=20, relief=tk.RIDGE)\n",
    "    frame2.pack(side=\"left\")\n",
    "    \n",
    "<hr>\n",
    "\n",
    "Hemen ardından ikinci frame için widgetlarımızı tanımlayıp, yerleştiriyoruz:\n",
    "\n",
    "    label3 = ttk.Label(frame2, text=\"label in the second frame\")\n",
    "    label3.pack()\n",
    "\n",
    "    button2 = ttk.Button(frame2, text=\"button in the second frame\")\n",
    "    button2.pack()\n",
    "\n",
    "    entry = ttk.Entry(frame2, width=30)\n",
    "    entry.pack()\n",
    "    \n",
    "<hr>\n",
    "\n",
    "Son olarak döngüyü oluşturuyoruz:\n",
    "\n",
    "    window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b7e1909",
   "metadata": {},
   "source": [
    "### 11-) Parenting Frames:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5cc04642",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "from tkinter import ttk\n",
    "\n",
    "window = tk.Tk()\n",
    "window.title(\"Frames\")\n",
    "window.geometry(\"600x400\")\n",
    "\n",
    "# first frame\n",
    "frame = ttk.Frame(window, width=200, height=200, borderwidth=10, relief=tk.GROOVE) \n",
    "# RIDGE,FLOAT,SUNKEN,RAISED\n",
    "frame.pack_propagate(False) # to keep frame's width and height otherwise it adjusts by it's children\n",
    "frame.pack(side=\"left\")\n",
    "\n",
    "# master setting for first frame\n",
    "label = ttk.Label(frame, text=\"label in a frame\")\n",
    "label.pack()\n",
    "\n",
    "button = ttk.Button(frame, text=\"button in a frame\")\n",
    "button.pack()\n",
    "\n",
    "label2 = ttk.Label(window, text=\"label outside frame\")\n",
    "label2.pack(side=\"left\")\n",
    "\n",
    "# second frame\n",
    "frame2 = ttk.Frame(window, width=200, height=200, borderwidth=20, relief=tk.RIDGE)\n",
    "frame2.pack(side=\"left\")\n",
    "\n",
    "# master setting for second frame\n",
    "label3 = ttk.Label(frame2, text=\"label in the second frame\")\n",
    "label3.pack()\n",
    "\n",
    "button2 = ttk.Button(frame2, text=\"button in the second frame\")\n",
    "button2.pack()\n",
    "\n",
    "entry = ttk.Entry(frame2, width=30)\n",
    "entry.pack()\n",
    "\n",
    "# run\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57c16a6e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "3d77e3a6",
   "metadata": {},
   "source": [
    "<a id=\"tabs\"></a>\n",
    "# 12-) Tabs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "469ba500",
   "metadata": {},
   "source": [
    "Sekmeler(**Tabs**), internet browserlarından alışkın olduğumuz sekmelere benziyor.\n",
    "\n",
    "Her zaman olduğu gibi modülleri import edip pencere kurulumunu yapıyoruz:\n",
    "\n",
    "    import tkinter as tk\n",
    "    from tkinter import ttk\n",
    "\n",
    "    window = tk.Tk()\n",
    "    window.title(\"Tabs\")\n",
    "    window.geometry(\"600x400\")\n",
    "    \n",
    "<hr>\n",
    "    \n",
    "Sekmeleri oluşturmak için `ttk.Notebook()` instance'ını pencere üzerinde oluşturmamız gerekiyor:\n",
    "\n",
    "    notebook = ttk.Notebook(window)\n",
    "    tab1 = ttk.Frame(notebook)\n",
    "    tab2 = ttk.Frame(notebook)\n",
    "    tab3 = ttk.Frame(notebook)\n",
    "    notebook.add(tab1, text=\"Tab 1\")\n",
    "    notebook.add(tab2, text=\"Tab 2\")\n",
    "    notebook.add(tab3, text=\"Tab 3\")\n",
    "    notebook.pack()\n",
    "    \n",
    "Daha sonra oluşturduğumuz **notebook'u** her bir sekme için tanımladığımız **frame'lerin** parenti olarak atıyoruz. Bu işlemden sonra ilgili **notebook'u** pencereye yerleştirmek için `pack()` veya `grid()` değil, `add()` metodunu kullanıyoruz. En sonda da **notebook'un** kendisini pencereye yerleştiriyoruz.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Bundan sonraki kısımda farklı bir şey yok. Widgetlarımızı tanımlayıp, parent olarak istediğimiz sekmenin ismini giriyoruz:\n",
    "\n",
    "    button_tab1 = ttk.Button(tab1, text=\"button\")\n",
    "    button_tab1.pack()\n",
    "    label_tab1 = ttk.Label(tab1, text=\"Hello world!\")\n",
    "    label_tab1.pack()\n",
    "\n",
    "\n",
    "    label_tab2 = ttk.Label(tab2, text=\"An entry below:\")\n",
    "    label_tab2.pack()\n",
    "    entry_tab2 = ttk.Entry(tab2, width=30)\n",
    "    entry_tab2.pack()\n",
    "\n",
    "\n",
    "    label_tab3 = ttk.Label(tab3, text=\"The two buttons\")\n",
    "    label_tab3.pack()\n",
    "    button_tab3 = ttk.Button(tab3, text=\"First button\")\n",
    "    button_tab3.pack()\n",
    "    button2_tab3 = ttk.Button(tab3, text=\"Second button\")\n",
    "    button2_tab3.pack()\n",
    "    \n",
    "<hr>\n",
    "\n",
    "Son olarak döngümüzü oluşturuyoruz:\n",
    "\n",
    "    window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96da0e67",
   "metadata": {},
   "source": [
    "### 12-) Tabs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "340d7043",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "from tkinter import ttk\n",
    "\n",
    "# window setup\n",
    "window = tk.Tk()\n",
    "window.title(\"Tabs\")\n",
    "window.geometry(\"600x400\")\n",
    "\n",
    "# notebook widget\n",
    "notebook = ttk.Notebook(window)\n",
    "tab1 = ttk.Frame(notebook)\n",
    "tab2 = ttk.Frame(notebook)\n",
    "tab3 = ttk.Frame(notebook)\n",
    "notebook.add(tab1, text=\"Tab 1\")\n",
    "notebook.add(tab2, text=\"Tab 2\")\n",
    "notebook.add(tab3, text=\"Tab 3\")\n",
    "notebook.pack()\n",
    "\n",
    "# first tab widgets\n",
    "button_tab1 = ttk.Button(tab1, text=\"button\")\n",
    "button_tab1.pack()\n",
    "label_tab1 = ttk.Label(tab1, text=\"Hello world!\")\n",
    "label_tab1.pack()\n",
    "\n",
    "# second tab widgets\n",
    "label_tab2 = ttk.Label(tab2, text=\"An entry below:\")\n",
    "label_tab2.pack()\n",
    "entry_tab2 = ttk.Entry(tab2, width=30)\n",
    "entry_tab2.pack()\n",
    "\n",
    "# third tab widgets\n",
    "label_tab3 = ttk.Label(tab3, text=\"The two buttons\")\n",
    "label_tab3.pack()\n",
    "button_tab3 = ttk.Button(tab3, text=\"First button\")\n",
    "button_tab3.pack()\n",
    "button2_tab3 = ttk.Button(tab3, text=\"Second button\")\n",
    "button2_tab3.pack()\n",
    "\n",
    "# run\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d162a609",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "bae9bc8f",
   "metadata": {},
   "source": [
    "<a id=\"menu\"></a>\n",
    "# 13-) Menus"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb98d7e6",
   "metadata": {},
   "source": [
    "Menüler, çoğu uygulamada üst kısımda bulunan, genelde belli bazı işlemleri yapmamızı sağlayan küçük widgetlar. Temelde menüleri oluşturma prensibi, menü içerisinde menü yaratarak oluyor. Örnek içerisinde daha net anlaşılıyor.\n",
    "\n",
    "Hemen import ve kurulumu yapıyoruz:\n",
    "\n",
    "    import tkinter as tk\n",
    "    from tkinter import ttk\n",
    "\n",
    "    window = tk.Tk()\n",
    "    window.title(\"Menus\")\n",
    "    window.geometry(\"600x400\")\n",
    "    \n",
    "<hr>\n",
    "\n",
    "İlk olarak menümüzü tanımlıyoruz:\n",
    "\n",
    "    menu = tk.Menu(window)\n",
    "    \n",
    "<hr>\n",
    "\n",
    "Şimdi de oluşturduğumuz menü içerisine menüler yerleştirip command'lerine fonksiyon ekleyeceğiz:\n",
    "\n",
    "    file_menu = tk.Menu(menu, tearoff=False)\n",
    "    file_menu.add_command(label=\"New\", command=lambda: print(\"New File!\"))\n",
    "    file_menu.add_command(label=\"Open\", command=lambda: print(\"Open File!\"))\n",
    "    file_menu.add_separator()\n",
    "    menu.add_cascade(label=\"File\", menu=file_menu)\n",
    "    \n",
    "Ana menü içerisine ilk menümüzü yerleştiriyoruz. **tearoff=** parametresine False giriyoruz çünkü aksi takdirde menüye tıklandığında, menüyü yeni bir pencerede açıyor. Doğal olarak biz bunu istemiyoruz. <br> Daha sonra, yeni oluşturduğumuz **file_menu** için, `add_command()` metodunu kullanarak içerisinde oluşturduğumuz **label'lara** fonksiyon atıyoruz. İlkine \"New\" ismini verdik ve \"New File!\" stringini print ediyor. Diğerine ise \"Open\" ismini verdik ve \"Open File!\" stringini print ediyor. <br> `add_separator()` metodu ise menü içerisindeki labelların arasına ayraç koymak için kullanılıyor. <br> Oluşturduğumuz **file_menu** isimli menüyü, ana menüye eklemek için ise `menu.add_cascade()` metodunu kullanıyoruz. Metodun içindeki ilk parametre olan **label=** oluşturduğumuz menünün hangi isimle gözükeceğini belirtiyor. İkinci parametre ise, hangi menünün yerleştirileceği, bizim örneğimizde menünün atandığı değişken ismi **file_menu** olduğu için bunu giriyoruz.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Az önce oluşturduğumuz **file_menu** menüsünün içerisine bir menü daha ekleyeceğiz şimdi:\n",
    "\n",
    "    extra_menu = tk.Menu(file_menu, tearoff=False)\n",
    "    extra_menu.add_radiobutton(label=\"Yesn't\", command=lambda: print(\"Yesn't\"))\n",
    "    extra_menu.add_radiobutton(label=\"Nope\", command=lambda: print(\"Nope\"))\n",
    "    file_menu.add_cascade(label=\"File Options\", menu=extra_menu)\n",
    "    \n",
    "Bu menüyü **extra_menu** isimli bir değişken ile tanımladık ve parenti olarak az önce yarattığımız **file_menu'yü** yazdık. Menü içerisine ise bu sefer bir fonksiyonu çağıran label yerine **radiobutton** kullanalım. Bunun içine `add_radiobutton()` metodunu kullanıyoruz, fonksiyon olarak da, kendi üzerlerinde yazan stringi bize döndürmesini istiyoruz. <br> Tabii oluşturduğumuz menüyü yerleştirmek için yine `add_cascade()` metodunu kullanıyoruz. Ekleyeceğimiz menünün isminin \"File Options\" olmasını istediğimiz için **label=** parametresine bu stringi giriyoruz. Ekleyeceğimiz menünün değişken ismi de **extra_menu** olduğu içine **menu=** parametresine de bu değeri giriyoruz.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Şimdi, ana menü üzerine yerleştirdiğimiz \"File\" menüsünün yanına da bir adet \"Help\" isimli menü yerleştirelim:\n",
    "\n",
    "    help_menu = tk.Menu(menu, tearoff=False)\n",
    "    help_menu.add_command(label=\"Help Entry\", \n",
    "                          command=lambda: print(help_check_str_value.get()))\n",
    "    help_check_str_value = tk.StringVar()\n",
    "    help_menu.add_checkbutton(label=\"Check\", onvalue=\"Help is on\", \n",
    "                              offvalue=\"Help is off\", variable=help_check_str_value)\n",
    "    menu.add_cascade(label=\"Help\", menu=help_menu)\n",
    "    \n",
    "Bu sefer de menümüzü **help_menu** değişkeni ile tanımladık. Parenti **menu** ve **tearoff=False**. Ancak içerisinde oluşturduğumuz **Help Entry** label'ına atadığımız fonksiyon farklı: `help_check_str_value.get()` => String değişkenlerini bize döndüren fonksiyon. Hemen, `tk.StringVar` ile aynı isimde bir değişken de tanımlıyoruz. Daha sonra menüdeki bu label'ın altına, string değerini değiştiren bir checkbutton ekliyoruz: `help_menu.add_checkbutton()`. Bu checkbutona birer **onvalue=** ve **offvalue=** giriyoruz. Hemen üstteki **Help Entry**'e basıldığına, checkbutonun durumuna göre string print edilecek.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Ana menü içerisine tüm bu menüleri ekledik ancak henüz ana menüyü pencere içerisine yerleştirmedik:\n",
    "\n",
    "    window.configure(menu=menu)\n",
    "    \n",
    "**Not:** Ana menü widget'ını diğer widget'lar gibi `pack()` ve `grid()` gibi metodlar ile yerleştiremiyoruz. Onun için `configure()` metodunu kullandık.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Az önce oluşturduğumuz ana menü dışında, direkt pencere üzerine de pencere tanımlayabiliyoruz:\n",
    "\n",
    "    menu_button = ttk.Menubutton(window, text=\"Menu Button\")\n",
    "    menu_button.pack()\n",
    "    button_sub_menu = tk.Menu(menu_button, tearoff=False)\n",
    "    button_sub_menu.add_command(label=\"An entry\", command=lambda: print(\"Yep...\"))\n",
    "    button_sub_menu.add_checkbutton(label=\"Checking\")\n",
    "    \n",
    "Bunu yaparken **tk** yerine **ttk** kullanacağız ve tk'deki menunun aksine `pack()` metodu ile pencereye yerleştirebiliyoruz. Bu yeni ana menünün ismi **menu_button** olsun. Oluşturduğumuz yeni menünün içerisine **button_sub_menu** isminde tekrar menü tanımlayalım. Parenti **menu_button** olacak ve **tearoff=** False olacak. <br> Yeni oluşturduğumuz alt menü içerisine; bir adet print yapan command ve bir adet de herhangi bir işlev eklemediğimiz checkbutton tanımlıyoruz.\n",
    "\n",
    "Bu oluşturduğumuz ana menü içerisindeki menü `tk.Menu` olduğundan, ait olduğu parentin `configure` metodu ile yerleştirilecek:\n",
    "\n",
    "    menu_button.configure(menu=button_sub_menu)\n",
    "    \n",
    "<hr>\n",
    "\n",
    "En sonda, yine döngümüzü oluşturuyoruz:\n",
    "\n",
    "    window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a573d52",
   "metadata": {},
   "source": [
    "### 13-) Menus:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f52e2c0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "from tkinter import ttk\n",
    "\n",
    "# window setup\n",
    "window = tk.Tk()\n",
    "window.title(\"Menus\")\n",
    "window.geometry(\"600x400\")\n",
    "\n",
    "# menu\n",
    "menu = tk.Menu(window)\n",
    "\n",
    "# sub menu\n",
    "file_menu = tk.Menu(menu, tearoff=False) # tearoff false, prevents to create new window from the current menu\n",
    "file_menu.add_command(label=\"New\", command=lambda: print(\"New File!\"))\n",
    "file_menu.add_command(label=\"Open\", command=lambda: print(\"Open File!\"))\n",
    "file_menu.add_separator()\n",
    "menu.add_cascade(label=\"File\", menu=file_menu)\n",
    "\n",
    "extra_menu = tk.Menu(file_menu, tearoff=False)\n",
    "extra_menu.add_radiobutton(label=\"Yesn't\", command=lambda: print(\"Yesn't\"))\n",
    "extra_menu.add_radiobutton(label=\"Nope\", command=lambda: print(\"Nope\"))\n",
    "file_menu.add_cascade(label=\"File Options\", menu=extra_menu)\n",
    "\n",
    "# sub menu2\n",
    "help_menu = tk.Menu(menu, tearoff=False)\n",
    "help_menu.add_command(label=\"Help Entry\", command=lambda: print(help_check_str_value.get()))\n",
    "help_check_str_value = tk.StringVar()\n",
    "help_menu.add_checkbutton(label=\"Check\", onvalue=\"Help is on\", offvalue=\"Help is off\", \n",
    "                          variable=help_check_str_value)\n",
    "menu.add_cascade(label=\"Help\", menu=help_menu)\n",
    "\n",
    "window.configure(menu=menu) # instead pack and grid method we use configure method for the menu\n",
    "\n",
    "menu_button = ttk.Menubutton(window, text=\"Menu Button\")\n",
    "menu_button.pack()\n",
    "button_sub_menu = tk.Menu(menu_button, tearoff=False)\n",
    "button_sub_menu.add_command(label=\"An entry\", command=lambda: print(\"Yep...\"))\n",
    "button_sub_menu.add_checkbutton(label=\"Checking\")\n",
    "\n",
    "menu_button.configure(menu=button_sub_menu)\n",
    "\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67022c87",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "176d7212",
   "metadata": {},
   "source": [
    "<a id=\"windows\"></a>\n",
    "# 14-) Windows"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4608fbe6",
   "metadata": {},
   "source": [
    "**Önemli Not:** Bu örnekte çalıştırılan bazı metotlar pencerenin kapanmasına engel olacak. Böyle bir durumda **Kernel'i** durdurabilir veya yeniden başlatabilirsiniz.\n",
    "\n",
    "Oluşturduğumuz pencerelerde hep aynı birkaç metodu kullandık ama aslında bu pencereler çok daha fazla fonksiyona sahip. Yine pencere kurulumu yaparken bakalım:\n",
    "\n",
    "    import tkinter as tk\n",
    "    from tkinter import ttk\n",
    "\n",
    "    window = tk.Tk()\n",
    "    window.title(\"Windows\")\n",
    "    window.geometry(\"600x400+660+340\")\n",
    "    window.iconbitmap(\"placeholder.ico\")\n",
    "    \n",
    "**Not:** `iconbitmap()` metodu argüman olarak verdiğimiz .ico uzantılı dosyaları pencerenin sol üstündeki ikon resmi ile güncelliyor. Koyabileceğiniz örnek icon dosyası yoksa comment out edebilirsiniz.\n",
    "\n",
    "Normalde `geometry()` metodunda, sadece ilk iki değeri yazıyorduk. Sonradan aralarına '+' sembolünü ekleyerek girdiğimiz değerler, pencerenin açılırken ekranımızda koordinatı belirtmek amacı ile yazılıyor. '660+340' değeri, monitör çözünürlüğü 1920x1080 olan bir ekranda, uygulamamızı tam ortada açmaya yetiyor. Ama eğer kullanıcının monitör çözünürlüğü değişirse problem yaşanabilir. Bunu dinamik çalışacak bir hale getirmenin bir yolu var:\n",
    "\n",
    "    window_width = 640\n",
    "    window_height = 480\n",
    "    display_width = window.winfo_screenwidth()\n",
    "    display_height = window.winfo_screenheight()\n",
    "    left = int(display_width/2 - (window_width/2))\n",
    "    top = int(display_height/2 - (window_height/2))\n",
    "\n",
    "    window.geometry(f\"{window_width}x{window_height}+{left}+{top}\")\n",
    "    \n",
    "İlk iki integer olarak tanımladığımız değişken, bizim pencere boyutlarımız olsun. **display** ile başlayan değişkenlere girdiğimiz `window.winfo_screenwidth/height()` metotları, kullanıcının çözünürlük değerlerini bize döndürüyor. (Bu değerleri print edersek kendi çözünürlük değerimiz göreceğiz.) **left** ve **top** değişkenlerinin içerisine de başta oluşturduğumuz değerlerin yarısının farkını alıyoruz, bu sayede ortaya çıkan sayılar, ekranın orta noktası olacak. <br> Son satırda da `geometry()` metodunun içerisine bu değerleri giriyoruz.\n",
    "\n",
    "**Not:** Neden `geometry()` metodunda **f string** kullandık? Çünkü bu metot, değerleri string olarak bekliyor ve biz önceki değişkenlerimizi integer olarak hesaplamıştık.\n",
    "\n",
    "**Not:** Peki **left** ve **top** değişkenlerini neden **int** kullanarak tekrar integer olarak güncelledik? Çünkü bunu yapmazsak, bu ifadeler bölme işleminin etkisi ile **float** olarak kalacaktı ve tkinter bize hata döndürecekti.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Bu ayarlar dışında, pencerenin büyüyeceği veya küçüleceği maksimum ve minimum boyutları da tanımlayabiliyoruz:\n",
    "\n",
    "    window.minsize(200, 100)\n",
    "    window.maxsize(800, 600)\n",
    "    window.resizable(True, True)\n",
    "    \n",
    "İlk iki satır ilgili ifadeleri net açıklıyor. Üçüncü satırdaki `resizable()` metodu ise, pencerenin boyutunun değiştirilip, değiştirilemeyeceğini belirliyor.\n",
    "\n",
    "**Not:** Neden iki adet Boolean ifade bekliyor? Çünkü metot, en için ayrı boy için ayrı değer bekliyor:\n",
    "\n",
    "    window.resizable(width=True, height=False)\n",
    "\n",
    "<hr>\n",
    "\n",
    "Penceremizin ayrıca `attribute()` metodu da var:\n",
    "\n",
    "    window.attributes(\"-alpha\", 0.9)\n",
    "    window.attributes(\"-topmost\", True)\n",
    "\n",
    "    window.attributes(\"-disable\", True)\n",
    "    window.attributes(\"-fullscreen\", True)\n",
    "    \n",
    "(\"-alpha\", 0.9) ile belirttiğimiz, pencerenin şeffaflık seviyesini değiştiriyor. Sayıyı azalttığımızda daha da şeffaf oluyor. (\"-topmost\", True) ise True girildiğinde, penceremizin her zaman üstte kalmasını sağlıyor. <br> (\"-disable\", True) ifadesi True yapıldığında pencere üzerindeki her şeyin çalışmasını durduruyor. Özellikle gerekmediği sürece kullanılması pek uygun değil tabi. (\"-fullscreen\", True) ifadesi True yapıldığında ise penceremiz tam ekran oluyor. <br> **Not:** Tam ekran yapan metot, `maxsize()` metodu ile çakıştığı için, beraber çalıştırılamıyor.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Eğer, penceremizin başlığının(**title**) yazdığı kısmın görünmesini istemiyorsak bu metodu kullanabiliyoruz:\n",
    "\n",
    "    window.overrideredirect(True)\n",
    "    \n",
    "Peki bu metot True iken pencereyi nasıl kapatacağız? onun için de penceremize bir event atayabiliriz:\n",
    "\n",
    "    window.bind(\"<KeyPress>\", lambda event: window.quit())\n",
    "    \n",
    "<hr>\n",
    "\n",
    "Pencerenin büyüklüğünü fare imleci ile tutup çekerek ayarlayacağımız bir widget da ekleyebiliyoruz:\n",
    "\n",
    "    grip = ttk.Sizegrip(window)\n",
    "    grip.place(relx=1.0, rely=1.0, anchor=\"se\")\n",
    "    \n",
    "Bunun için `ttk.Sizegrip()` instance'ı kullanıyoruz. Yerleştirirken bu sefer `place()` metodunu kullandık. Bu metot diğerlerinden farklı olarak, pencere üzerinde net bir nokta bekliyor yerleştirmek için. **anchor=** metodu ise, pencere içerisinde seçilen bir yönde sabit kalmasını sağlıyor. Biz ekranın sağ altında kalmasını istediğimiz için; yani güneydoğu(**s**outh**e**ast) yönü, bu parametreye **\"se\"** değerini yazıyoruz.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Son olarak, her zaman olduğu gibi döngümüzü başlatıyoruz:\n",
    "\n",
    "    window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b03f3db",
   "metadata": {},
   "source": [
    "### 14-) Windows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f06951d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "from tkinter import ttk\n",
    "\n",
    "window = tk.Tk()\n",
    "window.title(\"Windows\")\n",
    "# window.geometry(\"600x400+660+340\") # last two added as pixel value for window coordination\n",
    "# window.iconbitmap(\"placeholder.ico\")\n",
    "\n",
    "window_width = 640\n",
    "window_height = 480\n",
    "display_width = window.winfo_screenwidth()\n",
    "display_height = window.winfo_screenheight()\n",
    "left = int(display_width/2 - (window_width/2))\n",
    "top = int(display_height/2 - (window_height/2))\n",
    "\n",
    "window.geometry(f\"{window_width}x{window_height}+{left}+{top}\")\n",
    "\n",
    "# window sizes\n",
    "window.minsize(200, 100)\n",
    "window.maxsize(800, 600)\n",
    "window.resizable(True, True)\n",
    "\n",
    "# screen attributes\n",
    "print(window.winfo_screenwidth()) # prints the user's screen resolution\n",
    "print(window.winfo_screenheight())\n",
    "\n",
    "# window attributes\n",
    "window.attributes(\"-alpha\", 0.9)\n",
    "window.attributes(\"-topmost\", True)\n",
    "\n",
    "# security event\n",
    "window.bind(\"<KeyPress>\", lambda event: window.quit())\n",
    "\n",
    "# window.attributes(\"-disable\", True)\n",
    "# window.attributes(\"-fullscreen\", True) # won't work with maxsize\n",
    "\n",
    "# title bar\n",
    "# window.overrideredirect(True)\n",
    "grip = ttk.Sizegrip(window)\n",
    "grip.place(relx=1.0, rely=1.0, anchor=\"se\")\n",
    "\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "510493e6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9329b336",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}