jupyter/15_gui_programming.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part XV: GUI Programming <a id=\"15-gui\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. [Tkinter](#tkinter)\n",
    "2. [PyQT](#pyqt)\n",
    "3. [wxPython](#wxpython)\n",
    "4. [Kivy](#kivy)\n",
    "5. [PySimpleGUI](#pysimplegui)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Graphical User Interface_ (GUI) programming is a way to interact with a computer using a mouse, keyboard, and other input devices. GUIs are used in almost every application, from web browsers to video games."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Tkinter <a id=\"tkinter\"></a>\n",
    "\n",
    "[Tkinter](https://docs.python.org/3/library/tkinter.html) is a standard GUI (Graphical User Interface) toolkit for Python. It is one of the most common ways to create graphical applications quickly and easily with Python. Tkinter is included with most Python installations, so there's usually no need to install anything extra to get started.\n",
    "\n",
    "_Core Concepts:_\n",
    "\n",
    "- **Tkinter Module:** This is the interface to the Tk GUI toolkit. It provides various widgets and controls such as buttons, labels, text boxes, checkboxes, and many more that are used to build a GUI application.\n",
    "- **Widgets:** In Tkinter, every element of the GUI (like buttons, labels, text fields) is called a Widget. These are the building blocks of a GUI application.\n",
    "- **Window:** The main GUI application window that hosts all other widgets.\n",
    "- **Event Loop:** Tkinter applications run an event loop (mainloop) to wait for and respond to user actions (events).\n",
    "\n",
    "_Why Use Tkinter?_\n",
    "\n",
    "- **Ease of Use:** Tkinter is straightforward and easy to understand, making it an excellent choice for beginners.\n",
    "- **Bundled with Python:** It comes with Python, so there's no need to install anything extra to start building simple GUI applications.\n",
    "- **Sufficient for Basic Applications:** For simple applications and tools, Tkinter provides enough widgets and functionality.\n",
    "- **Cross-Platform:** Applications built with Tkinter can run on Windows, macOS, and Linux without modification.\n",
    "\n",
    "However, for more complex applications with modern UI requirements, other GUI frameworks like PyQt or Kivy might be more appropriate due to their advanced features and styling options."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%script false --no-raise-error  # This cell is not executed\n",
    "\n",
    "import tkinter as tk\n",
    "\n",
    "\n",
    "def update_label():\n",
    "    label.config(text=\"Hello, Tkinter!\")\n",
    "\n",
    "\n",
    "root = tk.Tk()\n",
    "root.title(\"Tkinter Example\")\n",
    "\n",
    "label = tk.Label(root, text=\"Press the button...\")\n",
    "label.pack()\n",
    "\n",
    "button = tk.Button(root, text=\"Click me\", command=update_label)\n",
    "button.pack()\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. PyQT <a id=\"pyqt\"></a>\n",
    "\n",
    "[PyQt](https://riverbankcomputing.com/software/pyqt/) is a set of Python bindings for The Qt Company's Qt application framework. It is one of the most powerful and popular choices for developing graphical user interfaces (GUIs) and for creating cross-platform applications. PyQt combines the best of Python and Qt, bringing the flexibility of Python and the extensive range of Qt libraries and tools for application development.\n",
    "\n",
    "_Core Features:_\n",
    "\n",
    "- **Rich Set of Widgets:** PyQt provides a wide range of standard widgets and controls such as buttons, sliders, text boxes, and complex widgets like calendars, 3D renderers, or web browsers.\n",
    "- **Advanced Graphics and Animation:** Through Qt's graphics and animation APIs, PyQt applications can include complex graphical effects and animations.\n",
    "- **Database Support:** PyQt offers support for SQL databases through Qt's SQL module, allowing applications to interact with databases seamlessly.\n",
    "- **Network Support:** It includes classes for network programming, enabling applications to communicate over TCP/IP, HTTP, and other protocols.\n",
    "- **Cross-Platform:** PyQt applications can run on various operating systems, including Windows, macOS, and Linux, with minimal to no changes in the codebase.\n",
    "\n",
    "_Why Use PyQt?_\n",
    "\n",
    "- **Comprehensive:** PyQt offers a vast array of functionalities and modules, making it suitable for developing both simple and complex applications.\n",
    "- **Professional and Modern UIs:** The framework supports advanced UI and UX elements, allowing for the creation of professional-looking applications.\n",
    "- **Strong Community and Support:** Qt has a large community and extensive documentation, which is beneficial for developers seeking support or learning resources.\n",
    "- **Commercial and GPL Licensing:** PyQt is available under the GPL and a commercial license, making it suitable for both open-source projects and proprietary software.\n",
    "\n",
    "Given its comprehensive feature set and flexibility, PyQt is an excellent choice for developers looking to create feature-rich, cross-platform applications with Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%script false --no-raise-error  # This cell is not executed\n",
    "\n",
    "import sys\n",
    "\n",
    "from PyQt5.QtWidgets import QApplication, QLabel, QPushButton, QVBoxLayout, QWidget\n",
    "\n",
    "\n",
    "def on_button_clicked():\n",
    "    label.setText(\"Hello, PyQt!\")\n",
    "\n",
    "\n",
    "app = QApplication(sys.argv)\n",
    "\n",
    "window = QWidget()\n",
    "window.setWindowTitle(\"PyQt Example\")\n",
    "\n",
    "layout = QVBoxLayout()\n",
    "\n",
    "label = QLabel(\"Press the button...\")\n",
    "layout.addWidget(label)\n",
    "\n",
    "button = QPushButton(\"Click me\")\n",
    "button.clicked.connect(on_button_clicked)\n",
    "layout.addWidget(button)\n",
    "\n",
    "window.setLayout(layout)\n",
    "window.show()\n",
    "\n",
    "sys.exit(app.exec_())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. wxPython <a id=\"wxpython\"></a>\n",
    "\n",
    "[wxPython](https://wxpython.org/index.html) is a cross-platform GUI toolkit for the Python programming language. It allows Python programmers to create programs with a robust, highly functional graphical user interface, simply and easily. It is implemented as a set of Python extensions, wrapping the native GUI components of the underlying platform, which means that applications built with wxPython will have a native appearance on all supported platforms.\n",
    "\n",
    "_Core Features:_\n",
    "\n",
    "- **Native Look and Feel:** wxPython uses the native GUI controls on whichever platform it is run, ensuring that applications will have the look and feel that users expect.\n",
    "- **Rich Set of Widgets:** It provides a wide variety of widgets (controls) that can be used to build complex user interfaces, including standard items like buttons, text boxes, and menus, as well as more specialized controls like tree views, list controls, and HTML viewers.\n",
    "- **Advanced Graphics Support:** Through wxGraphicsContext, it offers advanced 2D drawing capabilities. Additionally, integration with libraries such as OpenGL for 3D graphics is possible for more complex graphical applications.\n",
    "- **Custom Widget Development:** Developers can create custom widgets and controls to fit their application's specific needs.\n",
    "- **Cross-Platform:** wxPython applications can run on Windows, macOS, and Linux with minimal or no changes to the source code.\n",
    "\n",
    "_Why Use wxPython?_\n",
    "\n",
    "- **Native Look and Feel:** Applications built with wxPython look and behave like native applications on the platform where they are run.\n",
    "- **Community and Support:** wxPython has a supportive community and extensive documentation, making it accessible for both beginners and experienced developers.\n",
    "- **Flexibility:** The ability to create custom controls and use advanced graphics makes wxPython suitable for building a wide range of applications.\n",
    "- **Open Source:** wxPython is open source and freely available for use, even in commercial applications.\n",
    "\n",
    "wxPython is an excellent choice for developers looking to create cross-platform desktop applications with Python, especially when a native look and feel is important."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%script false --no-raise-error  # This cell is not executed\n",
    "\n",
    "import wx  # pip install wxPython\n",
    "\n",
    "\n",
    "class MyFrame(wx.Frame):\n",
    "    def __init__(self):\n",
    "        super().__init__(parent=None, title=\"wxPython Example\")\n",
    "        self.panel = wx.Panel(self)\n",
    "\n",
    "        self.label = wx.StaticText(\n",
    "            self.panel, label=\"Press the button...\", pos=(20, 20)\n",
    "        )\n",
    "        self.button = wx.Button(self.panel, label=\"Click Me\", pos=(20, 50))\n",
    "\n",
    "        self.button.Bind(wx.EVT_BUTTON, self.on_button_click)\n",
    "\n",
    "        self.Show()\n",
    "\n",
    "    def on_button_click(self, event):\n",
    "        self.label.SetLabel(\"Hello, wxPython!\")\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    app = wx.App(False)\n",
    "    frame = MyFrame()\n",
    "    app.MainLoop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Kivy <a id=\"kivy\"></a>\n",
    "\n",
    "[Kivy](https://kivy.org/) is an open-source Python library for developing multitouch application software with a natural user interface (NUI). It is designed to allow the quick and easy creation of applications that run on Windows, Linux, MacOS, Android, and iOS. The main goal of Kivy is to provide a framework for developing applications that take advantage of various input devices, such as touchscreens, multi-touch displays, mice, keyboards, and more.\n",
    "\n",
    "_Core Features:_\n",
    "\n",
    "- **Cross-platform:** Kivy applications can run on multiple platforms without requiring platform-specific code, making it a great choice for developing applications that need to operate across various devices.\n",
    "- **Multitouch Support:** One of the distinguishing features of Kivy is its built-in support for multitouch events, allowing developers to create applications that can handle complex touch interactions.\n",
    "- **Flexible and Customizable:** Kivy allows for the creation of custom widgets and supports a wide range of graphical effects, animations, and transitions. This flexibility lets developers design unique user interfaces.\n",
    "- **GPU Accelerated:** Kivy leverages the GPU (Graphics Processing Unit), which makes it capable of rendering fast graphics. It uses OpenGL ES 2, allowing for smooth animations and transitions in applications.\n",
    "- **Extensive Widget Library:** It comes with a rich set of pre-built widgets, including buttons, sliders, text inputs, and more, that can be easily customized and extended.\n",
    "- **Kivy Language (KV):** A domain-specific language for designing user interfaces. This language makes it easier to bind logic and layout, helping to keep code more organized and readable.\n",
    "\n",
    "_Why Use Kivy?_\n",
    "\n",
    "- **Cross-Platform Development:** Kivy is an excellent choice for developing applications that need to run on multiple platforms, including mobile devices, with minimal changes to the codebase.\n",
    "- **Rapid Development:** The framework supports rapid development with its easy-to-use widgets and the KV language, enabling quick prototyping and iterations.\n",
    "- **Multitouch and NUI Support:** For projects requiring advanced touch interaction or novel user interface approaches, Kivy provides a robust set of capabilities out of the box.\n",
    "- **Open Source:** Being open source, it has the support of a vibrant community that contributes to its development and provides support through forums and documentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%script false --no-raise-error  # This cell is not executed because it will raise OSError in Jupyter Notebook\n",
    "\n",
    "from kivy.app import App  # pip install kivy\n",
    "from kivy.uix.button import Button\n",
    "\n",
    "\n",
    "class TestApp(App):\n",
    "    def build(self):\n",
    "        self.button = Button(text=\"Press Me\")\n",
    "        self.button.bind(on_press=self.on_button_press)\n",
    "        return self.button\n",
    "\n",
    "    def on_button_press(self, instance):\n",
    "        instance.text = \"You Pressed Me!\"\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    TestApp().run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. PySimpleGUI <a id=\"pysimplegui\"></a>\n",
    "\n",
    "[PySimpleGUI](https://docs.pysimplegui.com/en/latest/) is a Python library designed to make the process of creating graphical user interfaces (GUI) more accessible and straightforward. It acts as a wrapper around other Python GUI frameworks like Tkinter, Qt (PyQt5, PySide2), and WxPython, allowing developers to leverage the strengths of these underlying frameworks with a more simplified and intuitive API. PySimpleGUI's philosophy is to enable developers, especially those new to GUI development, to quickly create windows with elements such as text, images, buttons, and inputs with minimal code.\n",
    "\n",
    "_Core Features:_\n",
    "\n",
    "- **Simplicity:** One of the primary goals of PySimpleGUI is to be easy to use and learn. It achieves this by providing a straightforward, Pythonic API that reduces the complexity involved in GUI creation.\n",
    "- **Cross-Platform:** Since PySimpleGUI can run on top of multiple GUI frameworks, it inherits their cross-platform capabilities, making it possible to develop applications that work on Windows, Linux, macOS, and even web browsers (through the Remi integration).\n",
    "- **Customizable:** Despite its focus on simplicity, PySimpleGUI offers enough flexibility to customize the appearance and behavior of GUI elements to fit the needs of a wide range of applications.\n",
    "- **Rich Widget Set:** It supports a comprehensive set of widgets, including text, input boxes, sliders, buttons, charts, and more, covering the needs of most basic to moderately complex GUI applications.\n",
    "\n",
    "_Why Use PySimpleGUI?_\n",
    "\n",
    "- **Rapid Development:** PySimpleGUI's straightforward syntax allows for quick development of simple to moderately complex GUIs.\n",
    "- **Ease of Learning:** For newcomers to GUI programming or those who prefer a more Pythonic approach, PySimpleGUI offers an accessible entry point.\n",
    "- **Versatility:** The ability to run atop multiple GUI backends means developers can prototype in one and switch to another for deployment, taking advantage of each's unique strengths.\n",
    "- **Suitable for Both Beginners and Professionals:** While it's an excellent tool for beginners due to its simplicity, PySimpleGUI is also powerful enough for professionals to build and deploy full-fledged applications.\n",
    "\n",
    "PySimpleGUI strikes a balance between ease of use and flexibility, making it an appealing choice for both newcomers to Python GUI programming and those looking for a quick way to develop applications across different platforms."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%script false --no-raise-error  # This cell is not executed\n",
    "\n",
    "import PySimpleGUI as sg\n",
    "\n",
    "layout = [[sg.Text(\"Hello from PySimpleGUI\")], [sg.Button(\"OK\")]]\n",
    "\n",
    "# Create the window\n",
    "window = sg.Window(\"Demo\", layout)\n",
    "\n",
    "# Create an event loop\n",
    "while True:\n",
    "    event, values = window.read()\n",
    "    # End program if user closes window or\n",
    "    # presses the OK button\n",
    "    if event == sg.WINDOW_CLOSED or event == \"OK\":\n",
    "        break\n",
    "\n",
    "window.close()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}