PCPP1 Graphical User Interface Programming Practice Test 5 — 15 Questions

Question 1

You are writing a Tkinter dialog that must react to a user pressing the Escape key at any time, even when focus is inside an Entry widget. You have a function named on_cancel. Which binding correctly achieves this?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

root.bind_all('<Escape>', on_cancel). A global cancel shortcut must be registered at the application level. bind_all places the handler in the application-wide binding table so it triggers no matter which widget has focus. Widget-level and class-level bindings are scoped to specific widgets or widget classes and therefore miss events when focus is elsewhere, which is why they cannot satisfy the scenario.

Answer

root.bind_class('Entry', '<Escape>', on_cancel)

Answer

entry.bind('<Escape>', on_cancel)

Answer

root.bind('<Escape>', on_cancel, add='+')

Question 2

You are placing several widgets in a window using the grid() geometry manager and want a widget to span multiple columns in the same row. Which grid() option accomplishes this?

Accepted Answer

columnspan. In grid(), the columnspan option specifies how many columns a widget should occupy, starting from its column index. This is the mechanism for horizontal spanning within a row. rowspan handles vertical spanning, sticky controls alignment and stretching inside the cell, and ipadx adds internal padding. Combining columnspan with sticky lets a widget both cover several columns and fill the resulting space as desired.

Answer

ipadx

Answer

rowspan

Answer

sticky

Question 3

A Tkinter application has a modal dialog implemented as a Toplevel that collects a numeric discount. The dialog's OK button command calls a validator that may raise ValueError, and you want the dialog to stay open with an inline error label rather than crashing the mainloop. The dialog is opened from the main window with dialog.grab_set() followed by main_window.wait_window(dialog). Which approach correctly keeps the error visible and prevents the exception from propagating out of the Tkinter callback?

Accepted Answer

Wrap the validation logic in try/except ValueError inside the OK button's command, update an error Label's text, and return normally so the callback ends without raising.. Inline validation in a modal Toplevel requires the callback to handle its own exceptions and update widget state instead of letting the error escape into Tkinter's global handler. Catching ValueError, writing to the error Label, and returning normally keeps the dialog alive and interactive, which is exactly what the scenario demands. Threading, nested wait_window, and protocol overrides all miss that central point.

Answer

Move the validation into a separate thread and call dialog.destroy() from that thread when validation fails.

Answer

Call dialog.wait_window(dialog) again inside the OK button command so the dialog blocks until validation succeeds.

Answer

Set dialog.protocol('WM_DELETE_WINDOW', lambda: None) so the dialog cannot be closed while validation is pending.

Question 4

You are creating a Tkinter GUI with a Canvas widget to draw a simple chart. You need to draw a filled blue rectangle from (50, 50) to (150, 100). Which Canvas method call achieves this?

Accepted Answer

canvas.create_rectangle(50, 50, 150, 100, fill='blue'). The Canvas widget offers dedicated factory methods for common shapes. create_rectangle takes two coordinate pairs that define the top-left and bottom-right corners and accepts a fill option for the interior colour. Using the correct method ensures the shape is actually a rectangle rather than a degenerate polygon, a thick line, or an ellipse.

Answer

canvas.create_polygon(50, 50, 150, 100, fill='blue')

Answer

canvas.create_oval(50, 50, 150, 100, fill='blue')

Answer

canvas.create_line(50, 50, 150, 100, fill='blue', width=50)

Question 5

You are building a canvas-based drawing tool and need to detect when the user clicks on a specific rectangle item to select it, while other clicks should be ignored. Which canvas feature should you use?

Accepted Answer

Use the canvas tag_bind() method to bind <Button-1> to the rectangle's tag or item id.. Canvas items support their own event bindings through tag_bind(), which ties a callback to a tag or item id. When the user clicks, the canvas performs hit testing and invokes the binding only if the pointer is over a matching item, honoring stacking order for overlaps. This is more robust than comparing raw coordinates and automatically tracks items as they move or change, making it the correct choice for selecting individual shapes.

Answer

Call itemconfigure() on the rectangle with an activefill option to detect selection.

Answer

Bind <Button-1> to the top-level window and use the focus() method to determine which item was clicked.

Answer

Bind a <Button-1> handler to the canvas and compare event coordinates against the rectangle's bounding box.

Question 6

You are maintaining a Tkinter inventory application where users type quantities into an Entry widget. A colleague reports that the application accepts "12.5" for an item that must be a whole number, and invalid keystrokes are only caught after the user clicks Save. You must reject non-numeric input as it is typed, while still allowing a normal editing experience. Which mechanism should you register on the Entry widget?

Accepted Answer

A command callback passed to the Entry widget's validatecommand option, with validate set to "key".. Tkinter's Entry validation framework invokes a registered callback at defined moments, and validate="key" triggers it on every keystroke before the change is applied. Returning False from that callback cancels the edit, so non-integer characters are rejected immediately while legitimate editing continues to work. This is the only listed approach that prevents bad input from ever reaching the widget, matching the stated requirement.

Answer

A call to the Entry widget's config method with the state option set to "readonly" while the user is typing.

Answer

A trace callback attached to a StringVar linked to the Entry widget, raising an exception whenever the new value is not an integer.

Answer

A binding for the <Return> event that inspects the Entry contents and shows a messagebox when the value is not an integer.

Question 7

A desktop tool built with Tkinter needs a list of departments shown as mutually exclusive radio buttons. When the user selects a department, the underlying model object's department attribute must update immediately, and the code must read the selection later without iterating over every radio button. Which Tkinter mechanism best satisfies these requirements?

Accepted Answer

Create an IntVar or StringVar, pass it as the variable option to every Radiobutton in the group, and read or trace that variable when the model needs updating.. A shared Tkinter variable is the mechanism that ties a group of Radiobuttons together and makes their selection readable as a single value. Because the variable can be traced, the model updates the moment the user clicks, and later reads need only the variable rather than a loop over widgets. Separate variables, Listboxes, and Comboboxes all fail at least one stated requirement.

Answer

Use a ttk.Combobox and call get() on it whenever the model is saved to the database.

Answer

Give each Radiobutton its own BooleanVar and inspect all of them with cget when the model needs the current department.

Answer

Use a Listbox configured with selectmode='browse' and read its curselection() to determine the chosen department.

Question 8

A Tkinter application has a main window containing a Text widget used as a log console. The application performs a long-running data import and must remain responsive, so the import runs in a background thread. The worker thread needs to append status lines to the Text widget. Which approach is correct?

Accepted Answer

Have the worker thread place messages on a queue.Queue, and have the main thread poll that queue periodically using the after method and perform the insert calls.. Tkinter widgets may only be manipulated from the thread that created the root window, so a background worker must not touch the Text widget directly. Passing messages through a queue and having the main thread drain it with an after-scheduled callback keeps all widget calls on the owning thread while the import proceeds in parallel. This preserves responsiveness and avoids interpreter corruption.

Answer

Wrap each insert call in a threading.Lock shared with the main thread so only one thread touches the Text widget at a time.

Answer

Call the Text widget's insert method directly from the worker thread, since Tkinter serializes widget access internally.

Answer

Call the root window's update_idletasks method from the worker thread before each insert so pending events are processed first.

Question 9

A colleague built a Tkinter form where every Entry widget uses `pack()` in the same frame. They now need the labels to sit in a single column with the entries aligned in the next column and the whole form centered. They ask you to recommend the smallest structural change that makes this alignment reliable. What should you suggest?

Accepted Answer

Replace `pack()` with `grid()` inside a dedicated Frame, assigning labels and entries to the same row with different column indexes, then pack that Frame into the parent.. Grid is the correct tool for two-column alignment because it assigns widgets to explicit row and column cells, keeping labels and entries aligned regardless of content width. Wrapping the grid in its own Frame and packing that Frame into the parent is the smallest structural change that both aligns the fields and centers the form, without rewriting the entire window layout.

Answer

Keep `pack()` but add `side=tk.LEFT` to every label and `side=tk.RIGHT` to every entry so they form two implicit columns.

Answer

Use `pack()` for the labels and `grid()` for the entries in the same container, relying on Tkinter to merge both managers automatically.

Answer

Switch each Entry to `place()` and hard-code its x and y coordinates based on the current window size.

Question 10

You are reviewing a Tkinter application that uses ttk widgets and a Canvas to draw a seating chart. The chart must redraw when the window is resized, and a toolbar above it must stay a fixed height. Which two techniques correctly contribute to a layout where the Canvas expands and the toolbar does not? (Choose two.)

Accepted Answer

Place the toolbar and Canvas in the same container with grid(), give the toolbar row weight=0 and the Canvas row weight=1, and set sticky='nsew' on the Canvas so it adheres to all cell edges.. A responsive chart needs both correct space allocation and a redraw trigger. Weighted grid rows with sticky='nsew' ensure the Canvas receives the surplus area while the toolbar keeps its natural height, and a <Configure> binding on the Canvas supplies the new dimensions for redrawing. The other options either mix incompatible geometry managers, hard-code sizes, or invert the weights.

Answer

Set canvas.configure(width=800, height=600) and bind the toplevel's <Configure> event to call canvas.configure with the new toplevel size.

Answer

Call canvas.pack(expand=True, fill='both') and toolbar.pack(side='top') in the same parent, relying on pack to keep the toolbar fixed.

Answer

Set the toolbar's grid row weight to 1 and the Canvas row weight to 0, then call canvas.update_idletasks() after each resize.

Question 11

You are building a Tkinter desktop application with a menu bar. Users report two problems: keyboard shortcuts such as Ctrl+S do not trigger the Save command when focus is inside a Text widget, and mnemonic underlines on the File menu are missing. You must correct the menu configuration. Which two changes should you make? (Choose two.)

Accepted Answer

Bind the event to the save handler on the root window or on the widget that holds focus, in addition to adding the menu entry.. In Tkinter, the accelerator option only displays shortcut text and does not install a binding, so making Ctrl+S work requires an explicit binding of to the handler. Separately, mnemonic underlines come from the underline option, which names the character index to underline on the menu label. Applying those two settings fixes the reported shortcut and underline problems.

Answer

Configure the menu entry with state="normal" so keyboard traversal is enabled for the File menu.

Answer

Set tearoff=0 on the menubar so the File menu can be detached and the underline becomes visible.

Answer

Pass accelerator="Ctrl+S" to the Save menu entry so the shortcut text is displayed next to the command.

Question 12

You are prototyping a Tkinter application and want a single-line input field where users can type a search term. The field should also show a placeholder-like behavior by pre-filling the text 'Search...' when the window opens. Which widget and option combination achieves this most directly?

Accepted Answer

An Entry widget with a StringVar whose initial value is 'Search...' and passed via the `textvariable` option.. An Entry widget is the canonical single-line text input in Tkinter. Pairing it with a StringVar initialized to the placeholder text and connected via `textvariable` gives both an initial visible value and a live binding that the application can read or update. This directly satisfies the requirement of a pre-filled, editable search field without extra workarounds.

Answer

A Text widget with `height=1` and the initial string passed as the first positional argument.

Answer

A Spinbox widget with `values=('Search...',)` and `state='readonly'` so the placeholder cannot be modified.

Answer

A Label widget with `textvariable` bound to a StringVar set to 'Search...' and made editable via `state=tk.NORMAL`.

Question 13

A Tkinter data-entry form uses an Entry widget for a numeric amount. Users report that pressing Enter in the Entry does nothing, and the value is only saved when they click a separate Save button. You want Enter to trigger the same save routine as the button, without duplicating logic. Which binding achieves this?

Accepted Answer

entry.bind('', lambda event: save_amount()). The event sequence is the correct Tkinter binding for the Enter key on an Entry widget. Binding it to a small lambda that calls the existing save function reuses the button's logic and gives users the keyboard shortcut they expect. KeyPress is too broad, Enter refers to pointer entry, and FocusOut triggers on focus changes rather than the Enter key.

Answer

entry.bind('<KeyPress>', lambda event: save_amount())

Answer

entry.bind('<Enter>', lambda event: save_amount())

Answer

entry.bind('<FocusOut>', lambda event: save_amount())

Question 14

A Tkinter application uses a Canvas to draw a seating chart. Each seat is a rectangle created with create_rectangle, and seats are grouped by section. When a section is selected, every seat in it must change fill color, and some seats must later be moved to a new position. Which strategy best supports efficient grouped updates while keeping individual seats addressable?

Accepted Answer

Assign a unique tag to each seat's rectangle and use the tag to call itemconfig on all seats in the section, and use coords or move to reposition individual seats.. Canvas tags are the intended mechanism for applying an operation to many items at once: itemconfig with a tag recolors every matching item in a single call, and each seat can also carry a unique tag for precise coords or move operations. This yields efficient section-wide updates while preserving individual addressability, unlike per-item loops or destructive recreation.

Answer

Delete all rectangles in the section and recreate them with the new color and position whenever a section changes.

Answer

Place each seat rectangle inside its own Frame widget and change the Frame background color, relying on the canvas window items to reflect the change.

Answer

Store each rectangle's item id in a dictionary and iterate over the section, calling itemconfig and coords on each id individually.

Question 15

You are designing a Tkinter application that uses a ttk.Treeview to display a table of records. You need to configure the widget so that users can select multiple non-contiguous rows and so that the first column shows a tree-style expander control. Which two actions must you perform? (Choose two.)

Accepted Answer

Set the show option to 'tree headings' or include 'tree' in the show tuple.. Multi-selection in a Treeview is governed by selectmode, which must be 'extended' to allow non-contiguous picks. The tree-style expander in the first column is controlled by the show option: including 'tree' (for example, 'tree headings') displays the tree column with expander controls. Heading text, height, and stretch are unrelated to these two requirements.

Answer

Call tree.heading('#0', text='Name') to set the label of the tree column.

Answer

Set the height option to a value greater than the number of rows.

Answer

Call tree.column('#0', stretch=True) to make the tree column resize with the widget.