How to keep PyGTK AppIndicator menu open after click?

I was trying to toy around with the pygtk module to make an app indicator in my top bar in Ubuntu 17.10.

With a little research, I have successfully made a menu where you can pause the main thread (which just prints "Update" to the console currently.)

Now I've stumbled across a problem and couldn't find an answer.

I plan to make a radio streamer for the top bar and the menu closing on every click would be very undesirable for navigation when searching.

How can I make the menu stay open when clicking an item?

Here is my code:

import os
import signal
import time
from threading import Thread

import gi
gi.require_version("Gtk", "3.0")
gi.require_version("AppIndicator3", "0.1")

from gi.repository import Gtk as gtk
from gi.repository import AppIndicator3 as appindicator
from gi.repository import GObject as gobject


class Indicator:

    def __init__(self, name=None, icon=None):

        self.path = os.path.abspath(os.path.dirname(__file__))

        signal.signal(signal.SIGINT, signal.SIG_DFL)

        if name is None:
            self.name = "MyApp"
        else:
            self.name = name

        if icon is None:
            self.icon = gtk.STOCK_INFO
        else:
            self.icon = icon

        self.indicator = appindicator.Indicator.new(
            self.name, self.icon,
            appindicator.IndicatorCategory.SYSTEM_SERVICES
            )

        self.indicator.set_status(appindicator.IndicatorStatus.ACTIVE)

        self.indicator.set_menu(self.create_menu())

        self.running = True
        self.paused = False

        self.thread = Thread(target=self.update)
        self.thread.setDaemon(True)
        self.thread.start()

    def create_menu(self):
        menu = gtk.Menu()

        pause_entry = gtk.MenuItem("Pause")
        pause_entry.connect("activate", self.pause)
        menu.append(pause_entry)

        quit_entry = gtk.MenuItem("Quit")
        quit_entry.connect("activate", self.quit)
        menu.append(quit_entry)

        menu.show_all()
        return menu

    def update(self):
        while self.running:
            time.sleep(1)
            if not self.paused:
                print("Update", flush=True)

    def start(self):
        gobject.threads_init()
        gtk.main()

    def pause(self, menu):
        self.paused = not self.paused
        text = "Resume" if self.paused else "Pause"
        for widget in menu.get_children():
            print(widget.get_text())
            widget.set_text(text)

    def quit(self, menu=None):
        self.running = False
        gtk.main_quit()


if __name__ == "__main__":
    indicator = Indicator()
    indicator.start()

Unfortunately, I don't think you can make the menu stay open when clicking on an item.

This was an intentional design decision taken by the AppIndicator developers in order to ensure that the indicator would function in a consistent and uniform way and that no custom actions(e.g. right-click, mouseover etc) would be possible to be applied on by end users.

I have created an appindicator that displays news in real time and when I researched the related pygtk/appindicator API reference material; the only allowed supported menu action that I came across was that of scrolling.

With regards to your radio streamer project I suggest have the menu as the main focal point of your application and have the menu items appropriately bidden to pygtk windows. Then use callbacks and signals to perform your necessary actions. This is the approach I undertook in my little project too and turned out pretty nicely.