hud-menu.py

#!python3

import dbus
import subprocess
import sys
from collections import defaultdict
import pickle
from os import environ
from os.path import join


MRU_FILE = join(environ['HOME'], '.hud_item_prios.pickle')
UNSEEN_ITEM_MRU_SCORE = float('inf')


def pickle_dump(obj, file_path, allow_exists=False):
    """convenience wrapper around pickle.dump that opens the file for you

       see also: pickle_load(...)
    """
    mode = 'wb' if allow_exists else 'xb'
    with open(file_path, mode=mode) as f:
        pickle.dump(obj, f)


def pickle_load(file_path):
    """convenience wrapper around pickle.load that opens the file for you

       see also: pickle_dump(...)
    """
    with open(file_path, mode='rb') as f:
        return pickle.load(f)


def mru_sort_menu_items(items, mru_file=MRU_FILE):
    try:
        mru_list = pickle_load(mru_file)
    except:
        mru_list = []

    mru_scores = defaultdict(lambda: UNSEEN_ITEM_MRU_SCORE)
    mru_scores.update({item: i for i, item in enumerate(mru_list)})

    items = sorted(items, key=lambda k: (mru_scores[k], k))
    return items, mru_scores


def update_mru(used, prev_mru, mru_file=MRU_FILE):
    prev_mru[used] = -1
    mru_list = [e for e in prev_mru if prev_mru[e] < UNSEEN_ITEM_MRU_SCORE]
    mru_list = sorted(mru_list, key=lambda k: (prev_mru[k], k))
    pickle_dump(mru_list, mru_file, allow_exists=True)


"""
  format_label_list
"""
def format_label_list(label_list):
  head, *tail = label_list
  result = head
  for label in tail:
    result = result + " > " + label
  result = result.replace("Root > ", "")
  result = result.replace("_", "")
  return result

"""
  try_appmenu_interface
"""
def try_appmenu_interface(window_id):
  # --- Get Appmenu Registrar DBus interface
  session_bus = dbus.SessionBus()
  appmenu_registrar_object = session_bus.get_object('com.canonical.AppMenu.Registrar', '/com/canonical/AppMenu/Registrar')
  appmenu_registrar_object_iface = dbus.Interface(appmenu_registrar_object, 'com.canonical.AppMenu.Registrar')

  # --- Get dbusmenu object path
  try:
    dbusmenu_bus, dbusmenu_object_path = appmenu_registrar_object_iface.GetMenuForWindow(window_id)
  except dbus.exceptions.DBusException:
    return

  # --- Access dbusmenu items
  dbusmenu_object = session_bus.get_object(dbusmenu_bus, dbusmenu_object_path)
  dbusmenu_object_iface = dbus.Interface(dbusmenu_object, 'com.canonical.dbusmenu')
  dbusmenu_items = dbusmenu_object_iface.GetLayout(0, -1, ["label"])

  dbusmenu_item_dict = dict()

  #For excluding items which have no action
  blacklist = [] 

  """ explore_dbusmenu_item """
  def explore_dbusmenu_item(item, label_list):
    item_id = item[0]
    item_props = item[1]

    item_children = item[2]

    if 'label' in item_props:
      new_label_list = label_list + [item_props['label']]
    else:
      new_label_list = label_list

    if len(item_children) == 0:
      if new_label_list not in blacklist:
        dbusmenu_item_dict[format_label_list(new_label_list)] = item_id
    else:
      blacklist.append(new_label_list)
      for child in item_children:
        explore_dbusmenu_item(child, new_label_list)

  explore_dbusmenu_item(dbusmenu_items[1], [])

  menuKeys, _mru_scores = mru_sort_menu_items(dbusmenu_item_dict.keys())

  # --- Run rofi/dmenu
  menu_string = ''
  head, *tail = menuKeys
  menu_string = head
  for m in tail:
    menu_string += '\n'
    menu_string += m

  if 'dmenu' in sys.argv:
    menu_cmd = subprocess.Popen(['dmenu', '-i', '-l', '15'], stdout=subprocess.PIPE, stdin=subprocess.PIPE)
  else:
    menu_cmd = subprocess.Popen(['rofi', '-dmenu', '-i', '-location', '1', '-width', '100', '-l', '15', '-scroll-method', '1', '-color-enabled', '-color-window', "#242424, #ffffff", '-color-normal', "#242424, #FFFFFF, #242424, #398ee7", '-separator-style', 'solid', '-p', ''], stdout=subprocess.PIPE, stdin=subprocess.PIPE)
  menu_cmd.stdin.write(menu_string.encode('utf-8'))
  menu_result = menu_cmd.communicate()[0].decode('utf8').rstrip()
  menu_cmd.stdin.close()

  if menu_result.endswith("\n"):
    menu_result = menu_result[:-1]

  # --- Use menu result
  if menu_result in dbusmenu_item_dict:
    action = dbusmenu_item_dict[menu_result]
    dbusmenu_object_iface.Event(action, 'clicked', 0, 0)

    update_mru(menu_result, _mru_scores)


"""
  try_gtk_interface
"""
def try_gtk_interface(gtk_bus_name_cmd, gtk_object_path_cmd):
  gtk_bus_name = gtk_bus_name_cmd.split(' ')[2].split('\n')[0].split('"')[1]
  # print(gtk_object_path_cmd)
  gtk_object_path = gtk_object_path_cmd.split(' ')[2].split('\n')[0].split('"')[1]
  # print("GTK MenuModel Bus name and object path: ", gtk_bus_name, gtk_object_path)

  # --- Ask for menus over DBus ---
  session_bus = dbus.SessionBus()
  gtk_menubar_object = session_bus.get_object(gtk_bus_name, gtk_object_path)
  gtk_menubar_object_iface = dbus.Interface(gtk_menubar_object, dbus_interface='org.gtk.Menus')
  gtk_action_object_actions_iface = dbus.Interface(gtk_menubar_object, dbus_interface='org.gtk.Actions')
  gtk_menubar_results = gtk_menubar_object_iface.Start([x for x in range(1024)])

  # --- Construct menu list ---
  gtk_menubar_menus = dict()
  for gtk_menubar_result in gtk_menubar_results:
    gtk_menubar_menus[(gtk_menubar_result[0], gtk_menubar_result[1])] = gtk_menubar_result[2]

  gtk_menubar_action_dict = dict()
 # gtk_menubar_target_dict = dict()

  """ explore_menu """
  def explore_menu(menu_id, label_list):
    if menu_id in gtk_menubar_menus:
      for menu in gtk_menubar_menus[menu_id]:
        if 'label' in menu:
          menu_label = menu['label']
          new_label_list = label_list + [menu_label]
          formatted_label = format_label_list(new_label_list)

          if 'action' in menu:
            menu_action = menu['action']
            if ':section' not in menu and ':submenu' not in menu:
              gtk_menubar_action_dict[formatted_label] = menu_action
            # if 'target' in menu:
             # menu_target = menu['target']
             # gtk_menubar_target_dict[formatted_label] = menu_target

        if ':section' in menu:
          menu_section = menu[':section']
          section_menu_id = (menu_section[0], menu_section[1])
          explore_menu(section_menu_id, label_list)

        if ':submenu' in menu:
          menu_submenu = menu[':submenu']
          submenu_menu_id = (menu_submenu[0], menu_submenu[1])
          explore_menu(submenu_menu_id, new_label_list)

  explore_menu((0,0), [])

  menuKeys, _mru_scores = mru_sort_menu_items(gtk_menubar_action_dict.keys())

  # --- Run rofi/dmenu
  menu_string = ''
  head, *tail = menuKeys
  menu_string = head
  for m in tail:
    menu_string += '\n'
    menu_string += m

  if 'dmenu' in sys.argv:
    menu_cmd = subprocess.Popen(['dmenu', '-i', '-l', '15'], stdout=subprocess.PIPE, stdin=subprocess.PIPE)
  else:
    menu_cmd = subprocess.Popen(['rofi', '-dmenu', '-i', '-location', '1', '-width', '100', '-l', '15', '-scroll-method', '1', '-color-enabled', '-color-window', "#242424, #ffffff", '-color-normal', "#242424, #FFFFFF, #242424, #398ee7", '-separator-style', 'solid', '-p', ''], stdout=subprocess.PIPE, stdin=subprocess.PIPE)
  menu_cmd.stdin.write(menu_string.encode('utf-8'))
  menu_result = menu_cmd.communicate()[0].decode('utf8').rstrip()
  menu_cmd.stdin.close()

  if menu_result.endswith("\n"):
    menu_result = menu_result[:-1]

  # --- Use menu result
  if menu_result in gtk_menubar_action_dict:
    action = gtk_menubar_action_dict[menu_result]
    # print('GTK Action :', action)
    gtk_action_object_actions_iface.Activate(action.replace('unity.', ''), [], dict())

    update_mru(menu_result, _mru_scores)


"""
  main
"""

# --- Get X Window ID ---
window_id_cmd = subprocess.check_output(['xprop', '-root', '-notype', '_NET_ACTIVE_WINDOW']).decode('utf-8')
window_id = window_id_cmd.split(' ')[4].split(',')[0].split('\n')[0]

# For testing get the id of the target window from xwininfo
# window_id = '0x3400186'
# print('Window id is :', window_id)

# --- Get GTK MenuModel Bus name ---
gtk_bus_name_cmd = subprocess.check_output(['xprop', '-id', window_id, '-notype', '_GTK_UNIQUE_BUS_NAME']).decode('utf-8')
gtk_object_path_cmd = subprocess.check_output(['xprop', '-id', window_id, '-notype', '_GTK_MENUBAR_OBJECT_PATH']).decode('utf-8')

# print(gtk_bus_name_cmd)

if (gtk_bus_name_cmd == '_GTK_UNIQUE_BUS_NAME:  not found.\n' or
 gtk_bus_name_cmd == '_GTK_UNIQUE_BUS_NAME:  no such atom on any window.\n' or
 gtk_object_path_cmd == '_GTK_MENUBAR_OBJECT_PATH:  not found.\n'):
  try_appmenu_interface(int(window_id, 16))
else:
  try_gtk_interface(gtk_bus_name_cmd, gtk_object_path_cmd)