19. Popovers
The Gtk.Popover is a separate window used for displaying additional
information and is often used with button menus and context menus.
Popovers are visually connected to a related widget with a small triangle.
Their uses are similar to those of dialog windows with the advantage of being less
disruptive and having a connection with the widget the popover is pointing to.
A Popover can be created with Gtk.Popover; for opening the popover use
Gtk.Popover.popup().
19.1. Custom Popover
A widget can be added to a popover using Gtk.Container.add().
19.1.1. Example
1import gi
2
3gi.require_version("Gtk", "3.0")
4from gi.repository import Gtk
5
6
7class PopoverWindow(Gtk.Window):
8 def __init__(self):
9 super().__init__(title="Popover Demo")
10 self.set_border_width(10)
11 self.set_default_size(300, 200)
12
13 outerbox = Gtk.Box(spacing=6, orientation=Gtk.Orientation.VERTICAL)
14 self.add(outerbox)
15
16 self.popover = Gtk.Popover()
17 vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
18 vbox.pack_start(Gtk.ModelButton(label="Item 1"), False, True, 10)
19 vbox.pack_start(Gtk.Label(label="Item 2"), False, True, 10)
20 vbox.show_all()
21 self.popover.add(vbox)
22 self.popover.set_position(Gtk.PositionType.BOTTOM)
23
24 button = Gtk.MenuButton(label="Click Me", popover=self.popover)
25 outerbox.pack_start(button, False, True, 0)
26
27
28win = PopoverWindow()
29win.connect("destroy", Gtk.main_quit)
30win.show_all()
31Gtk.main()
19.2. Menu Popover
A popover can be created from a Gio.MenuModel using
Gtk.Popover.new_from_model() and can be changed after creation with
Gtk.Popover.bind_model().
Passing a Gio.MenuModel as a
menu_model argument to the
Gtk.MenuButton constructor implicitly creates a popover.
19.2.1. Example
import sys
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gio, Gtk
# This would typically be its own file
MENU_XML = """
<?xml version="1.0" encoding="UTF-8"?>
<interface>
<menu id="app-menu">
<section>
<item>
<attribute name="label">About</attribute>
<attribute name="action">app.about</attribute>
</item>
<item>
<attribute name="label">Quit</attribute>
<attribute name="action">app.quit</attribute>
</item>
</section>
</menu>
</interface>
"""
class AppWindow(Gtk.ApplicationWindow):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.set_default_size(300, 200)
outerbox = Gtk.Box(spacing=6, orientation=Gtk.Orientation.VERTICAL)
self.add(outerbox)
outerbox.show()
builder = Gtk.Builder.new_from_string(MENU_XML, -1)
menu = builder.get_object("app-menu")
button = Gtk.MenuButton(menu_model=menu)
outerbox.pack_start(button, False, True, 0)
button.show()
self.set_border_width(50)
class Application(Gtk.Application):
def __init__(self, *args, **kwargs):
super().__init__(*args, application_id="org.example.myapp", **kwargs)
self.window = None
def do_startup(self):
Gtk.Application.do_startup(self)
action = Gio.SimpleAction(name="about")
action.connect("activate", self.on_about)
self.add_action(action)
action = Gio.SimpleAction(name="quit")
action.connect("activate", self.on_quit)
self.add_action(action)
def do_activate(self):
# We only allow a single window and raise any existing ones
if not self.window:
# Windows are associated with the application
# when the last one is closed the application shuts down
self.window = AppWindow(application=self, title="Main Window")
self.window.present()
def on_about(self, action, param):
about_dialog = Gtk.AboutDialog(transient_for=self.window, modal=True)
about_dialog.present()
def on_quit(self, action, param):
self.quit()
if __name__ == "__main__":
app = Application()
app.run(sys.argv)