Added process path context filter

src/client/FocusedWindow.h

@@ -15,6 +15,7 @@ class FocusedWindow {
   bool update();
   const std::string& window_class() const;
   const std::string& window_title() const;
+  const std::string& window_path() const;
   bool is_inaccessible() const;
 
 private:

src/client/linux/FocusedWindowImpl.cpp

@@ -69,3 +69,18 @@ const std::string& FocusedWindow::window_class() const {
 const std::string& FocusedWindow::window_title() const {
   return m_impl->window_title;
 }
+
+const std::string& FocusedWindow::window_path() const {
+  return m_impl->window_path;
+}
+
+//-------------------------------------------------------------------------
+
+std::string get_process_path_by_pid(int pid) {
+  char path[32];
+  std::sprintf(path, "/proc/%d/exe", pid);
+  const auto resolved = ::realpath(path, nullptr);
+  auto result = std::string(resolved);
+  ::free(resolved);
+  return result;
+}

src/client/linux/FocusedWindowImpl.h

@@ -7,6 +7,7 @@
 struct FocusedWindowData {
   std::string window_class;
   std::string window_title;
+  std::string window_path;
 };
 
 class FocusedWindowSystem {
@@ -24,3 +25,5 @@ class FocusedWindowImpl : public FocusedWindowData {
   void shutdown();
   bool update();
 };
+
+std::string get_process_path_by_pid(int pid);

src/client/linux/FocusedWindowX11.cpp

@@ -15,6 +15,7 @@ class FocusedWindowX11 : public FocusedWindowSystem {
   Window m_root_window{ };
   Atom m_net_active_window_atom{ };
   Atom m_net_wm_name_atom{ };
+  Atom m_net_wm_pid_atom{ };
   Atom m_utf8_string_atom{ };
   Window m_focused_window{ };
 
@@ -39,6 +40,7 @@ class FocusedWindowX11 : public FocusedWindowSystem {
     m_root_window = XRootWindow(m_display, 0);
     m_net_active_window_atom = XInternAtom(m_display, "_NET_ACTIVE_WINDOW", False);
     m_net_wm_name_atom = XInternAtom(m_display, "_NET_WM_NAME", False);
+    m_net_wm_pid_atom = XInternAtom(m_display, "_NET_WM_PID", False);
     m_utf8_string_atom = XInternAtom(m_display, "UTF8_STRING", False);
     XSetErrorHandler([](Display*, XErrorEvent*) { return 0; });
     return true;
@@ -53,12 +55,14 @@ class FocusedWindowX11 : public FocusedWindowSystem {
 
     // window handles can become invalid any time
     auto window_class = get_window_class(window);
-    if (window_class.empty() || window_title.empty())
+    auto window_path = get_window_path(window);
+    if (window_class.empty() || window_title.empty() || window_path.empty())
       return false;
 
     m_focused_window = window;
     m_data.window_class = std::move(window_class);
     m_data.window_title = std::move(window_title);
+    m_data.window_path = std::move(window_path);
     return true;
   }
 
@@ -109,6 +113,24 @@ class FocusedWindowX11 : public FocusedWindowSystem {
     }
     return { };
   }
+
+  std::string get_window_path(Window window) {
+    auto type = Atom{ };
+    auto format = 0;
+    auto length = 0ul;
+    auto rest = 0ul;
+    auto data = std::add_pointer_t<unsigned char>{ };
+    if (window &&
+        XGetWindowProperty(m_display, window, m_net_wm_pid_atom, 0, 1,
+          False, XA_CARDINAL, &type, &format, &length,
+          &rest, &data) == Success &&
+        data) {
+      const auto pid = *reinterpret_cast<unsigned long*>(data);
+      XFree(data);
+      return get_process_path_by_pid(pid);
+    }
+    return { };
+  }
 };
 
 std::unique_ptr<FocusedWindowSystem> make_focused_window_x11(FocusedWindowData* data) {

src/client/linux/main.cpp

@@ -44,8 +44,9 @@ namespace {
     const auto& contexts = g_config_file.config().contexts;
     const auto& window_class = g_focused_window.window_class();
     const auto& window_title = g_focused_window.window_title();
+    const auto& window_path = g_focused_window.window_path();
     for (auto i = 0; i < static_cast<int>(contexts.size()); ++i)
-      if (contexts[i].matches(window_class, window_title))
+      if (contexts[i].matches(window_class, window_title, window_path))
         g_active_contexts.push_back(i);
 
     return g_server.send_active_contexts(g_active_contexts);
@@ -85,6 +86,7 @@ namespace {
         verbose("Detected focused window changed:");
         verbose("  class = '%s'", g_focused_window.window_class().c_str());
         verbose("  title = '%s'", g_focused_window.window_title().c_str());
+        verbose("  path = '%s'", g_focused_window.window_path().c_str());
         if (!send_active_contexts())
           return;
       }

src/client/windows/FocusedWindow.cpp

@@ -1,6 +1,7 @@
 
 #include "client/FocusedWindow.h"
 #include "common/windows/win.h"
+#include <psapi.h>
 #include <array>
 #include <cstring>
 
@@ -25,11 +26,13 @@ class FocusedWindowImpl {
   std::wstring m_current_title;
   std::string m_class;
   std::string m_title;
+  std::string m_path;
 
 public:
   HWND current() const { return m_current_window; }
   const std::string& window_class() const { return m_class; }
   const std::string& window_title() const { return m_title; }
+  const std::string& window_path() const { return m_path; }
 
   bool update() {
     const auto hwnd = GetForegroundWindow();
@@ -50,6 +53,19 @@ class FocusedWindowImpl {
     GetClassNameW(hwnd, buffer.data(), static_cast<int>(buffer.size()));
     m_class = wide_to_utf8(buffer.data());
     m_title = wide_to_utf8(m_current_title);
+
+#if (PSAPI_VERSION >= 2)
+    m_path.clear();
+    auto pid = DWORD{ };
+    auto buffer_size = DWORD{ buffer.size() };
+    if (GetWindowThreadProcessId(hwnd, &pid))
+      if (const auto handle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid)) {
+        if (QueryFullProcessImageNameW(handle, 0, buffer.data(), &buffer_size))
+          m_path = wide_to_utf8(buffer.data());
+        CloseHandle(handle);
+      }
+#endif
+
     return true;
   }
 };
@@ -74,6 +90,10 @@ const std::string& FocusedWindow::window_title() const {
   return m_impl->window_title();
 }
 
+const std::string& FocusedWindow::window_path() const {
+  return m_impl->window_path();
+}
+
 bool FocusedWindow::is_inaccessible() const {
   if (auto hwnd = m_impl->current()) {
     auto process_id = DWORD{ };

src/client/windows/main.cpp

@@ -107,8 +107,10 @@ namespace {
     g_new_active_contexts.clear();
     if (g_active)
       for (auto i = 0; i < static_cast<int>(contexts.size()); ++i)
-        if (contexts[i].matches(g_focused_window.window_class(),
-            g_focused_window.window_title()))
+        if (contexts[i].matches(
+            g_focused_window.window_class(),
+            g_focused_window.window_title(),
+            g_focused_window.window_path()))
           g_new_active_contexts.push_back(i);
 
     if (force_send || g_new_active_contexts != g_current_active_contexts) {
@@ -139,6 +141,7 @@ namespace {
       verbose("Detected focused window changed:");
       verbose("  class = '%s'", g_focused_window.window_class().c_str());
       verbose("  title = '%s'", g_focused_window.window_title().c_str());
+      verbose("  path = '%s'", g_focused_window.window_path().c_str());
       update_active_contexts(false);
     }
   }

src/config/Config.h

@@ -36,17 +36,21 @@ struct Config {
     bool system_filter_matched;
     Filter window_class_filter;
     Filter window_title_filter;
+    Filter window_path_filter;
     std::string device_filter;
     std::vector<Input> inputs;
     std::vector<KeySequence> outputs;
     std::vector<CommandOutput> command_outputs;
 
     bool matches(const std::string& window_class,
-                 const std::string& window_title) const {
+                 const std::string& window_title,
+                 const std::string& window_path) const {
       if (!window_class_filter.matches(window_class, false))
         return false;
       if (!window_title_filter.matches(window_title, true))
         return false;
+      if (!window_path_filter.matches(window_path, true))
+        return false;
       return true;
     }
   };

src/config/ParseConfig.cpp

@@ -188,6 +188,7 @@ void ParseConfig::parse_context(It* it, const It end) {
   auto system_filter_matched = true;
   auto class_filter = Config::Filter();
   auto title_filter = Config::Filter();
+  auto path_filter = Config::Filter();
   auto device_filter = std::string();
   m_context_modifier = { };
 
@@ -213,6 +214,9 @@ void ParseConfig::parse_context(It* it, const It end) {
       else if (attrib == "title") {
         title_filter = read_filter(it, end);
       }
+      else if (attrib == "path") {
+        path_filter = read_filter(it, end);
+      }
       else if (attrib == "system") {
         system_filter_matched =
           (to_lower(read_value(it, end)) == current_system);
@@ -250,6 +254,7 @@ void ParseConfig::parse_context(It* it, const It end) {
     system_filter_matched,
     std::move(class_filter),
     std::move(title_filter),
+    std::move(path_filter),
     std::move(device_filter)
   });
 }

src/test/test1_ParseConfig.cpp

@@ -9,14 +9,17 @@ namespace {
     return parse(stream);
   }
 
-  int find_context(const Config& config, const char* window_class, const char* window_title) {
+  int find_context(const Config& config, 
+      const char* window_class, 
+      const char* window_title, 
+      const char* window_path = "") {
     const auto& contexts = config.contexts;
     // skip default context
     const auto begin = std::next(contexts.begin());
     const auto end = contexts.end();
     const auto it = std::find_if(begin, end,
       [&](const Config::Context& context) {
-        return context.matches(window_class, window_title);
+        return context.matches(window_class, window_title, window_path);
       });
     return (it == end ? 0 : std::distance(begin, it) + 1);
   }