• Stars
    star
    1,010
  • Rank 44,306 (Top 0.9 %)
  • Language Vala
  • Created over 7 years ago
  • Updated about 3 years ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

A searchable command palette in every modern GTK+ application

Only a compound can be beautiful, never anything devoid of parts; and only a whole;
the several parts will have beauty, not in themselves,
but only as working together to give a comely total.
Yet beauty in an aggregate demands beauty in details:
it cannot be constructed out of ugliness; its law must run throughout.

– Plotinus, First Ennead

Plotinus

A searchable command palette in every modern GTK+ application


Have you used Sublime Text's or Atom's "Command Palette"? It's a list of everything those editors can do that opens at the press of a key and finds the action you are looking for just by typing a few letters. It's raw power at your fingertips.

Plotinus brings that power to every application on your system (that is, to those that use the GTK+ 3 toolkit). It automatically extracts all available commands by introspecting a running application, instantly adapting to UI changes and showing only relevant actions. Using Plotinus requires no modifications to the application itself!

Just press Ctrl+Shift+P (configurable) and you're in business – it feels so natural you'll soon wonder how you ever lived without it.

Nautilus screencast

gedit screencast

Installation

Prerequisites

To build Plotinus from source, you need Git, CMake, Vala, and the GTK+ 3 development files. All of these are easily obtained on most modern Linux distributions:

Fedora / RHEL / etc.

sudo dnf install git cmake vala gtk3-devel

Ubuntu / Mint / Elementary / etc.

sudo apt-get install git cmake valac libgtk-3-dev

Building

git clone https://github.com/p-e-w/plotinus.git
cd plotinus
mkdir build
cd build
cmake ..
make
sudo make install

Enabling Plotinus in applications

Because of the complexity and clumsiness surrounding Linux environment variables, Plotinus is currently not enabled automatically. The easiest way to enable Plotinus for all applications on the system is to add the line

GTK3_MODULES=[libpath]

to /etc/environment, where [libpath] is the full, absolute path of libplotinus.so, which can be found using the command

whereis -b libplotinus

Alternatively, you can try Plotinus with individual applications by running them with

GTK3_MODULES=[libpath] application

from a terminal.

Configuration

Plotinus can be configured both globally and per application. Application settings take precedence over global settings. In the commands below, [application] can be either

  • default, in which case the setting is applied globally, or
  • the path of an application executable, without the leading slash and with all other slashes replaced by periods (e.g. /usr/bin/gedit -> usr.bin.gedit).

Note that the relevant path is the path of the process executable, which is not always identical to the executable being launched. For example, all GNOME JavaScript applications run the process /usr/bin/gjs.

Enabling/disabling the command palette

gsettings set com.worldwidemann.plotinus:/com/worldwidemann/plotinus/[application]/ enabled [true/false]

Changing the keyboard shortcut

gsettings set com.worldwidemann.plotinus:/com/worldwidemann/plotinus/[application]/ hotkeys '[keys]'

[keys] must be an array of strings in the format expected by gtk_accelerator_parse, e.g. ["<Primary><Shift>P", "<Primary>P"]. Each shortcut in the array opens the command palette.

Enabling/disabling D-Bus window registration

gsettings set com.worldwidemann.plotinus:/com/worldwidemann/plotinus/[application]/ dbus-enabled [true/false]

See the following section for details.

D-Bus API

Plotinus provides a simple but complete D-Bus API for developers who want to use its functionality from their own software. The API consists of two methods, exposed on the session bus at com.worldwidemann.plotinus:

  • GetCommands(window_path) -> (bus_name, command_paths)
    Takes the object path of a GTK+ window (which can e.g. be obtained from a Mutter window via meta_window_get_gtk_window_object_path) and returns an array of object paths referencing commands extracted from that window, as well as the name of the bus on which they are registered.
    The mechanism behind this method is somewhat similar to Ubuntu's AppMenu Registrar, but more lightweight and compatible with Wayland. Window registration must be enabled before using this method.

  • ShowCommandPalette(commands) -> (bus_name, command_palette_path)
    Takes an array of commands (structs of the form (path, label, accelerators)) and opens a command palette window displaying those commands. The returned object path references a control object registered on the returned bus name which provides signals on user interaction with the window.

Calls to these methods are processed by the Plotinus D-Bus service, which can be started with

plotinus

Examples

The following examples demonstrate how to use the D-Bus API from Python. They require pydbus to be installed and the Plotinus D-Bus service to be running.

Application remote control

#!/usr/bin/env python

import sys
from pydbus import SessionBus

bus = SessionBus()
plotinus = bus.get("com.worldwidemann.plotinus")

bus_name, command_paths = plotinus.GetCommands(sys.argv[1])
commands = [bus.get(bus_name, command_path) for command_path in command_paths]

for i, command in enumerate(commands):
  print("[%d] %s -> %s" % (i, " -> ".join(command.Path), command.Label))

index = raw_input("Number of command to execute: ")

if index:
  commands[int(index)].Execute()

Before running this example, enable window registration with

gsettings set com.worldwidemann.plotinus:/com/worldwidemann/plotinus/default/ dbus-enabled true

Then, run an application (e.g. gedit) with Plotinus enabled. Now run the script with the window object path as an argument, i.e.

./application_remote_control.py /org/gnome/gedit/window/1

Application launcher

Based on this Argos plugin, uses Plotinus' command palette to display a list of applications available on the system.

#!/usr/bin/env python

import os, re
from pydbus import SessionBus
from gi.repository import GLib, Gio

applications = {}

for app_info in Gio.AppInfo.get_all():
  categories = app_info.get_categories()
  if categories is None:
    continue
  # Remove "%U" and "%F" placeholders
  command_line = re.sub("%\\w", "", app_info.get_commandline()).strip()
  app = (app_info.get_name(), command_line)
  for category in categories.split(";"):
    if category not in ["GNOME", "GTK", ""]:
      if category not in applications:
        applications[category] = []
      applications[category].append(app)
      break

commands = []
command_lines = []

for category, apps in sorted(applications.items()):
  for app in sorted(apps):
    commands.append(([category], app[0], []))
    command_lines.append(app[1])

bus = SessionBus()
plotinus = bus.get("com.worldwidemann.plotinus")

bus_name, command_palette_path = plotinus.ShowCommandPalette(commands)
command_palette = bus.get(bus_name, command_palette_path)

loop = GLib.MainLoop()

def command_executed(index):
  os.system(command_lines[index])

command_palette.CommandExecuted.connect(command_executed)

def closed():
  # Wait for CommandExecuted signal
  GLib.timeout_add(500, loop.quit)

command_palette.Closed.connect(closed)

loop.run()

Acknowledgments

Documentation on GTK+ modules is essentially nonexisting. Without gtkparasite and gnome-globalmenu to learn from, it would have been a lot harder to get this project off the ground.

The CMake modules are copied verbatim from Elementary's pantheon-installer repository.

Vala is still the greatest thing ever to happen to Linux Desktop development.

Contributing

Contributors are always welcome. However, please file an issue describing what you intend to add before opening a pull request, especially for new features! I have a clear vision of what I want (and do not want) Plotinus to be, so discussing potential additions might help you avoid duplication and wasted work.

By contributing, you agree to release your changes under the same license as the rest of the project (see below).

License

Copyright Β© 2016-2017 Philipp Emanuel Weidmann ([email protected])

Released under the terms of the GNU General Public License, version 3

More Repositories

1

maybe

πŸ“‚ πŸ‡ 🎩 See what a program does before deciding whether you really want it to happen (NO LONGER MAINTAINED)
Python
6,362
star
2

finalterm

At last – a modern terminal emulator (NO LONGER MAINTAINED)
Vala
3,860
star
3

argos

Create GNOME Shell extensions in seconds
JavaScript
1,612
star
4

ternimal

Simulate a lifeform in the terminal
Rust
1,042
star
5

krill

πŸ“° The hacker's way of keeping up with the world (NO LONGER MAINTAINED)
Python
807
star
6

savage

A primitive computer algebra system
Rust
548
star
7

hegemon

A modular system monitor written in Rust
Rust
324
star
8

shin

A shell in every text input on your system
Go
265
star
9

ranwhen

Visualize when your system was running (NO LONGER MAINTAINED)
Python
262
star
10

language-javascript-semantic

JavaScript Semantic Highlighting Package for Atom (NO LONGER MAINTAINED)
JavaScript
82
star
11

GTKDarkThemeVariantSetter

Make Sublime Text use the dark GTK+ theme variant (NO LONGER MAINTAINED)
Python
51
star
12

quicksafe

The easiest way to securely encrypt notes (NO LONGER MAINTAINED)
Python
51
star
13

envy

Text editing supercharger
JavaScript
35
star
14

chatbot_clinic

Science-driven chatbot development
Python
27
star
15

sequencer

Purely algorithmic number sequence identification
Scala
25
star
16

pingpong

End-to-end latency monitoring for Matrix
Go
10
star
17

cal-ender

A modern, practical date model simplifying what people actually use a calendar for (NO LONGER MAINTAINED)
JavaScript
7
star
18

wd2sql

Transform a Wikidata JSON dump into an SQLite database
Rust
6
star
19

tree-saw

tree-sitter and compilers testing each other
JavaScript
4
star
20

pastevents

A structured, searchable archive of Wikipedia's "Current Events" portal
Python
3
star
21

enough

Rust
2
star
22

humergesort

Rank arbitrary lists through human-powered comparison sorting (NO LONGER MAINTAINED)
1
star
23

curv-solids

A library for working with polyhedra in Curv
1
star
24

graduality

Rust
1
star
25

arrows

A frontend for creative writing with LLMs
TypeScript
1
star