Escribir indicadores con Python, GIR y GTK3

Estoy escribiendo una aplicación que necesita usar un indicador. Lo hice en el pasado usando PyGTK y GTK2, usando como referencia este documento: https://wiki.ubuntu.com/DesktopExperienceTeam/ApplicationIndicators#Python_version

Sin embargo, eso solo funciona con PyGTK y GTK2. Las cosas han cambiado desde entonces, y necesito encontrar buena documentación, un tutorial o un buen ejemplo para aprender cómo funciona.

Además, una cosa que el documento mencionado anteriormente no describe en absoluto, es cómo agregar submenús a un indicador. Espero que alguien pueda arrojar algo de luz sobre esto, así como sobre cómo integrarse con los indicadores de categoría si se hace con la misma herramienta.

Gracias.

Este es mi código de prueba para gtk3 y appindicator que crea un indicador para GPaste .

Básicamente,

from gi.repository import AppIndicator3 as AppIndicator

para usar appindicator para aplicaciones gtk3 que se proporciona por paquete gir1.2-appindicator3.

Aquí está la documentación de AppIndicator3 .

pygtk quedará en desuso para Gtk3 y deberá pasar por la ruta GObject-Introspection para desarrollar aplicaciones Gtk3 en python. Puede consultar la documentación de PyGObject . En lugar de

import pygtk, gtk, gdk, gobject, pango  

etc deberías hacer

from gi.repository import Gtk, Gdk, Pango, GObject  

Para estudiar un código de trabajo, puede ver Kazam que se ha movido a gtk3 desde gtk2 y usa appindicator3 .

También hay un paquete gir1.2-appindicatorque parece ser el mismo que el uso, python-appindicatorya que ambos proporcionan el uso para la aplicación gtk2 que es:

from gi.repository import AppIndicator

O

import appindicator

Alguna información en esta publicación de blog también.

Aquí hay una estúpida aplicación de andamio simple que tiene una ventana de configuración, una ventana principal y un indicador de aplicación.

#!/usr/bin/env python3.3

from gi.repository import Gtk
from gi.repository import AppIndicator3 as appindicator

class MyIndicator:
  def __init__(self, root):
    self.app = root
    self.ind = appindicator.Indicator.new(
                self.app.name,
                "indicator-messages",
                appindicator.IndicatorCategory.APPLICATION_STATUS)
    self.ind.set_status (appindicator.IndicatorStatus.ACTIVE)
    self.menu = Gtk.Menu()
    item = Gtk.MenuItem()
    item.set_label("Main Window")
    item.connect("activate", self.app.main_win.cb_show, '')
    self.menu.append(item)

    item = Gtk.MenuItem()
    item.set_label("Configuration")
    item.connect("activate", self.app.conf_win.cb_show, '')
    self.menu.append(item)

    item = Gtk.MenuItem()
    item.set_label("Exit")
    item.connect("activate", self.cb_exit, '')
    self.menu.append(item)

    self.menu.show_all()
    self.ind.set_menu(self.menu)

  def cb_exit(self, w, data):
     Gtk.main_quit()

class MyConfigWin(Gtk.Window):
  def __init__(self, root):
    super().__init__()
    self.app = root
    self.set_title(self.app.name + ' Config Window')

  def cb_show(self, w, data):
    self.show()

class MyMainWin(Gtk.Window):
  def __init__(self, root):
    super().__init__()
    self.app = root
    self.set_title(self.app.name)

  def cb_show(self, w, data):
    self.show()

class MyApp(Gtk.Application):
  def __init__(self, app_name):
    super().__init__()
    self.name = app_name
    self.main_win = MyMainWin(self)
    self.conf_win = MyConfigWin(self)
    self.indicator = MyIndicator(self)

  def run(self):
    Gtk.main()

if __name__ == '__main__':
  app = MyApp('Scaffold')
  app.run()

En caso de que alguien pueda encontrarlo útil, hice un indicador de aplicación mínima con Python, GIR y GTK3. Lee las velocidades de CPU de / proc / cpuinfo cada pocos segundos y las muestra.

Ver aquí: https://bitbucket.org/cpbotha/indicator-cpuspeed/src

Aquí hay un ejemplo de lectura de temperatura de la CPU. copie un icono llamado temp-icon.png / svg en el directorio del script

from gi.repository import Gtk, GLib
from gi.repository import AppIndicator3 as appindicator
import os

def cb_exit(w, data):
   Gtk.main_quit()

def cb_readcputemp(ind_app):
# get CPU temp
   fileh = open(
      '/sys/devices/platform/thinkpad_hwmon/subsystem/devices/coretemp.0/temp1_input',
    'r')
  ind_app.set_label(fileh.read(2), '')
  fileh.close()
  return 1


ind_app = appindicator.Indicator.new_with_path (
  "cputemp-indicator",
   "temp-icon",
   appindicator.IndicatorCategory.APPLICATION_STATUS,
    os.path.dirname(os.path.realpath(__file__)))
ind_app.set_status (appindicator.IndicatorStatus.ACTIVE)

# create a menu
menu = Gtk.Menu()
menu_items = Gtk.MenuItem("Exit")
menu.append(menu_items)
menu_items.connect("activate", cb_exit, '')
menu_items.show()
ind_app.set_menu(menu)
GLib.timeout_add(500, cb_readcputemp, ind_app)
Gtk.main()