We will, in the process of creating a text editor, take a closer look at some widgets and learn how to tweak them to meet our specific needs.

The following are the key objectives for this project:

The goal here is to build a text editor with some cool nifty features. Let's call it the Footprint Editor.

We intend to include the following features in the text editor:

Our first goal is to implement the broad visual elements of the text editor. As programmers, we have all used text editors to edit code. We are mostly aware of the common GUI elements of a text editor. So, without much of an introduction, let's get started.

The first phase implements the Menu, Menubutton, Label, Button, Text and Scrollbar widgets. Although we'll cover all of these in detail, you might find it helpful to look at the widget-specific options in the documentation of Tkinter maintained by its author Frederick Lundh at http://effbot.org/tkinterbook/. You can also use the interactive shell, as discussed in Chapter 1, Meet Tkinter.

You might also want to bookmark the official documentation page of Tcl/Tk at http://www.tcl.tk/man/tcl8.6/TkCmd/contents.htm. This site includes the original Tcl/Tk reference. While it does not relate to Python, it provides a detailed overview of each widget and is a useful reference. Remember that Tkinter is just a wrapper...

Menus offer a very compact way of presenting a large number of choices to the user without cluttering the interface. Tkinter offers the following two widgets to handle menus:

We will use the following code to add Toplevel menu buttons:

my_menu = Menu(parent, **options)

For example, to add a File menu, we will use the following code:

# Adding Menubar in the widget
menu_bar = Menu(root)

file_menu = Menu(menu_bar, tearoff=0)
# all file menu-items will be added here next
menu_bar.add_cascade(label='File', menu=file_menu)
root.config(menu=menu_bar)

The following screenshot is the result of the preceding code:

Similarly, we will add the Edit, View, and About menus. See 2.01.py.

We will also define a constant, as follows:

PROGRAM_NAME = " Footprint Editor "

Then, we'll set the root window tile as follows:

root.title(PROGRAM_NAME...

Tkinter offers the following three varieties of menu items:

The following View menu shows all of these three types of menu items in action:

The first three menu items in the View menu let users make a definite yes or no choice by checking or unchecking them. These are examples of the Checkbutton menu.

The Themes menu item in the preceding screenshot is an example of a Cascade menu. Hovering over this cascade menu simply opens another list of menu items. However, we can also bind a menu item by using the postcommand=callback option. This can be used to manage something just before bringing up the cascading menu item's contents and is often used for dynamic list creation.

Within the cascade menu, you are presented...

Tkinter's Text widget comes with some handy built-in functionality to handle common text-related functions. Let's leverage these functionalities to implement some common features in the text editor.

Let's start by implementing the cut, copy, and paste features. We now have the editor GUI ready. If you open the program and play with the Text widget, you will see that you can perform basic functions such as cut, copy, and paste in the text area by using Ctrl + X, Ctrl + C, and Ctrl + V respectively. All of these functions exist without us having to add a single line of code toward these functionalities.

The text widget clearly comes with these built-in events. Now, we simply want to connect these events to their respective menu items.

The documentation of Tcl/Tk Universal widget methods tells us that we can trigger events without an external stimulus by using the following command:

widget.event_generate(sequence, **kw)

To trigger the cut event, all we need is the...

Though we managed to leverage some built-in functionality to gain a quick advantage, we need more control over the text area so that we can bend it to our will. This will require the ability to target each character or location of the text with precision.

We will need to know the exact position of each character, the cursor, or the selected area in order to do anything with the contents of the editor.

The Text widget offers us the ability to manipulate its content using index, tags, and mark, which let us target a position or place within the text area for manipulation.

We know that Tkinter has a built-in sel tag that applies a selection to a given text range. We want to apply this tag to the entire text in the widget.

We can simply define a function to handle this, as follows (refer to 2.05.py in the code bundle):

def select_all(event=None):
    content_text.tag_add('sel', '1.0', 'end')
    return "break"

After doing this, add a callback to the Select All menu item:

edit_menu.add_command(label='Select All', underline=7, accelerator='Ctrl+A', command=select_all)

We also need to bind the function to the Ctrl + A keyboard shortcut. We do this by using the following key bindings (refer to 2.05.py in the code bundle):

content_text.bind('<Control-A>', select_all)
content_text.bind('<Control-a>', select_all)

The coding of the Select All feature is complete. To try it out, add some text to the text widget and then click on the menu item, Select All or use the Ctrl + A (accelerator shortcut key).

Next, let's code the Find Text feature (refer to 2.05.py in the code bundle). The following screenshot shows an example of the Find Text feature:

Here's a quick summary of the desired functionality. When a user clicks on the Find menu item, a new Toplevel window opens up. The user enters a search keyword and specifies whether the search needs to be case-sensitive. When the user clicks on the Find All button, all matches are highlighted.

To search through the document, we will rely on the text_widget.search() method. The search method takes in the following arguments:

search(pattern, startindex, stopindex=None, forwards=None, backwards=None, exact=None, regexp=None, nocase=None, count=None)

For the editor, define a function called find_text and attach it as a callback to the Find menu (refer to 2.05.py in the code bundle):

edit_menu.add_command(label='Find',underline= 0, accelerator='Ctrl+F', command=find_text)

Also, bind it to the Ctrl + F shortcut, as follows...

In a code previously in this chapter, we used the following line:

search_toplevel.transient(root)

Let's understand what it means here. Tkinter supports the following four types of Toplevel windows:

The goal for this iteration is to implement the functionality of the File menu options of Open, Save, and Save As.

We can implement these dialogs by using the standard Tkinter widgets. However, since these are so commonly used, a specific Tkinter module called filedialog has been included in the standard Tkinter distribution.

The source code of the filedialog module can be found within the Tkinter source code in a separate file named filedialog.py.

Example of filedialog

A quick look at the source code shows the following functions for our use:

Now, let's complete the code for the About and Help menus. The functionality is simple. When a user clicks on the Help or About menu, a message window pops up and waits for the user to respond by clicking on a button. Though we can easily code new Toplevel windows to show the About and Help messages, we will instead use a module called messagebox to achieve this functionality.

The messagebox module provides ready-made message boxes to display a wide variety of messages in applications. The functions available through this module include showinfo, showwarning, showerror, askquestion, askokcancel, askyesno, askyesnocancel, and askretrycancel, as shown in the following screenshot:

To use this module, we simply import it into the current namespace by using the following command:

import tkinter.messagebox

A demonstration of the commonly used functions of messagebox is illustrated in 2.08.py in the code bundle. The following are some common usage patterns:

import tkinter...

In this iteration, we will add the following functionalities to the text editor:

Let's start with a simple task first. In this step, we will add shortcut icons to the toolbar as shown in the following screenshot:

You may recall that we have already created a frame to hold these icons. Let's add these icons now.

While adding these icons, we have followed a convention. The icons have been named exactly the same as the corresponding function that handles them. Following this convention has enabled us to loop through a list, simultaneously apply the icon image to each button, and add the command callback from within the loop. All the icons have been placed in the icons folder.

The following code adds an icon (refer to 2.10.py in the code bundle):

icons = ('new_file', 'open_file', 'save', 'cut', 'copy', 'paste', 'undo', 'redo'...