Python GUI Programming with Tkinter: Design and build functional and user-friendly GUI applications, 2nd Edition

Cover
Copyright
Contributors
Table of Contents
Preface
Chapter 1: Introduction to Tkinter
	Introducing Tkinter and Tk
		Choosing Tkinter
		Installing Tkinter
			Installing Python 3.9 on Windows
			Installing Python 3 on macOS
			Installing Python 3 and Tkinter on Linux
		Introducing IDLE
			Using the shell mode of IDLE
			Using the editor mode of IDLE
			IDLE as a Tkinter example
		Creating a Tkinter Hello World
	An overview of basic Tkinter
		Building a GUI with Tkinter widgets
		Arranging our widgets with geometry managers
		Making the form actually do something
		Handling data with Tkinter control variables
			Using control variables in a callback function
			The importance of control variables
	Summary
Chapter 2: Designing GUI Applications
	Analyzing a problem at ABQ AgriLabs
		Assessing the problem
		Gathering information about the problem
			Interviewing the interested parties
		Analyzing what we\'ve found out
			Information from the data originators
			Information from the users of the application
			Information from technical support
			Information from the data consumer
	Documenting specification requirements
		Contents of a simple specification
		Writing the ABQ data entry program specification
	Designing the application
		Deciding on input widgets
		Grouping our fields
		Laying out the form
		Laying out the application
	Evaluating technology options
	Summary
Chapter 3: Creating Basic Forms with Tkinter and Ttk Widgets
	The Ttk widget set
		The Label widget
		The Entry widget
		The Spinbox widget
		The Checkbutton widget
		The Radiobutton widget
		The Combobox widget
		The Text widget
			Text widget indices
		The Button widget
		The LabelFrame widget
	Implementing the application
		First steps
		Building the data record form
			The Record Information section
			The Environment Data section
			The Plant Data section
			Finishing the GUI
		Writing the callback functions
			The Reset function
			The Save callback
		Finishing up and testing
	Summary
Chapter 4: Organizing Our Code with Classes
	A primer on Python classes
		The advantages of using classes
			Classes are an integral part of Python
			Classes make relationships between data and functions explicit
			Classes help create reusable code
		Syntax of class creation
			Attributes and methods
			Magic attributes and methods
			Public, private, and protected members
		Inheritance and subclasses
	Using classes with Tkinter
		Improving Tkinter classes
		Creating compound widgets
		Building encapsulated components
			Subclassing Tk
	Rewriting our application using classes
		Adding a StringVar to the Text widget
			Passing in a variable
			Synchronizing the widget to the variable
			Synchronizing the variable to the widget
		Creating a more advanced LabelInput()
		Creating a form class
		Creating an application class
	Summary
Chapter 5: Reducing User Error with Validation and Automation
	Validating user input
		Strategies to prevent data errors
		Validation in Tkinter
			The validate argument
			The validatecommand argument
			The invalidcommand argument
	Creating validated widget classes
		Creating a Date field
	Implementing validated widgets in our GUI
		Introducing the power of multiple inheritance
		Building a validating mixin class
		Building validating input widgets with ValidatedMixin
			Requiring data
			Creating a Date widget
			A better Combobox widget
			A range-limited Spinbox widget
			Validating Radiobutton widgets
		Updating our form with validated widgets
		Implementing validation interaction between form widgets
			Dynamically updating the Spinbox range
			Dynamic disabling of fields
		Displaying errors
		Preventing form submission on error
	Automating input
		Date automation
		Automating Plot, Lab, Time, and Technician
	Summary
Chapter 6: Planning for the Expansion of Our Application
	Separating concerns
		The MVC pattern
			What is a model?
			What is a view?
			What is a controller?
		Why complicate our design?
	Structuring our application directory
		Basic directory structure
			The abq_data_entry.py file
			The README.rst file
			Populating the docs folder
			Making a Python package
	Splitting our application into multiple files
		Creating the models module
		Moving the widgets
		Moving the views
			Removing redundancy in our view logic
			Using custom events to remove tight coupling
		Creating the application file
		Running the application
	Using version control software
		A super-quick guide to using Git
			Initializing and configuring a Git repository
			Adding and committing code
			Viewing and using our commits
	Summary
Chapter 7: Creating Menus with Menu and Tkinter Dialogs
	Solving problems in our application
		Planning solutions to the issues
	Implementing Tkinter dialogs
		Error dialogs with the Tkinter messagebox
		Showing error dialogs in ABQ Data Entry
		Using filedialog
		Using simpledialog and creating a custom dialog
			Creating a Login dialog using simpledialog
			Incorporating the LoginDialog in our class
	Designing the application menu
		The Tkinter Menu widget
			Using Checkbutton and Radiobutton items
		Implementing the ABQ application menu
			Adding a Help menu
			Adding a File menu
			Adding a settings menu
			Finishing the menu
		Persisting settings
			Building a model for settings persistence
			Using the settings model in our application
	Summary
Chapter 8: Navigating Records with Treeview and Notebook
	Implementing read and update in the model
		Adding read and update to the CSVModel class
			Implementing get_all_records()
			Implementing get_record()
			Adding update capability to save_record()
	The Ttk Treeview
		Anatomy of a Treeview
		Building a file browser
			Creating and configuring a Treeview
			Populating a Treeview with data
			Sorting Treeview records
			Using Treeview virtual events
	Implementing a record list with Treeview
		Creating the RecordList class
			Configuring a Treeview widget
			Adding a scrollbar for the Treeview
			Populating the Treeview
	Adding the record list to the application
		Modifying the record form for read and update
			Adding a current record property
			Adding a label to show what is being edited
			Adding a load_record() method
		Updating the application layout
			The Ttk Notebook widget
			Adding a notebook to our application
		Adding and updating application callbacks
			The _show_recordlist() method
			The _populate_recordlist() method
			The _new_record() method
			The _open_record() method
			The _on_save() method
		Main menu changes
		Testing our program
	Summary
Chapter 9: Improving the Look with Styles and Themes
	Working with images in Tkinter
		Tkinter PhotoImage
			PhotoImage and variable scope
		Using Pillow for extended image support
		Adding the company logo to ABQ Data Entry
			Dealing with the image path problem
		Setting a window icon
		Adding icons to buttons and menus
			Using BitmapImage
	Styling Tkinter widgets
		Widget color properties
			Using widget properties on the MainMenu
		Styling widget content with tags
			Styling our record list with tags
	Working with fonts in Tkinter
		Configuring Tkinter fonts
			Configuring fonts with strings and tuples
			The font module
		Giving users font options in ABQ Data Entry
	Styling Ttk widgets
		TTk styling breakdown
			Exploring a Ttk widget
			Using themes
		Adding some color to ABQ Data Entry
			Adding styles to individual form widgets
			Fixing the error colors
			Styling input widgets on error
		Setting themes
			Building a theme selector
	Summary
Chapter 10: Maintaining Cross-Platform Compatibility
	Writing cross-platform Python
		Filenames and file paths across platforms
			Path separators and drives
			Case sensitivity
			Symbolic links
			Path variables
		Inconsistent library and feature support
			Python\'s platform-limited libraries
			Checking low-level function compatibility
			The dangers of the subprocess module
		Text file encodings and formats
		Graphical and console modes
		Writing code that changes according to the platform
	Writing cross-platform Tkinter
		Tkinter version differences across platforms
		Application menus across platforms
			Menu widget capabilities
			Menu guidelines and standards
			Menus and accelerator keys
		Cross-platform fonts
		Cross-platform theme support
		Window zoomed state
	Improving our application\'s cross-platform compatibility
		Storing preferences correctly
		Specifying an encoding for our CSV file
		Making platform-appropriate menus
			Preparing our MainMenu class
			Adding accelerators
			Building the Windows menu
			Building the Linux menu
			Building the macOS menu
			Creating and using our selector function
	Summary
Chapter 11: Creating Automated Tests with unittest
	Automated testing basics
		A simple unit test
		The unittest module
			Writing a test case
			TestCase assertion methods
			Fixtures
			Using Mock and patch
			Running multiple unit tests
	Testing Tkinter code
		Managing asynchronous code
		Simulating user actions
			Specifying an event sequence
		Managing focus and grab
		Getting widget information
	Writing tests for our application
		Testing the data model
			Testing file reading in get_all_records()
			Testing file saving in save_record()
			More tests on the models
		Testing our Application object
		Testing our widgets
			Unit testing the ValidatedSpinbox widget
			Integration testing the ValidatedSpinbox widget
		Testing our mixin class
	Summary
Chapter 12: Improving Data Storage with SQL
	PostgreSQL
		Installing and configuring PostgreSQL
			Configuring PostgreSQL using the GUI utility
			Configuring PostgreSQL using the command line
	Modeling relational data
		Primary keys
			Using surrogate primary keys
		Normalization
			First normal form
			Second normal form
			Third normal form
			More normalization forms
		Entity-relationship diagrams
		Assigning data types
	Creating the ABQ database
		Creating our tables
			Creating the lookup tables
			The lab_checks table
			The plot_checks table
		Creating a view
		Populating the lookup tables
	Connecting to PostgreSQL with psycopg2
		psycopg2 basics
		Parameterized queries
		Special cursor classes
	Integrating SQL into our application
		Creating a new model
			Saving data
			Getting the current seed sample for the plot
		Adjusting the Application class for the SQL backend
			Implementing SQL logins
			Updating the Application._on_save() method
			Removing file-based code
		Adjusting the DataRecordForm for SQL data
			Reordering fields
			Fixing the load_record() method
			Improving auto-fill
		Updating the RecordList for the SQLModel
		We\'re done!
	Summary
Chapter 13: Connecting to the Cloud
	HTTP using urllib
		HTTP transaction fundamentals
			HTTP status codes
		Basic downloading with urllib.request
			Generating POST requests
		Downloading weather data to ABQ Data Entry
			Creating a weather data model
			Parsing the XML weather data
			Implementing weather data storage
		Adding the GUI elements for weather download
	RESTful HTTP using requests
		Understanding RESTful web services
		The Python requests library
			Installing and using requests
			Interacting with authenticated sites using Session
			The requests.Response object
		Implementing a REST backend
			The authenticate() method
			The upload_file() method
			The check_file() method
			The get_file() method
		Integrating REST upload into the application
			Creating a CSV extract
			Creating the upload callback
			Finishing up
	SFTP using paramiko
		Setting up SSH services for testing
		Installing and using paramiko
			Using paramiko
			Inspecting our connection
			Using SFTP
		Implementing an SFTP model
			Uploading files
			Checking a file\'s existence
		Using SFTPModel in our application
			Finishing up
	Summary
Chapter 14: Asynchronous Programming with Thread and Queue
	Tkinter\'s event queue
		Event queue control
			The update() methods
			The after() methods
		Common uses of event queue control
			Smoothing out display changes
			Mitigating GUI freezes
	Running code in the background with threads
		The threading module
			Tkinter and thread safety
		Converting our network functions to threaded execution
			Using the threaded uploader
			Passing messages using a queue
			The Queue object
			Using queues to communicate between threads
		Adding a communication queue to our threaded uploader
		Creating a communications protocol
		Sending messages from the uploader
		Handling queue messages
	Using locks to protect shared resources
		Understanding the Lock object
		Using a Lock object to prevent concurrent uploads
			Threading and the GIL
	Summary
Chapter 15: Visualizing Data Using the Canvas Widget
	Drawing and animation with Tkinter\'s Canvas
		Drawing on the Canvas
			Rectangles and squares
			Ovals, circles, and arcs
			Lines
			Polygons
			Text
			Images
			Tkinter widgets
			Canvas items and state
		Canvas object methods
		Scrolling the Canvas
		Animating Canvas objects
			Setting up the playing field
			Setting our players
			Animating the racers
			Running the game loop and detecting a win condition
	Creating simple graphs using Canvas
		Creating the model method
		Creating the chart view
		Updating the application
	Advanced graphs using Matplotlib
		Data model method
		Creating the bubble chart view
		Updating the Application class
	Summary
Chapter 16: Packaging with setuptools and cxFreeze
	Creating distributable packages with setuptools
		Preparing our package for distribution
			Creating a requirements.txt file
			Creating a pyproject.toml file
			Adding a license file
			Making our package executable
		Configuring a setup.py script
			Basic metadata arguments
			Packages and dependencies
			Adding extra files
			Defining commands
			Testing the configuration
		Creating and using source distributions
			Testing our source distribution
		Building a wheel distribution
	Creating executables with cx_Freeze
		First steps with cx_Freeze
		The build_exe options
		Including external files
		Building executables
			Cleaning up the build
		Building Windows executables with cx_Freeze
			Building a Windows installer file
		Building macOS executables with cx_Freeze
			Building macOS application bundles
			Building macOS .dmg files
	Summary
Appendix
A Quick Primer on
reStructured Text
A Quick SQL Tutorial
Other Books You May Enjoy
Index