I.M.C.A Semester – 3 Data Science Fundamentals With Python Unit – 6 |
Graphics and GUI Programming
GUI Development Getting Start with Tkinter
A GUI (Graphical User Interface)
application is a type of software program that provides an interface for users
to interact with a computer or an application using graphical elements such as
windows, icons, buttons, and menus.
GUI applications are designed to be user-friendly
and visually intuitive, making it easier for users to perform tasks, access
features, and manipulate data.
GUI applications have become the
standard for most desktop and mobile computing platforms because they offer an
and user-friendly way to interact with computers and software.
Python Provide inbuilt module name
Tkinter which is used to develop GUI application in python.
Tkinter:
Tkinter is the standard GUI library
that comes with Python. It is simple to use and is a great choice for creating
basic GUI applications.
Tkinter is a lightweight
module. It comes as part of the standard Python installation, so you don't
have to install it separately. It supports a lot of builtin widgets that
can be used directly to create desktop applications.
Python with tkinter is the fastest and easiest way to create the GUI applications. Creating a GUI using tkinter is an easy task.
To
create a tkinter app:
1.
Importing
the module – tkinter
2. Create the main window (container)
3. Add any number of widgets to the main
window
4.
Apply
the event Trigger on the widgets.
Importing tkinter is same as importing
any other module in the Python code.
To create GUI application with python
we must have to first import tkinter module.
following
is a syntax:
from tkinter import *
following
are key points of tkinter:
1. Widgets:
Tkinter provides a wide range of GUI widgets that
you can use to build your applications. Some of the commonly used widgets
include:
Label: Used for displaying static text.
Button: Used for creating clickable buttons.
Entry: Provides a singleline input field.
Text: Allows for multiline text input or display.
Canvas: Provides a drawing area for creating custom
graphics.
Frame: Used for organizing and grouping widgets.
Listbox: Displays a list of items for selection.
Checkbutton and Radiobutton: Used for creating
checkboxes and radio buttons.
Menu: Used for creating menus and menu items.
MessageBox: Provides message boxes for displaying
alerts, warnings, and errors.
And many more.
2. EventDriven Programming:
Tkinter follows an eventdriven programming model.
This means that your application responds to events, such as button clicks or
keyboard input. You define functions (event handlers) that get called in
response to these events.
3. Geometry Management:
Tkinter provides three main geometry managers for
arranging widgets within windows and frames:
Pack: Widgets are packed in their parent container
in the order they are added.
Grid: Widgets are arranged in a gridlike layout
using rows and columns.
Place: Widgets are manually placed at specific
coordinates within their parent container.
4. Main Event Loop:
To start your Tkinter application, you create a main event loop. This loop continuously waits for events to occur (e.g., button clicks or keyboard input) and dispatches them to the appropriate event handlers.
5.
Documentation and Resources:
There are many resources available for learning
Tkinter, including official documentation, tutorials, and community forums, making
it relatively easy to get started.
Tkinter is a great choice for building simple to
moderately complex desktop applications with Python.
In Tkinter, an event is a specific
action or occurrence, such as a user's interaction with a graphical user
interface (GUI) element.
Events are used to detect and respond
to various user actions like mouse clicks, keyboard input, window resizing, and
more.
In Tkinter, events are central to
creating interactive and responsive applications.
Events are associated with widgets
(like buttons, labels, or canvases) and trigger event handlers (functions or
methods) that respond to these actions.
When an event occurs, the associated
event handler is executed, allowing you to take specific actions in response to
user input or system-generated events.
Events are fundamental for creating
interactive and user-friendly GUI applications.
Here's
an explanation of how events are processed in Tkinter:
1.
Binding Events:
This is typically done using the bind
method on the widget. The bind method takes two arguments:
The event you want to bind to (e.g., a
mouse click or keyboard keypress), specified as a string or an event sequence.
The function that should be executed
when the event occurs.
2.
Event Loop:
Tkinter maintains an event loop (also
known as the mainloop) that constantly checks for events happening within the
application. This loop runs indefinitely until the application is closed.
3.
Event Processing:
When an event occurs, such as a button
click or a keypress, Tkinter's event loop detects it. The associated event
handler (the function you bound to the widget) is then executed.
4.
Unbinding Events:
If you no longer want a widget to
respond to an event, you can unbind the event using the unbind method. This
removes the association between the event and the event handler.
Tkinter
supports a wide range of events that you can use to interact with your
graphical user interface (GUI) applications.
Here are some common types of events in Tkinter:
Mouse Events:
<Button-1>:
Left mouse button click.
<Button-2>:
Middle mouse button click.
<Button-3>:
Right mouse button click.
<Enter>:
Mouse pointer enters the widget.
<Leave>:
Mouse pointer leaves the widget.
<Motion>:
Mouse pointer motion over the widget.
Keyboard Events:
<Key>:
Key press event.
<KeyPress>:
A specific key is pressed.
<KeyRelease>:
A specific key is released.
Window Events:
<Configure>:
Window resize or move.
<FocusIn>:
Widget gains focus.
<FocusOut>:
Widget loses focus.
<Map>:
Widget is mapped (made visible).
<Unmap>:
Widget is unmapped (made invisible).
<Visibility>:
Widget's visibility changes.
And more…
In summary, events in Tkinter are an
essential part of building interactive GUI applications.
You bind event handlers to widgets, and
these handlers are executed in response to events, allowing your application to
respond to user interactions.
In Tkinter, a graphical user interface
(GUI) is built by creating and configuring various widget classes.
Widget classes represent different
types of user interface elements, such as buttons, labels, entry fields, and
more.
Following
some of the commonly used widget classes in Tkinter:
1.
Tk (Root Window):
The
Tk class represents the main application window or the root window.
It is the toplevel container for all
other widgets in your Tkinter application.
Typically, you create one instance of
this class to serve as the main application window.
Example:
import tkinter as tk
root = tk.Tk()
root.title("My Tkinter App")
2.
Label:
The Label class is used to display text
or images.
It is a non-interactive widget and is
often used for providing information or instructions to the user. It displays
non-editable Text.
Example:
label = tk.Label(root, text="Hello, World!")
label.pack()
3.
Button:
The Button class represents a clickable
button.
You can associate functions or commands
with buttons, and they are commonly used to trigger actions when clicked.
Example:
button = tk.Button(root, text="Click Me", command=my_function)
button.pack()
According to above example The command option takes a reference to a
function or method as its argument.
When the button is clicked, the
specified function is called.
4.
Entry:
The Entry class provides a text entry
field where users can input singleline text.
You can retrieve the text entered by
the user for further processing.
Example:
entry = tk.Entry(root)
entry.pack()
5. Text:
The Text class is used for displaying
and editing multiline text.
It provides more advanced textediting capabilities compared to the Entry widget.
Example:
text_widget = tk.Text(root)
text_widget.pack()
6.
Frame:
The Frame class is a container widget
that is used to group and organize other widgets.
It can be used to create sections
within your application's window.
Example:
frame = tk.Frame(root)
frame.pack()
7.
Check Button:
The Checkbutton class is used to create
checkboxes that allow users to select multiple options. Checkbuttons are
typically used in groups to enable or disable certain features.
Example:
check_button = tk.Checkbutton(root, text="Enable Feature")
check_button.pack()
8.
Radio Button:
The Radiobutton class is used to create
radio buttons, which allow users to choose one option from a group of mutually
exclusive choices.
Example:
radio_button1 = tk.Radiobutton(root, text="Option 1", value=1)
radio_button2 = tk.Radiobutton(root, text="Option 2", value=2)
9.
Listbox:
The Listbox class is used to create a
list of items from which the user can select one or more. It is often used for
providing a selection menu.
Example:
listbox = tk.Listbox(root)
listbox.insert(1, "Item 1")
listbox.insert(2, "Item 2")
10.
Scale:
The Scale class provides a slider that
allows users to select a value within a specified range. It is useful for
adjusting settings or values.
Example:
scale = tk.Scale(root, from_=0, to=100)
scale.pack()
These are some of the fundamental
widget classes in Tkinter.
You can create complex user interfaces
by combining and customizing these widgets according to your application's
requirements.
In Tkinter, the Canvas widget is a
powerful component for creating and displaying graphics, shapes, and other
graphical elements in a window or frame.
It serves as a drawing surface where
you can draw lines, shapes, text, images, and more.
Here's a detailed explanation of the
Tkinter Canvas widget:
You
can create a Canvas widget using the following Syntax:
canvas = tkinter.Canvas(parent,
options)
According
to above Syntax:
parent: This is the parent widget or
window in which the Canvas widget will be placed.
options: These are various
configuration options you can provide to customize the appearance and behavior
of the Canvas.
Common Canvas Options are:
bg
(background):
Sets the background color of the canvas.
width
and height:
Specify the dimensions (in pixels) of the canvas.
highlightbackground
and highlightcolor: Set
the colors for the border round the canvas.
borderwidth: Determines the width of the border
around the canvas.
scrollregion: Specifies the scrollable region as a
tuple (left, top, right, bottom).
xscrollincrement
and yscrollincrement:
Sets the scroll increment values for horizontal and vertical scrolling.
Following
are some Methods and Functions for Drawing:
Once you have a Canvas widget, you can
use various methods and functions to draw on it. Here are some commonly used
ones:
create_line: Draws a line on the canvas.
canvas.create_line(x1, y1, x2, y2, options)
create_rectangle: Draws a rectangle on the canvas.
canvas.create_rectangle(x1, y1, x2, y2, options)
create_oval: Draws an oval or circle on the canvas.
canvas.create_oval(x1, y1, x2, y2, options)
create_text: Draws text on the canvas.
canvas.create_text(x, y, text="Hello, Tkinter!", options)
create_image: Displays an image on the canvas.
canvas.create_image(x, y, image=image, options)
create_polygon: Draws a polygon on the canvas.
canvas.create_polygon(x1, y1, x2, y2, x3, y3, ..., options)
We can delete or Removes items from the
canvas by following function.
canvas.delete(item) # Delete a
specific item
canvas.delete("all") #
Delete all items on the canvas
move: Moves an item on the canvas.
canvas.move(item, x, y) # Move the item by (x, y) pixels
Event
Handling:
You can also bind events to items on
the canvas to make your drawings interactive. For example, you can bind mouse
click or drag events to respond to user actions on specific items.
Scrolling:
If the content on the canvas exceeds
the visible area, you can enable scrolling by configuring the scrollregion and
using scrollbars.
Canvas
Coordinates:
The coordinate system of the Canvas
starts from the topleft corner with (0, 0) and increases to the right and down.
This means that xcoordinates increase from left to right, and ycoordinates
increase from top to bottom.
Example:
# Draw a line from (10, 10) to (100,
50)
canvas.create_line(10, 10, 100, 50)
The abovecode will draw a line that
starts at (10, 10) and ends at (100, 50) on the canvas.
The Canvas widget is a versatile tool
for creating custom graphics and visual elements in your Tkinter applications,
making it useful for drawing diagrams, charts, custom widgets, and more.
In Python's Tkinter library, which is
commonly used for creating graphical user interfaces (GUIs), geometry managers
are used to control the placement and layout of widgets (UI elements) within a
window or frame.
In simple words, Geometry Managers
refer to the mechanisms that are used to define the positioning and sizing of
widgets (such as buttons, labels, and other UI elements) within a Tkinter
application's window or frame.
Tkinter provides three main geometry
managers:
1.
pack
2.
grid
3.
place.
Each manager has its own approach to
organizing widgets, and you can choose the one that best suits your layout
needs.
1.
pack Geometry Manager:
The pack geometry manager organizes
widgets into a single, non-overlapping horizontal or vertical layout.
It places widgets in the order they are
added and automatically adjusts their sizes to fit the available space.
Syntax:
widget.pack(options)
According to above syntax:
widget: The widget to be placed at
window.
options: A set of options that define
how the widget should be packed. It is also known as attributes.
Common options are:
1.
side
(which can be 'top', 'bottom', 'left', or 'right')
2.
fill
(to specify whether the widget should fill available space in form of X-axis
and Y-axis).
And more options…
Example:
label1 = tk.Label(root, text="Label 1")
label1.pack(side="top", fill="x")
label2 = tk.Label(root, text="Label 2")
label2.pack(side="left", fill="Y")
2.
grid Geometry Manager:
The grid geometry manager arranges
widgets in a tablelike grid, allowing you to specify rows and columns for precise
control over widget placement.
You can define the row and column
positions of widgets, as well as how many rows and columns they span.
Syntax:
widget.grid(options)
According to above syntax:
widget: The widget to be placed at
window screen.
options: A set of options to specify
the row, column, and other layout parameters like row, column, rowspan, and
columnspan.
Example:
label1 = tk.Label(root, text="Label 1")
label1.grid(row=0, column=0)
label2 = tk.Label(root, text="Label 2")
label2.grid(row=1, column=0)
3.
place Geometry Manager:
The place geometry manager allows you
to place widgets using absolute positioning. You specify the exact x and y
coordinates of the widget in pixels, making it suitable for precise layouts.
Syntax:
widget.place(options)
According to above Syntax:
widget: The widget to be placed at
window screen.
options: A set of options, including x
and y for positioning.
Example:
label1 = tk.Label(root, text="Label 1")
label1.place(x=10, y=10)
label2 = tk.Label(root, text="Label 2")
label2.place(x=10, y=50)
Each
geometry manager has its use cases:
pack() is best for simple layouts when
widgets are stacked either horizontally or vertically.
grid() is suitable for more complex layouts
where widgets need to be organized in rows and columns.
place() is handy when you need precise control
over the exact positioning of widgets.
You can mix and match these geometry
managers within the same application, using each where it makes the most sense
for your GUI design.
Displaying images in a Tkinter
application is a common task when working with graphical user interfaces in
Python.
In Tkinter, PhotoImage is a class
provided by the Python Imaging Library (PIL), which is now known as the Pillow
library, that allows you to work with image data and display images within a
graphical user interface.
Use the PhotoImage class to load your
image. You can do this by providing the image file path as an argument to the
PhotoImage constructor.
To display the image in your Tkinter
application, create a Label widget and set its image attribute to the PhotoImage object.
Syntax:
img = PhotoImage(file=’file_path’)
lb1 = Label(root,image=img).pack()
According to above Syntax PhotoImage()
class is used to store file path and image attribute of Label is used to
display that image on window screen.
Example:
from tkinter import *
root = Tk()
root.title = "Menu Options"
root.geometry("500x500")
img = PhotoImage(file='path/image.jpg')
img = img.subsample(2, 4)
lbl = Label(root,image=img).pack()
root.mainloop()
According to above example file
attribute of PhotoImage is contain location or path of file.
Here subsample() is a function provided
by PhotoImage class, that is used to resize or modify the size of an Image.
Than image attribute of Label is used
to display Image on Screen.
In another way we can display image by
using canvas widget.
You can display an image in a Tkinter
canvas by following these steps:
1.
Import the Required Modules:
First, import the necessary modules for
working with Tkinter and images:
Syntax:
import tkinter as tk
from PIL import Image, ImageTk
2.
Create the Main Window:
Start by creating the main Tkinter
application window:
3.
Load and Open the Image:
Load your image using the Image.open()
method from Pillow. This method reads the image file and prepares it for use:
Syntax:
image = Image.open("image.jpg")
Replace "image.jpg" with the
path to your image.
4.
Convert the Image to TkinterCompatible Format:
Convert the image to a format that can
be displayed on a Tkinter canvas using the ImageTk.PhotoImage method:
Syntax:
tk_image = ImageTk.PhotoImage(image)
5.
Create a Tkinter Canvas:
Create a Tkinter Canvas widget that
will be used to display the image. Specify its dimensions using the width and
height parameters:
Syntax:
canvas = Canvas(root, width=500,
height=500)
canvas.pack()
Here, we've set the canvas size to
match the dimensions of the loaded image.
6.
Display the Image on the Canvas:
Use the create_image method on the
canvas to display the image. You'll need to specify the X and Y coordinates
where you want to place the image on the canvas, and provide the tk_image as
the image source:
Syntax:
canvas.create_image(0, 0, anchor=NW,
image=tk_image)
The (0, 0) coordinates specify the
topleft corner of the canvas.
anchor=NW indicates that the image
should be anchored to the topleft corner of the canvas.
Example:
from
PIL import Image, ImageTk
root
= Tk()
#
Load and open the image
image
= Image.open("Path/image.jpg")
#
Convert the image to a Tkinter-compatible format
tk_image
= ImageTk.PhotoImage(image)
#
Create a Tkinter canvas with the same size as the image
canvas
= Canvas(root, width=500, height=500)
canvas.pack()
#
Display the image on the canvas
canvas.create_image(0,
0, anchor=NW, image=tk_image)
This code displays the image on a
Tkinter canvas when you run the program. Ensure you replace
"image.jpg" with the path to your own image file.
In Tkinter, you can create various
types of menus to provide a structured and organized way for users to interact
with your application.
The Tkinter Menu widget is used to create different types of menus in
Python Application.
The following types of menus can be
created using the Tkinter Menu widget: popup, pulldown, and
top level.
Toplevel menus are those menus that are displayed just under the title
bar of the root or any other toplevel windows. For example,
all the websites have a top navigation menu just below the URL bar in the
browser.
Tkinter
provides classes for creating the following types of menus:
1.
TopLevel Menus (Menu Bar):
These menus are displayed at the top of
your application's main window, typically as part of the application's title
bar. They are the highlevel categories like "File," "Edit,"
and "View" and etc.
You create toplevel menus using the
Menu class.
Each toplevel menu can contain submenus
(pulldown menus).
2.
Pulldown Menus:
Pulldown menus are submenus that appear
under toplevel menu items. For example, the "File" menu might have
pulldown submenus like "Open," "Save," and "Exit"
and etc.
You create pulldown menus using the
Menu class, which can be associated with toplevel menus.
3.
Context Menus (Popup Menus):
Context menus, also known as popup
menus or rightclick menus, appear when the user rightclicks on a widget. They
provide contextspecific options.
You create context menus using the Menu
class and typically bind them to specific widgets or events.
To create and use menus in Tkinter, you
generally follow these steps:
1. Create the main window (an instance
of Tk).
2. Create menu objects using the Menu
class.
3. Add menu items to these menu objects
using methods like:add_command, add_separator, and add_cascade.
4. Attach submenus to menu items using add_cascade.
5. Configure the main window to use the
menu bar by using the config method.
6. Display the main window using the mainloop method.
Following
are most common and important methods of Menu Widget:
add_command(): This method is used to add menu items to the menu.
add_cascade() : This method is used to create a hierarchical menu to the parent menu by associating
the given menu to the parent menu.
add_seperator() : This method is used to add the separator line to the menu items.
add(type, options) :This method is used to add the specific menu item to the menu.
delete(startindex, endindex) : This method is used to delete the menuitems that exist
in the specified range.
Here's a basic example that
demonstrates how to create a simple menu bar with "File" and
"Edit" menus and menu items:
from tkinter import *
def open_file():
print("Open
File")
def save_file():
print("Save
File")
def cut_text():
print("Cut
Text")
def copy_text():
print("Copy
Text")
root = Tk()
root.title("Menu Example")
root.geometry("300x200")
menu_bar = Menu(root)
# Create the "File" menu
file_menu = Menu(menu_bar, tearoff=0)
file_menu.add_command(label="Open",
command=open_file)
file_menu.add_command(label="Save",
command=save_file)
file_menu.add_separator()
file_menu.add_command(label="Exit",
command=root.quit)
# Create the "Edit" menu
edit_menu = Menu(menu_bar, tearoff=0)
edit_menu.add_command(label="Cut",
command=cut_text)
edit_menu.add_command(label="Copy",
command=copy_text)
# Add the "File" and
"Edit" menus to the menu bar
menu_bar.add_cascade(label="File",
menu=file_menu)
menu_bar.add_cascade(label="Edit",
menu=edit_menu)
# Configure the main window to use the
menu bar
root.config(menu=menu_bar)
root.mainloop()
This example creates a main window with
a menu bar containing "File" and "Edit" menus.
Each menu contains various menu items,
and when these items are selected, the corresponding functions are executed.
This is just a basic example, and you
can extend it to create more complex menu systems for your Tkinter
applications.
The Tkinter Menu widget is used to create different types of menus in
Python Application.
The following types of menus can be
created using the Tkinter Menu widget: popup, pulldown, and
top level.
Popup menus, also known as Context
menus or rightclick menus, appear when the user rightclicks on a widget. They
provide contextspecific options.
This menu can be shown anywhere on the
client window.
To create a popup menu in Tkinter, you
can use the Menu() class.
The Menu() class takes a
single argument: the parent widget of the menu.
For example, to create a popup menu
that appears when the user rightclicks on a Tk() widget, You would
use the following Syntax:
Syntax:
menu = Menu(root)
According to above example Menu() class
is use to create main Menu.
Following are most common and important
methods of Menu Widget:
Menu(root): creates the menu.
tk_popup(x,
y): posts
the menu at the position given as arguments.
grab_release(): releases the event grab.
bind(key,
event): binds
the mouse event.
add_command() : This method is used to add menu items to the menu.
add_cascade() : This method is used to create a hierarchical menu to the parent menu by associating
the given menu to the parent menu.
add_seperator() : This method is used to add the separator line to the menu items.
add(type, options) :This method is used to add the specific menu item to the menu.
delete(startindex,
endindex) : This
method is used to delete the
menuitems that exist in the specified range.
Example:
from tkinter import *
root = Tk()
root.title = "Menu Options"
root.geometry("500x500")
def popup_event(event):
myMenu.tk_popup(x =
event.x_root, y = event.y_root)
myMenu = Menu(root,tearoff=False)
myMenu.add_command(label="Copy")
myMenu.add_command(label="Cut")
myMenu.add_command(label="Paste")
myMenu.add_separator()
myMenu.add_command(label="Exit",command=quit)
root.bind("<Button-3>",popup_event)
root.mainloop()
According to above example myMenu is an object of Menu class which
is used to create Menu box in tkinter.
Here we use add_command() function
which is used to define menu items in Menu box such as Copy, Cut, Paste and
Exit.
Then we use bind() function which binds
the popup_event() function with right click mouse event. Here <Button-3>
represents right click mouse event.
Tkinter is very powerful tool of python
which is used to develop desktop application.
Basically in any application events
play most important part which works as a bridge between the User and the
application logic.
Events include mouse clicks, key
presses, and window resizing.
In tkinter, mouse is concept of mouse
events there are numbers of mouse events and key events provided by tkinter.
Mouse events in Tkinter allow you to
capture and respond to user interactions with the mouse, including clicks,
button presses, and movements.
These events enable you to create
interactive and responsive graphical user interfaces (GUIs).
Following
are some Common mouse events in Tkinter:
1.
ButtonPress Event:
This event is triggered when the user
presses a mouse button.
Event name format: <Button1> (for
the left mouse button), <Button2> (middle button), and <Button3>
(right button).
2.
ButtonRelease Event:
Triggered when the user releases a
mouse button after pressing it.
Event name format is the same as
ButtonPress.
3.
Motion Event:
Occurs when the mouse pointer moves
within the boundaries of a widget.
Event name format: <Motion>
4.
Enter Event:
Triggered when the mouse pointer enters
the boundaries of a widget.
Event name format: <Enter>
5.
Leave Event:
Occurs when the mouse pointer leaves
the boundaries of a widget.
Event name format: <Leave>
6.
DoubleButton Press Event:
This event is triggered when the user
doubleclicks a mouse button.
Event name format:
<DoubleButton1>, <DoubleButton2>, and <DoubleButton3>,
similar to ButtonPress.
7.
Mouse Wheel Event:
Occurs when the user rotates the mouse
wheel (scroll wheel).
Event name format: <Button4> (scroll
up) and <Button5> (scroll down).
Mouse
Binding in Tkinter:
To respond to mouse events in Tkinter,
you can bind functions to specific mouse events using the bind method of a
widget. Here's how to do it:
Syntax of bind() function:
widget.bind(“<Button1>”,function_name)
Example:
from tkinter import *
def mouse_click_event(event):
print("Mouse clicked
at ",event.x, event.y)
root = Tk()
root.title("Mouse Event
Example")
root.geometry("300x100")
b1 = Button(root,text="Click
Here")
b1.bind("<Button1>",
mouse_click_event)
b1.pack()
root.mainloop()
In this example, when you click the
left mouse button within the window, the mouse_click_event function is
executed, and the coordinates of the click are displayed in the console.
Mouse binding is a fundamental feature
for creating graphical user interfaces with Tkinter.
Tkinter is a Python library which is
used to create GUIbased application.
Tkinter Events are generally used to
provide an interface that works as a bridge between the User and the
application logic.
We can use Events in any Tkinter
application to make it operable and functional.
In Tkinter, events are user actions that cause the
interpreter to execute a function.
Events include mouse clicks, key
presses, and window resizing.
Binding a function to an event means
that the function will be executed when the event occurs.
To bind a function to an event, tkinter
provide the bind() method.
The bind() method takes two
arguments:
1.
the
event name.
2.
and
the function name, to be executed.
The event name is a string that
describes the event. For example, the event name for a mouse click
is "<KeyPressa>".
Syntax:
widget.bind(“<KeyPressa”,function_name)
According to above syntax bind()
function binds widget to a function. Here first argument <KeyPressa> is
an inbuilt Key Pressing event and second argument is function_name, which we
define in our program.
There are various types of mouse events
and key events are available in tkinter,but following are some Key events that
represents various types of Key board related actions.
1.
KeyPress Event:
This event is triggered when a key is
pressed down.
The event name format is
<KeyPressa>, where "a" is the key or key symbol.
2.
KeyRelease Event:
This event is triggered when a key is
released after being pressed.
The event name format is
<KeyReleasea>, where "a" is the key or key symbol.
3.
Key Event for Special Keys:
Special keys such as Shift, Control,
Alt, and function keys are represented using their names, e.g., <KeyPressShift_L>,
<KeyPressControl_L>, <KeyPressF1>.
4.
Key Combination Events:
You can bind functions to key
combinations, such as Ctrl+C or Alt+T. For example, <Controlc> for
Ctrl+C.
Following is simple KeyPress Event Example:
from tkinter import *
root = Tk()
root.title("Events and
Bindings")
root.geometry("300x200")
def key_event(event):
print("KeyPressed")
root.bind("<KeyPressa>",key_event)
root.mainloop()
According to above example when we
press key of a letter the function key_event() getting execute and display
the meassge “Key Pressed” in Console Screen.
We can set any key with just defining
<KeyPressb>, <KeyPressc> and any letter of key.
Standard dialogs in Tkinter are prebuilt dialog
boxes provided by the Tkinter library to help you interact with the user and
gather information or perform specific actions in your graphical user interface
(GUI) applications.
These dialogs are commonly used for tasks such as
opening files, saving files, selecting colors, and displaying messages.
Tkinter provides several standard dialogs, each
onehave a specific purpose.
Following
are some of the standard dialogs available in Tkinter:
1. File Dialogs:
File dialogs are used for opening and saving files.
They allow users to browse the file system and select or specify file
locations.
Tkinter provides two file dialogs:
filedialog.askopenfilename and filedialog.asksaveasfilename.
Example:
from tkinter import *
from tkinter import filedialog
root = Tk()
file_path =
filedialog.askopenfilename(title="Select a file")
print(file_path)
2. Color Dialogs:
Color dialogs allow users to select colors for
various purposes, such as setting text or background colors.
Tkinter provides the colorchooser.askcolor
function.
Example:
from tkinter import *
from tkinter import colorchooser
root = Tk()
color =
colorchooser.askcolor(title="Choose a color")
print(color)
3. Message Box Dialogs:
Message box dialogs are used to display messages to
the user, ask for confirmation, or provide alerts.
Tkinter provides various message box types, such as messagebox.showinfo, messagebox.showwarning, messagebox.showerror, and messagebox.askyesno, among others.
Example:
from tkinter import *
from tkinter import messagebox
root = Tk()
response =
messagebox.askyesno("Confirmation", "Do you want to
proceed?")
print(response)
4. Directory Dialogs:
Directory dialogs allow users to select a directory
or folder from the file system.
Tkinter provides filedialog.askdirectory.
Example:
from tkinter import *
from tkinter import filedialog
root = Tk()
directory =
filedialog.askdirectory(title="Select a directory")
print(directory)
root.mainloop()
5. Simple Dialogs:
Simple dialogs provide custom input fields for
collecting user data, such as text input or numeric input.
Tkinter offers the simpledialog module with
functions like simpledialog.askstring, simpledialog.askinteger, and
simpledialog.askfloat.
Example:
from tkinter import *
from tkinter import simpledialog
root = Tk()
user_input =
simpledialog.askstring("Input", "Enter your name:")
print(user_input)
These standard dialogs save you time and effort in
creating common user interactions, ensuring a consistent look and feel across
different platforms. They are a valuable resource for building userfriendly GUI
applications with Tkinter.
Thank You
:: Any Query::
Contact: Ruparel Education Pvt. Ltd.
Mobile No: 7600044051
