tkinter-workshop-KNTU.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e4174841",
   "metadata": {
    "direction": "ltr"
   },
   "source": [
    "<h1><center>Workshop on Python GUI with tkinter</center></h1>\n",
    "<h2><center>    May 28, 2023</center></h2>\n",
    "<h3><center>    K. N. Toosi University of Technology</center></h3>\n",
    "<h3><center>    Faculty of Aerospace Engineering</center></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13909515",
   "metadata": {},
   "source": [
    "## Table of Contents\n",
    "* [Introdction](#introduction)\n",
    "* [First Example](#first_example)\n",
    "* [Widgets](#Widgets)\n",
    "    - [Label](#label)\n",
    "    - [Button](#button)\n",
    "* [Geometry Managment](#geometry)\n",
    "    - [place](#place)\n",
    "    - [pack](#pack)\n",
    "    - [grid](#grid)\n",
    "* [Control Variables](#control)\n",
    "* [Check Button](#checkbutton)\n",
    "* [Radio Button](#radiobutton)\n",
    "* [Ttk Widgets](#ttk)\n",
    "    - [Combobox](#combobox)\n",
    "* [Project: Mini Calculator](#project)\n",
    "* [Menu](#menu)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7174b6b",
   "metadata": {},
   "source": [
    "<a name = 'introduction'></a>\n",
    "## Introduction\n",
    "\n",
    "Python provides various options for developing graphical user interfaces (GUIs). **Tkinter** is the Python interface to the <a href=\"https://en.wikipedia.org/wiki/Tk_(software)\" >Tk GUI</a> toolkit shipped with Python. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecc0da78",
   "metadata": {},
   "source": [
    "<a name=\"first_example\"></a>\n",
    "## First Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c243a7d8",
   "metadata": {
    "direction": "rtl"
   },
   "outputs": [],
   "source": [
    "import tkinter as tk # python 3.x\n",
    "## import Tkinter as tk # python 2.x\n",
    "\n",
    "root = tk.Tk()\n",
    "root.mainloop()\n"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "iVBORw0KGgoAAAANSUhEUgAAAMoAAADoCAYAAACuAXuVAAAFgElEQVR4nO3dwWpUeRrG4bNpZpY9VzB30DaIMFPauOmseqFDKXFshMM0VZUKFBywV+6HbIVZu/UKJLegi1q5G+IVCEJAEDf69SJDujNtrLcqZeoU/bzwrEKOf4I/qo6mOE3XdQV8XtN1XZnZ+ROKWTChmAUTilkwoZgFE4pZsLWG8uzZs/rHcFiz7uFarmfWl60llDdv3tRoNKrBjb/Vk+dv6+bNm+s5nVlPtpZQ2ratJ8/f1pPnb2vn4Khu3769puOZ9WMXDuW3kXxz/z+1c3BUd+/erdevX6/xmPal1jRNpG9rmqbm8/m5X5/P52s994VCeffuXd248fd68vxt/fW7n2rn4Ki+/+fPde/evRWPc1jjZlCPj1b8dlt6yV+mPoYyn8/rqz/9+ZOxfO5rq+5CoTx48OD01aRpmto5OKqrV68u8Wry/2EI5bK3raFUfTqILxFJ1QVCefXqVX377ZUzkewcHNXu7u4SVxHKprfNoVSdDeNLRVL1v1Datl36Gx8+fPi7V5PB7f26detWfI3xb98Hjw/rbCiHJ18fHy59Nsu37aFU/RrLl4qk6uRevJnNZkt/4507d85E8v2//1vXrl2rDx8+LHGV815RjurxoKlta2Qbb4yFkm02m60Wyu7u7plQrv0wrUePHi15lU+HMhg0NfD+61K27aFc1luvlUO5f/9+VdVpKNevX6+PHz8ueZVPhdLUYDDwluuSts2hXObN/MqhDAaD+vFfP1XTNPX113+pFy9erPDHn38zfzj2qnIZ29ZQLvufh1cO5eXLl3XlypVqmqYODg5WPsDh+Lyb+ZP7lGbweOVr2+Jt431V1eX/h+PKoVRVHR8f9/KHaLbuXSiU9+/fC8X+ELtQKFVVT58+XeNxzPq5C4di9keYUMyCCcUsmFDMggnFLJhQzIIJxSyYUMyCnYZyfHwMnEMoEBAKBIQCAaFAQCgQEAoEhAIBoUBAKBAQCgSEAgGhQEAoEBAKBIQCAaFAQCgQmM1mJ4+m2/RBoM/atj152OmmDwJ9dvpU4E0fBPpMKBAQCgSEAgGhQEAoEBAKBIQCAaFAQCgQEAoEhAIBoUCg6zq/Zg+LtG3rg1uwiE84QkAoEBAKBIQCAaFAQCgQEAoEhAIBoUBAKBAQCgSEAgGhQEAoEBAKBIQCAaFAQCgQEAoEhAIBoUBAKBAQCgSEAgGhQEAoEBAKBIQCAaFAQCgQEAoEhAIBoUBgNpt5NB0s0rath53CIp4KDAGhQEAoEBAKBIQCAaFAoOu6aobD4cYPAn02HA69osAi3npBQCgQEAoEhAIBoUCg6zq/Zg+LtG3rg1uwiE84QkAoEBAKBIQCAaFAQCgQEAoEhAIBoUBAKBAQCgSEAgGhQEAoEBAKBIQCAaFAQCgQEAoEhAIBoUBAKBAQCgSEAgGhQEAoEBAKBIQCAaFAQCgQEAoEhAIBoUBgNpt5NB0s0rath53CIp4KDAGhQEAoEBAKBIQCga7rqhkOhxs/CPTZcDj0igKLeOsFAaFAQCgQEAoEhAIBoUBAKBAQCgSEAgGhQEAoEBAKBIQCAaFAQCgQEAoEhAKBruuqGY1GGz8I9NloNBIKLDIajaoZj8cbPwj02Xg8FgosMh6Pq5lMJhs/CPTZZDIRCiwymUyq2dvb2/hBoM/29vaqmU6nGz8I9Nl0OhUKLCIUCAgFAtPptJr9/f2NHwT6bH9/XyiwiFAgIBQICAUCQoGAUCAgFAgIBQJCgYBQICAUCAgFAkKBgFAgIBQICAUCQoGAUCAgFAgIBQJCgYBQICAUCAgFAkKBgFAgIBQICAUCQoGAUCAgFAgIBQJCgYBQICAUCAgFAkKBgFAgIBQICAUCQoGAUCAgFAgIBQKnoQCf9wuwM58BGmTi7QAAAABJRU5ErkJggg=="
    }
   },
   "cell_type": "markdown",
   "id": "1a794bea",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7502374",
   "metadata": {},
   "source": [
    "<a name=\"widgets\"></a>\n",
    "## Widgets\n",
    "In general,  **Widget** is an element of Graphical User Interface (GUI) that displays/illustrates information or gives a way for the user to interact with the OS.  In **Tkinter** , **Widgets** are objects ; instances of classes that represent buttons, frames, and so on.  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "000b2980",
   "metadata": {},
   "source": [
    "Widgets\t| Description\n",
    ":--|:--\n",
    "**Label** |\tIt is used to display text or image on the screen\n",
    "**Button** |\tIt is used to add buttons to your application\n",
    "**Canvas** |\tIt is used to draw pictures and others layouts like texts, graphics etc.\n",
    "**ComboBox** |\tIt contains a down arrow to select from list of available options\n",
    "**CheckButton** |\tIt displays a number of options to the user as toggle buttons from which user can select any number of options.\n",
    "**RadiButton** |\tIt is used to implement one-of-many selection as it allows only one option to be selected\n",
    "**Entry** |\tIt is used to input single line text entry from user\n",
    "**Frame** |\tIt is used as container to hold and organize the widgets\n",
    "**Message** |\tIt works same as that of label and refers to multi-line and non-editable text\n",
    "**Scale** |\tIt is used to provide a graphical slider which allows to select any value from that scale\n",
    "**Scrollbar** |\tIt is used to scroll down the contents. It provides a slide controller.\n",
    "**SpinBox** |\tIt is allows user to select from given set of values\n",
    "**Text** |\tIt allows user to edit multiline text and format the way it has to be displayed\n",
    "**Menu** |\tIt is used to create all kinds of menu used by an application"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9adabb05",
   "metadata": {},
   "source": [
    "<a name=\"label\"></a>\n",
    "### Label Widget\n",
    "\n",
    "```python\n",
    "w = Label ( master, option, … )\n",
    "```\n",
    "\n",
    "Parameters:\n",
    "* **master**: This represents the parent window\n",
    "* **options**: Below is the list of most commonly used options for this widget. These options can be used as key-value pairs separated by commas:\n",
    "\n",
    "\n",
    "Option | Description \n",
    ":--|:--\n",
    "**anchor** | This options is used to control the positioning of the text if the widget has more space than required for the text. The default is anchor=CENTER, which centers the text in the available space.\n",
    "**bg**|This option is used to set the normal background clior displayed behind the label and indicator.\n",
    "**height**|This option is used to set the vertical dimension of the new frame.\n",
    "**width**| Width of the label in characters (not pixels!). If this option is not set, the label will be sized to fit its contents.\n",
    "**bd**|This option is used to set the size of the border around the indicator. Default bd value is set on 2 pixels.\n",
    "**font**|If you are displaying text in the label (with the text or textvariable option), the font option is used to specify in what font that text in the label will be displayed.\n",
    "**cursor**|It is used to specify what cursor to show when the mouse is moved over the label. The default is to use the standard cursor.\n",
    "**textvariable**| As the name suggests it is associated with a Tkinter variable (usually a StringVar) with the label. If the variable is changed, the label text is updated.\n",
    "**bitmap**|It is used to set the bitmap to the graphical object specified so that, the label can represent the graphics instead of text.\n",
    "**fg**|The label clior, used for text and bitmap labels. The default is system specific. If you are displaying a bitmap, this is the clior that will appear at the position of the 1-bits in the bitmap.\n",
    "**image**| This option is used to display a static image in the label widget.\n",
    "**padx**|This option is used to add extra spaces between left and right of the text within the label.The default value for this option is 1.\n",
    "**pady**|This option is used to add extra spaces between top and bottom of the text within the label.The default value for this option is 1.\n",
    "**justify**|This option is used to define how to align multiple lines of text. Use LEFT, RIGHT, or CENTER as its values. Note that to position the text inside the widget, use the anchor option. Default value for justify is CENTER.\n",
    "**relief**| This option is used to specify appearance of a decorative border around the label. The default value for this option is FLAT.\n",
    "**underline**|This\n",
    "**wraplength**|Instead of having only one line as the label text it can be broken itno to the number of lines where each line has the number of characters specified to this option.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f62a69b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "\n",
    "root = tk.Tk()\n",
    "# giving title to the main window\n",
    "root.title(\"First_Program\")\n",
    "root.minsize(400,200)\n",
    "\n",
    "# Label is what output will be \n",
    "# show on the window\n",
    "label = tk.Label(root,text=\"Hello World!\")\n",
    "label.pack()\n",
    "  \n",
    "# calling mainloop method which is used\n",
    "# when your application is ready to run\n",
    "# and it tells the code to keep displaying \n",
    "root.mainloop()"
   ]
  },
  {
   "attachments": {
    "image-2.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "6bcd8194",
   "metadata": {},
   "source": [
    "![image-2.png](attachment:image-2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acf65e5f",
   "metadata": {},
   "source": [
    "<a name=\"button\"></a>\n",
    "### Button Widget\n",
    "\n",
    "```python\n",
    "w = Button ( master, option=value, ... )\n",
    "```\n",
    "\n",
    "Option | Description \n",
    ":--|:--\n",
    "**activebackground**| Background color when the button is under the cursor.\n",
    "**activeforeground**|Foreground color when the button is under the cursor.\n",
    "**bd**|Border width in pixels. Default is 2.\n",
    "**bg**|Normal background color.\n",
    "**command**|Function or method to be called when the button is clicked.\n",
    "**fg**|Normal foreground (text) color.\n",
    "**font**|Text font to be used for the button's label.\n",
    "**height**|Height of the button in text lines (for textual buttons) or pixels (for images).\n",
    "**highlightcolor**|The color of the focus highlight when the widget has focus.\n",
    "**image**|Image to be displayed on the button (instead of text).\n",
    "**justify**|How to show multiple text lines: LEFT to left-justify each line; CENTER to center them; or RIGHT to right-justify.\n",
    "**padx**|Additional padding left and right of the text.\n",
    "**pady**|Additional padding above and below the text.\n",
    "**relief**|Relief specifies the type of the border. Some of the values are SUNKEN, RAISED, GROOVE, and RIDGE.\n",
    "**state**|Set this option to DISABLED to gray out the button and make it unresponsive. Has the value ACTIVE when the mouse is over it. Default is NORMAL.\n",
    "**underline**|Default is -1, meaning that no character of the text on the button will be underlined. If nonnegative, the corresponding text character will be underlined.\n",
    "**width**|Width of the button in letters (if displaying text) or pixels (if displaying an image).\n",
    "**wraplength**|If this value is set to a positive number, the text lines will be wrapped to fit within this length.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "7ee24784",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "import webbrowser\n",
    "# create root window\n",
    "root = tk.Tk()\n",
    "\n",
    "# setting the window size in pixel \n",
    "root.geometry('200x200')\n",
    "\n",
    "# frame inside root window\n",
    "frame = tk.Frame(root)\n",
    "\n",
    "# geometry method\n",
    "frame.pack()\n",
    "\n",
    "# button inside frame which is\n",
    "# inside root\n",
    "button = tk.Button(frame, text ='KNTU',\n",
    "            command=lambda: webbrowser.open_new_tab(\"https:\\\\kntu.ac.ir\"))\n",
    "button.pack()\n",
    "\n",
    "# Tkinter event loop\n",
    "root.mainloop()\n"
   ]
  },
  {
   "attachments": {
    "image-5.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "9458b041",
   "metadata": {},
   "source": [
    "![image-5.png](attachment:image-5.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de661099",
   "metadata": {},
   "source": [
    "<a name=\"geometry\"></a>\n",
    "## Geometry Management\n",
    "\n",
    "_Creating a new widget doesn’t mean that it will appear on the screen._ To display it, we need to call a special method: either **grid**, **pack** (example above), or **place**. \n",
    "\n",
    "\n",
    "Method|\tDescription\n",
    ":---|:---\n",
    "**pack()** |\tThe Pack geometry manager packs widgets in rows or columns. \n",
    "**grid()** |\tThe Grid geometry manager puts the widgets in a 2-dimensional table.The master widget is split into a number of rows and columns, and each “cell” in the resulting table can hold a widget.\n",
    "**place()** |\tThe Place geometry manager is the simplest of the three general geometry managers provided in Tkinter. It allows you explicitly set the position and size of a window, either in absolute terms, or relative to another window."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f6ace55",
   "metadata": {},
   "source": [
    "<a name=\"place\"></a>\n",
    "### place method\n",
    "```python\n",
    "widget.place( place_options )\n",
    "```\n",
    "\n",
    "\n",
    "Option| Desceription\n",
    ":--|:--\n",
    "**anchor**| The exact spot of widget other options refer to: may be N, E, S, W, NE, NW, SE, or SW, compass directions indicating the corners and sides of widget; default is NW (the upper left corner of widget)\n",
    "**bordermode**| INSIDE (the default) to indicate that other options refer to the parent's inside (ignoring the parent's border); OUTSIDE otherwise.\n",
    "**height**, **width**| Height and width in pixels.\n",
    "**relheight**, **relwidth**| Height and width as a float between 0.0 and 1.0, as a fraction of the height and width of the parent widget.\n",
    "**relx**, **rely**| Horizontal and vertical offset as a float between 0.0 and 1.0, as a fraction of the height and width of the parent widget.\n",
    "**x**, **y**| Horizontal and vertical offset in pixels.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d52a3af1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "\n",
    "top = tk.Tk()\n",
    "top.geometry(\"450x300\")\n",
    "\n",
    "# the label for user_name\n",
    "user_name = tk.Label(top,text = \"Username\").place(x=40,y=60)\n",
    "\n",
    "# the label for user_password\n",
    "user_password = tk.Label(top,text = \"Password\").place(x=40,y=100)\n",
    "\n",
    "# Entry for username\n",
    "user_name_input_area = tk.Entry(top,width = 30).place(x=110,y=60)\n",
    "\n",
    "# Entry for password\n",
    "user_password_entry_area = tk.Entry(top,width = 30,show='*').place(x = 110,\n",
    "                                                                   y = 100)\n",
    "\n",
    "# submit button\n",
    "submit_button = tk.Button(top,text = \"Submit\").place(x = 40,y = 130)\n",
    "\n",
    "top.mainloop()\n"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "eadd6e13",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58a4a885",
   "metadata": {},
   "source": [
    "<a name=\"pack\"></a>\n",
    "### pack method\n",
    "\n",
    "```python\n",
    "widget.pack( pack_options )\n",
    "```\n",
    "\n",
    "Option| Desceription\n",
    ":--|:--\n",
    "**after**| widget - pack it after you have packed widget\n",
    "**anchor**| NSEW (or subset) - position widget according to given direction\n",
    "**before**| widget - pack it before you will pack widget\n",
    "**expand**| bool - expand widget if parent size grows\n",
    "**fill**| NONE or X or Y or BOTH - fill widget if widget grows\n",
    "**in**|master - use master to contain this widget\n",
    "**ipadx**|amount - add internal padding in x direction\n",
    "**ipady**|amount - add internal padding in y direction\n",
    "**padx**|amount - add padding in x direction\n",
    "**pady**|amount - add padding in y direction\n",
    "**side**|TOP or BOTTOM or LEFT or RIGHT -  where to add this widget.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "50c97762",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "\n",
    "top = tk.Tk()\n",
    "top.geometry(\"450x300\")\n",
    "top_frame = tk.Frame(top)\n",
    "top_frame.pack(side=tk.TOP)\n",
    "middle_frame = tk.Frame(top)\n",
    "middle_frame.pack(side=tk.TOP)\n",
    "bottom_frame = tk.Frame(top)\n",
    "bottom_frame.pack(side=tk.BOTTOM)\n",
    "\n",
    "# the label for user_name\n",
    "user_name = tk.Label(top_frame,text = \"Username\").pack(side=tk.LEFT)\n",
    "\n",
    "# the label for user_password\n",
    "user_password = tk.Label(middle_frame,text = \"Password\").pack(side=tk.LEFT)\n",
    "\n",
    "# Entry for username\n",
    "user_name_input_area = tk.Entry(top_frame,width = 30).pack(side=tk.LEFT)\n",
    "\n",
    "# Entry for password\n",
    "user_password_entry_area = tk.Entry(middle_frame,width = 30,show='*').pack(side=tk.LEFT)\n",
    "\n",
    "# submit button\n",
    "submit_button = tk.Button(bottom_frame,text = \"Submit\").pack(side=tk.BOTTOM)\n",
    "\n",
    "top.mainloop()"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "1f6059f1",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "080acc41",
   "metadata": {},
   "source": [
    "<a name=\"grid\"></a>\n",
    "### grid method\n",
    "\n",
    "```python\n",
    "widget.grid( grid_options )\n",
    "```\n",
    "\n",
    "Option| Desceription\n",
    ":--|:--\n",
    "    **column**| The column to put widget in; default 0 (leftmost column).\n",
    "**columnspan**| How many columns widgetoccupies; default 1.\n",
    "**ipadx, ipady**| How many pixels to pad widget, horizontally and vertically, inside widget's borders.\n",
    "**padx, pady**| How many pixels to pad widget, horizontally and vertically, outside v's borders.\n",
    "**row**| The row to put widget in; default the first row that is still empty.\n",
    "**rowspan**| How many rowswidget occupies; default 1.\n",
    "**sticky**| What to do if the cell is larger than widget. By default, with sticky='', widget is centered in its cell. sticky may be the string concatenation of zero or more of N, E, S, W, NE, NW, SE, and SW, compass directions indicating the sides and corners of the cell to which widget sticks.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "97a2e7a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "\n",
    "top = tk.Tk()\n",
    "top.geometry(\"450x300\")\n",
    "\n",
    "frame = tk.Frame(top)\n",
    "frame.pack()\n",
    "\n",
    "# the label for user_name\n",
    "user_name = tk.Label(frame,text = \"Username\").grid(row=0,column=0)\n",
    "\n",
    "# the label for user_password\n",
    "user_password = tk.Label(frame,text = \"Password\").grid(row=1,column=0)\n",
    "\n",
    "# Entry for username\n",
    "user_name_input_area = tk.Entry(frame,width = 30).grid(row=0,column=1,\n",
    "                                                       sticky=\"EW\")\n",
    "\n",
    "# Entry for password\n",
    "user_password_entry_area = tk.Entry(frame,width = 30,show='*').grid(row=1,column=1)\n",
    "\n",
    "# submit button\n",
    "submit_button = tk.Button(frame,text = \"Submit\").grid(row=2,column=1,\n",
    "                                                      sticky='E')\n",
    "\n",
    "top.mainloop()"
   ]
  },
  {
   "attachments": {
    "image-2.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "97775c73",
   "metadata": {},
   "source": [
    "![image-2.png](attachment:image-2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af048c02",
   "metadata": {},
   "source": [
    "<a name=\"control\"></a>\n",
    "## Control variables\n",
    "A Tkinter control variable is a special object that acts like a regular Python variable in that it is a container for a value, such as a number or string.\n",
    "\n",
    " One special quality of a control variable is that it can be shared by a number of different widgets, and the control variable can remember all the widgets that are currently sharing it. This means, in particular, that if your program stores a value v into a control variable c with its c.set(v) method, any widgets that are linked to that control variable are automatically updated on the screen.\n",
    "\n",
    "Tkinter uses control variables for a number of important functions, for example:\n",
    "\n",
    "* Checkbuttons use a control variable to hold the current state of the checkbutton (on or off).\n",
    "\n",
    "* A single control variable is shared by a group of radiobuttons and can be used to tell which one of them is currently set. When the user clicks on one radiobutton in a group, the sharing of this control variable is the mechanism by which Tkinter groups radiobuttons so that when you set one, any other set radiobutton in the group is cleared.\n",
    "\n",
    "* Control variables hold text string for several applications. Normally the text displayed in an Entry widget is linked to a control variable. In several other controls, it is possible to use a string-valued control variable to hold text such as the labels of checkbuttons and radiobuttons and the content of Label widgets.\n",
    "\n",
    "* For example, you could link an Entry widget to a Label widget so that when the user changes the text in the entry and presses the Enter key, the label is automatically updated to show that same text. \n",
    "\n",
    "To get a control variable, use one of these class constructors, depending on what type of values you need to store in it: \n",
    "```python\n",
    "v = tk.DoubleVar()   # Holds a float; default value 0.0\n",
    "v = tk.IntVar()      # Holds an int; default value 0\n",
    "v = tk.StringVar()   # Holds a string; default value ''\n",
    "```\n",
    "All control variables have these two methods: \n",
    "\n",
    "method| Desceription\n",
    ":--|:--\n",
    ".get()|    Returns the current value of the variable. \n",
    ".set(value)| Changes the current value of the variable. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2de99a4",
   "metadata": {},
   "source": [
    "### Add fuctionality for submit button\n",
    "We want to design if the user presses submit button in previous example, the credentials will be printed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "e5fd068e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Username: farrokh\n",
      "Password: mojtaba\n",
      "Username: farrokh\n",
      "Password: 123456\n"
     ]
    }
   ],
   "source": [
    "import tkinter as tk\n",
    "\n",
    "top = tk.Tk()\n",
    "top.geometry(\"450x300\")\n",
    "\n",
    "#control variable\n",
    "\n",
    "user_var = tk.StringVar()\n",
    "pass_var = tk.StringVar()\n",
    "\n",
    "\n",
    "frame = tk.Frame(top)\n",
    "frame.pack()\n",
    "\n",
    "# the label for user_name\n",
    "user_name = tk.Label(frame,text = \"Username\").grid(row=0,column=0)\n",
    "\n",
    "# the label for user_password\n",
    "user_password = tk.Label(frame,text = \"Password\").grid(row=1,column=0)\n",
    "\n",
    "# Entry for username\n",
    "user_name_input_area = tk.Entry(frame,textvariable = user_var\n",
    "                                , width = 30).grid(row=0,\n",
    "                                                   column=1,sticky=\"EW\")\n",
    "\n",
    "# Entry for password\n",
    "user_password_entry_area = tk.Entry(frame,textvariable = pass_var,\n",
    "                                    width = 30,show='*').grid(row=1,\n",
    "                                                              column=1)\n",
    "\n",
    "# print credentils function\n",
    "def print_credentials():\n",
    "    print(\"Username:\", user_var.get())\n",
    "    print(\"Password:\", pass_var.get())\n",
    "\n",
    "\n",
    "# submit button\n",
    "submit_button = tk.Button(frame,text = \"Submit\",\n",
    "                          command =print_credentials ).grid(row=2,\n",
    "                                                            column=1,\n",
    "                                                            sticky='E')\n",
    "\n",
    "top.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "879cb489",
   "metadata": {},
   "source": [
    "<a name=\"checkbutton\"></a>\n",
    "## Checkbutton Widget\n",
    "```python\n",
    "w = Checkbutton ( master, option, ... )\n",
    "```\n",
    "\n",
    "Option | Description \n",
    ":--|:--\n",
    "**height**|The number of lines of text on the checkbutton. Default is 1.\n",
    "**offvalue**|Normally, a checkbutton's associated control variable will be set to 0 when it is cleared (off). You can supply an alternate value for the off state by setting offvalue to that value.\n",
    "**onvalue**| Normally, a checkbutton's associated control variable will be set to 1 when it is set (on). You can supply an alternate value for the on state by setting onvalue to that value.\n",
    "**text**|The label displayed next to the checkbutton. Use newlines (\"\\n\") to display multiple lines of text.\n",
    "**variable**|The control variable that tracks the current state of the checkbutton. Normally this variable is an IntVar, and 0 means cleared and 1 means set, but see the offvalue and onvalue options above.\n",
    "**width**|The default width of a checkbutton is determined by the size of the displayed image or text. You can set this option to a number of characters and the checkbutton will always have room for that many characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "3c3682d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The selected courses are:\n",
      "Basic Python\n",
      "Python for ABAQUS\n",
      "The selected courses are:\n",
      "Applied Python\n"
     ]
    }
   ],
   "source": [
    "import tkinter as tk\n",
    "root = tk.Tk()\n",
    "root.geometry(\"300x200\")\n",
    "\n",
    "w = tk.Label(root, text ='Courses', font = \"50\")\n",
    "w.pack()\n",
    "\n",
    "Checkbutton1 = tk.IntVar()\n",
    "Checkbutton2 = tk.IntVar()\n",
    "Checkbutton3 = tk.IntVar()\n",
    "\n",
    "Button1 = tk.Checkbutton(root, text = \"Basic Python\",\n",
    "\t\t\t\t\tvariable = Checkbutton1,\n",
    "\t\t\t\t\tonvalue = 1,\n",
    "\t\t\t\t\toffvalue = 0,\n",
    "\t\t\t\t\theight = 2,\n",
    "\t\t\t\t\twidth = 30)\n",
    "\n",
    "Button2 = tk.Checkbutton(root, text = \"Applied Python\",\n",
    "\t\t\t\t\tvariable = Checkbutton2,\n",
    "\t\t\t\t\tonvalue = 1,\n",
    "\t\t\t\t\toffvalue = 0,\n",
    "\t\t\t\t\theight = 2,\n",
    "\t\t\t\t\twidth = 30)\n",
    "\n",
    "Button3 = tk.Checkbutton(root, text = \"Python for ABAQUS\",\n",
    "\t\t\t\t\tvariable = Checkbutton3,\n",
    "\t\t\t\t\tonvalue = 1,\n",
    "\t\t\t\t\toffvalue = 0,\n",
    "\t\t\t\t\theight = 2,\n",
    "\t\t\t\t\twidth = 30)\n",
    "\t\n",
    "Button1.pack()\n",
    "Button2.pack()\n",
    "Button3.pack()\n",
    "\n",
    "def print_selected():\n",
    "    print(\"The selected courses are:\")\n",
    "    if (Checkbutton1.get()): print(\"Basic Python\")\n",
    "    if (Checkbutton2.get()): print(\"Applied Python\")\n",
    "    if (Checkbutton3.get()): print(\"Python for ABAQUS\")\n",
    "\n",
    "tk.Button(root, text=\"submit\", command=print_selected).pack()\n",
    "root.mainloop()\n"
   ]
  },
  {
   "attachments": {
    "image-2.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "2dd72b22",
   "metadata": {},
   "source": [
    "![image-2.png](attachment:image-2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac98ad14",
   "metadata": {},
   "source": [
    "<a name=\"radiobutton\"></a>\n",
    "## Radiobutton Widget\n",
    "\n",
    "```python\n",
    "w = Radiobutton ( master, option, ...  )\n",
    "```\n",
    "\n",
    "Option | Description \n",
    ":--|:--\n",
    "**command**|A procedure to be called every time the user changes the state of this radiobutton.\n",
    "**text**|The label displayed next to the radiobutton. Use newlines (\"\\n\") to display multiple lines of text.\n",
    "**value**| When a radiobutton is turned on by the user, its control variable is set to its current value option. If the control variable is an IntVar, give each radiobutton in the group a different integer value option. If the control variable is a StringVar, give each radiobutton a different string value option.\n",
    "**variable**|The control variable that this radiobutton shares with the other radiobuttons in the group. This can be either an IntVar or a StringVar.\n",
    "...|..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "3d363aba",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "\n",
    "root = tk.Tk()\n",
    "root.geometry('175x100')\n",
    "var = tk.IntVar()\n",
    "\n",
    "def sel():\n",
    "   selection = \"You selected the option \" + str(var.get())\n",
    "   #label.config(text = selection)\n",
    "   label['text'] = selection \n",
    "\n",
    "R1 = tk.Radiobutton(root, text=\"Option 1\", variable=var, value=1,\n",
    "                  command=sel)\n",
    "R1.pack(anchor=tk.W )\n",
    "\n",
    "R2 = tk.Radiobutton(root, text=\"Option 2\", variable=var, value=2,\n",
    "                  command=sel)\n",
    "R2.pack( anchor = tk.W )\n",
    "\n",
    "R3 = tk.Radiobutton(root, text=\"Option 3\", variable=var, value=3,\n",
    "                  command=sel)\n",
    "R3.pack( anchor = tk.W)\n",
    "\n",
    "label = tk.Label(root)\n",
    "label.pack()\n",
    "root.mainloop()"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "00126143",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b4b8a3c",
   "metadata": {},
   "source": [
    "<a name=\"ttk\"></a>\n",
    "## Ttk Widgets\n",
    "\n",
    "Ttk comes with 18 widgets, twelve of which already existed in tkinter: Button, Checkbutton, Entry, Frame, Label, LabelFrame, Menubutton, PanedWindow, Radiobutton, Scale, Scrollbar, and Spinbox. The other six are new: **Combobox**, **Notebook**, **Progressbar**, **Separator**, **Sizegrip** and **Treeview**. And all them are subclasses of Widget.\n",
    "\n",
    "Using the Ttk widgets gives the application an improved look and feel.\n",
    "\n",
    "#### Using Ttk\n",
    "To start using Ttk, import its module:\n",
    "\n",
    "```python\n",
    "from tkinter import ttk\n",
    "```\n",
    "\n",
    "To override the basic Tk widgets, the import should follow the Tk import:\n",
    "```python\n",
    "from tkinter import *\n",
    "from tkinter.ttk import *\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8df67159",
   "metadata": {},
   "source": [
    "<a name=\"combobox\"></a>\n",
    "### Combobox\n",
    "\n",
    "This widget accepts the following specific options:\n",
    "\n",
    "Option| Desceription\n",
    ":--|:-- \n",
    "**exportselection**|Boolean value. If set, the widget selection is linked to the Window Manager selection (which can be returned by invoking Misc.selection_get, for example).\n",
    "**justify**| Specifies how the text is aligned within the widget. One of \"left\", \"center\", or \"right\".\n",
    "**height**|    Specifies the height of the pop-down listbox, in rows.\n",
    "**postcommand**| A script (possibly registered with Misc.register) that is called immediately before displaying the values. It may specify which values to display.\n",
    "**state**| One of \"normal\", \"readonly\", or \"disabled\". In the \"readonly\" state, the value may not be edited directly, and the user can only selection of the values from the dropdown list. In the \"normal\" state, the text field is directly editable. In the \"disabled\" state, no interaction is possible.\n",
    "**textvariable**| Specifies a name whose value is linked to the widget value. Whenever the value associated with that name changes, the widget value is updated, and vice versa. See tkinter.StringVar.\n",
    "**values**|Specifies the list of values to display in the drop-down listbox.\n",
    "**width**| Specifies an integer value indicating the desired width of the entry window, in average-size characters of the widget’s font.\n",
    "\n",
    "Available methods are:\n",
    "\n",
    "method| Desceription\n",
    ":--|:--\n",
    "**current(newindex=None)**|  If newindex is specified, sets the combobox value to the element position newindex. Otherwise, returns the index of the current value or -1 if the current value is not in the values list.\n",
    "**get()**| Returns the current value of the combobox.\n",
    "**set(value)**|Sets the value of the combobox to value.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "de3a90ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "from tkinter import ttk\n",
    "from tkinter.messagebox import showinfo\n",
    "\n",
    "root = tk.Tk()\n",
    "root.geometry('300x250')\n",
    "root.resizable(False, False)\n",
    "root.title('Combobox Widget')\n",
    "\n",
    "\n",
    "def month_changed(event):\n",
    "    msg = f'You selected {month_cb.get()}!'\n",
    "    showinfo(title='Result', message=msg)\n",
    "\n",
    "\n",
    "# month of year\n",
    "months = ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',\n",
    "        'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec')\n",
    "\n",
    "label = ttk.Label(text=\"Please select a month:\")\n",
    "label.pack(fill='x', padx=5, pady=5)\n",
    "\n",
    "# create a combobox\n",
    "selected_month = tk.StringVar()\n",
    "\n",
    "month_cb = ttk.Combobox(root, textvariable=selected_month)\n",
    "month_cb['values'] = months\n",
    "month_cb['state'] = 'readonly'  # normal\n",
    "month_cb.pack(fill='x', padx=5, pady=5)\n",
    "\n",
    "month_cb.bind('<<ComboboxSelected>>', month_changed)\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "b3a9161c",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "015251a6",
   "metadata": {},
   "source": [
    "<a name=\"project\"></a>\n",
    "## Project: Mini Calculator"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "1852828a",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c072948d",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Exception in Tkinter callback\n",
      "ValueError: Error from parse_expr with transformed code: \"Symbol ('x' )**Integer (2 )-Integer (1 )=Integer (0 )\"\n",
      "\n",
      "The above exception was the direct cause of the following exception:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\sympy\\core\\sympify.py\", line 495, in sympify\n",
      "    expr = parse_expr(a, local_dict=locals, transformations=transformations, evaluate=evaluate)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\sympy\\parsing\\sympy_parser.py\", line 1105, in parse_expr\n",
      "    raise e from ValueError(f\"Error from parse_expr with transformed code: {code!r}\")\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\sympy\\parsing\\sympy_parser.py\", line 1096, in parse_expr\n",
      "    rv = eval_expr(code, local_dict, global_dict)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\sympy\\parsing\\sympy_parser.py\", line 915, in eval_expr\n",
      "    expr = eval(\n",
      "  File \"<string>\", line 1\n",
      "    Symbol ('x' )**Integer (2 )-Integer (1 )=Integer (0 )\n",
      "                                            ^\n",
      "SyntaxError: invalid syntax\n",
      "\n",
      "During handling of the above exception, another exception occurred:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\tkinter\\__init__.py\", line 1892, in __call__\n",
      "    return self.func(*args)\n",
      "  File \"C:\\Users\\mojta\\AppData\\Local\\Temp\\ipykernel_3936\\3373549945.py\", line 28, in solve_calc\n",
      "    res = solve(sympify(str_var.get()))\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\sympy\\core\\sympify.py\", line 497, in sympify\n",
      "    raise SympifyError('could not parse %r' % a, exc)\n",
      "sympy.core.sympify.SympifyError: Sympify of expression 'could not parse 'x**2-1=0'' failed, because of exception being raised:\n",
      "SyntaxError: invalid syntax (<string>, line 1)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import tkinter as tk\n",
    "from sympy import *\n",
    "x = symbols('x')\n",
    "\n",
    "root = tk.Tk()\n",
    "root.minsize(300,100)\n",
    "root.title(\"Mini Calculator\")\n",
    "\n",
    "\n",
    "str_var = tk.StringVar()\n",
    "\n",
    "def calc():\n",
    "    entry_str = str_var.get()\n",
    "    try:\n",
    "        res = N(sympify(entry_str))\n",
    "        str_var.set(res)\n",
    "    except:\n",
    "        tk.messagebox.showerror(title=\"Entry Error\", \n",
    "                                message=\"Entry Error, Try again!\")\n",
    "def calc_diff():\n",
    "    res=diff(sympify(str_var.get()),x)\n",
    "    str_var.set(res)\n",
    "def calc_int():\n",
    "    res=integrate(sympify(str_var.get()),x)\n",
    "    str_var.set(res)\n",
    "    \n",
    "def solve_calc():\n",
    "    res = solve(sympify(str_var.get()))\n",
    "    str_var.set(str(res))\n",
    "def plot_func():\n",
    "    plot(sympify(str_var.get()))\n",
    "    \n",
    "def clear_entry():\n",
    "    str_var.set('')\n",
    "\n",
    "label = tk.Label(root, text='Enter your expression in the box:',\n",
    "                 font=('Arial',12),fg='blue')\n",
    "label.pack()\n",
    "textbox = tk.Entry(root,textvariable = str_var,font=('Arial',12))\n",
    "textbox.pack(fill=tk.X)\n",
    "\n",
    "calc_btn = tk.Button(root,text='=',command=calc,font=('Arial',12))\n",
    "\n",
    "diff_btn = tk.Button(root,text='diff',command=calc_diff,font=('Arial',12))\n",
    "\n",
    "int_btn = tk.Button(root,text='Int',command=calc_int,font=('Arial',12))\n",
    "\n",
    "sympy_btn = tk.Button(root,text='Solve', command=solve_calc,\n",
    "                      font=('Arial',12))\n",
    "\n",
    "plot_btn = tk.Button(root,text='Plot', command=plot_func, font=('Arial',12))\n",
    "\n",
    "reset_btn = tk.Button(root,text='Clear Entry', width=10,command=clear_entry,\n",
    "                      font=('Arial',12))\n",
    "\n",
    "calc_btn.pack(side=tk.LEFT,padx=10)\n",
    "diff_btn.pack(sid=tk.LEFT)\n",
    "int_btn.pack(side=tk.LEFT,padx=10)\n",
    "sympy_btn.pack(side=tk.LEFT)\n",
    "plot_btn.pack(side=tk.LEFT,padx=10)\n",
    "reset_btn.pack(side=tk.LEFT)\n",
    "\n",
    "\n",
    "root.mainloop()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82068c55",
   "metadata": {},
   "source": [
    "<a name=\"menu\"></a>\n",
    "## Menu\n",
    "\n",
    "```python\n",
    "w = Menu ( master, option, ... )\n",
    "```\n",
    "Option| Desceription\n",
    ":--|:-- \n",
    "**activebackground**|The background color that will appear on a choice when it is under the mouse.\n",
    "**activeborderwidth**|Specifies the width of a border drawn around a choice when it is under the mouse. Default is 1 pixel.\n",
    "**activeforeground**|The foreground color that will appear on a choice when it is under the mouse.\n",
    "**bg**|The background color for choices not under the mouse.\n",
    "**bd**|The width of the border around all the choices. Default is 1.\n",
    "**cursor**|The cursor that appears when the mouse is over the choices, but only when the menu has been torn off.\n",
    "**disabledforeground**|The color of the text for items whose state is DISABLED.\n",
    "**font**|The default font for textual choices.\n",
    "**fg**|The foreground color used for choices not under the mouse.\n",
    "**postcommand**|You can set this option to a procedure, and that procedure will be called every time someone brings up this menu.\n",
    "**relief**|The default 3-D effect for menus is relief=RAISED.\n",
    "**image**|To display an image on this menubutton. \t\n",
    "**selectcolor**|Specifies the color displayed in checkbuttons and radiobuttons when they are selected.\n",
    "**tearoff**|Normally, a menu can be torn off, the first position (position 0) in the list of choices is occupied by the tear-off element, and the additional choices are added starting at position 1. If you set tearoff=0, the menu will not have a tear-off feature, and choices will be added starting at position 0.\n",
    "**title**|Normally, the title of a tear-off menu window will be the same as the text of the menubutton or cascade that lead to this menu. If you want to change the title of that window, set the title option to that string.\n",
    "\n",
    "#### Methods\n",
    "\n",
    "method| Desceription\n",
    ":--|:-- \t\n",
    "**add_command (options)**|Adds a menu item to the menu.\n",
    "**add_radiobutton( options )**|Creates a radio button menu item.\n",
    "**add_checkbutton( options )**|Creates a check button menu item.\n",
    "**add_cascade(options)**|Creates a new hierarchical menu by associating a given menu to a parent menu\n",
    "**add_separator()**|Adds a separator line to the menu.\n",
    "**add( type, options )**|Adds a specific type of menu item to the menu.\n",
    "**delete( startindex [, endindex ])**|Deletes the menu items ranging from startindex to endindex.\n",
    "**entryconfig( index, options )**|Allows you to modify a menu item, which is identified by the index, and change its options.\n",
    "**index(item)**|Returns the index number of the given menu item label.\n",
    "**insert_separator ( index )**|Insert a new separator at the position specified by index.\n",
    "**invoke ( index )**|Calls the command callback associated with the choice at position index. If a checkbutton, its state is toggled between set and cleared; if a radiobutton, that choice is set.\n",
    "**type ( index )**|Returns the type of the choice specified by index: either \"cascade\", \"checkbutton\", \"command\", \"radiobutton\", \"separator\", or \"tearoff\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "da5bcd9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "\n",
    "def donothing():\n",
    "   filewin = Toplevel(root)\n",
    "   button = Button(filewin, text=\"Do nothing button\")\n",
    "   button.pack()\n",
    "   \n",
    "root = Tk()\n",
    "menubar = Menu(root)\n",
    "filemenu = Menu(menubar, tearoff=0)\n",
    "filemenu.add_command(label=\"New\", command=donothing)\n",
    "filemenu.add_command(label=\"Open\", command=donothing)\n",
    "filemenu.add_command(label=\"Save\", command=donothing)\n",
    "filemenu.add_command(label=\"Save as...\", command=donothing)\n",
    "filemenu.add_command(label=\"Close\", command=donothing)\n",
    "\n",
    "filemenu.add_separator()\n",
    "\n",
    "filemenu.add_command(label=\"Exit\", command=root.quit)\n",
    "menubar.add_cascade(label=\"File\", menu=filemenu)\n",
    "editmenu = Menu(menubar, tearoff=0)\n",
    "editmenu.add_command(label=\"Undo\", command=donothing)\n",
    "\n",
    "editmenu.add_separator()\n",
    "\n",
    "editmenu.add_command(label=\"Cut\", command=donothing)\n",
    "editmenu.add_command(label=\"Copy\", command=donothing)\n",
    "editmenu.add_command(label=\"Paste\", command=donothing)\n",
    "editmenu.add_command(label=\"Delete\", command=donothing)\n",
    "editmenu.add_command(label=\"Select All\", command=donothing)\n",
    "\n",
    "menubar.add_cascade(label=\"Edit\", menu=editmenu)\n",
    "helpmenu = Menu(menubar, tearoff=0)\n",
    "helpmenu.add_command(label=\"Help Index\", command=donothing)\n",
    "helpmenu.add_command(label=\"About...\", command=donothing)\n",
    "menubar.add_cascade(label=\"Help\", menu=helpmenu)\n",
    "\n",
    "root.config(menu=menubar)\n",
    "root.mainloop()"
   ]
  },
  {
   "attachments": {
    "image-2.png": {
     "image/png": "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"
    },
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "849affde",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)\n",
    "![image-2.png](attachment:image-2.png)\n",
    "![image-2.png](attachment:image-2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56f09aa5",
   "metadata": {},
   "source": [
    "# <center> THANK YOU FOR YOUR ATTENTION. </center>"
   ]
  }
 ],
 "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}