qi3pc.h

#ifndef QI3PC_H
#define QI3PC_H
 
#include "QtNetwork/qlocalsocket.h"
#include "qi3pc_global.h"
#include <QDebug>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QLocalSocket>
#include <QMutexLocker>
#include <QProcessEnvironment>
#include <QTime>
#include <i3/ipc.h>
#include <optional>
 
class QI3PCSHARED_EXPORT qi3pc : public QObject
{
  Q_OBJECT
 
public:
  // magic string used by the current API
  static constexpr auto IpcMagicString = I3_IPC_MAGIC;
  static constexpr auto IpcMagicLength = 6;
 
  enum class IpcEvent : quint32
  {
    Workspace = I3_IPC_EVENT_WORKSPACE,
    Output = I3_IPC_EVENT_OUTPUT,
    Mode = I3_IPC_EVENT_MODE,
    Window = I3_IPC_EVENT_WINDOW,
    BarUpdate = I3_IPC_EVENT_BARCONFIG_UPDATE,
    Binding = I3_IPC_EVENT_BINDING,
    Shutdown = I3_IPC_EVENT_SHUTDOWN,
    Tick = I3_IPC_EVENT_TICK
  };
 
  enum class IpcType : quint32
  {
    Command = I3_IPC_REPLY_TYPE_COMMAND,
    Workspaces = I3_IPC_REPLY_TYPE_WORKSPACES,
    Subscribe = I3_IPC_REPLY_TYPE_SUBSCRIBE,
    Outputs = I3_IPC_REPLY_TYPE_OUTPUTS,
    Tree = I3_IPC_REPLY_TYPE_TREE,
    Marks = I3_IPC_REPLY_TYPE_MARKS,
    BarConfig = I3_IPC_REPLY_TYPE_BAR_CONFIG,
    Version = I3_IPC_REPLY_TYPE_VERSION,
    BindingModes = I3_IPC_REPLY_TYPE_BINDING_MODES,
    Config = I3_IPC_REPLY_TYPE_CONFIG,
    Tick = I3_IPC_REPLY_TYPE_TICK,
    Sync = I3_IPC_REPLY_TYPE_SYNC
  };
 
  enum class WorkspaceChange
  {
    Focus,
    Init,
    Empty,
    Urgent,
    Reload,
    Rename,
    Restored,
    Move,
    Unknown
  };
 
  enum class OutputChange
  {
    Unspecified, 
    Unknown      
  };
 
  enum class WindowChange
  {
    New,        
    Close,      
    Focus,      
    Title,      
    Fullscreen, 
    Move,       
    Floating,   
    Urgent,     
    Mark,       
    Unknown     
  };
 
  enum class ShutdownChange
  {
    Restart, 
    Exit,    
    Unknown  
  };
 
  enum class BindingChange
  {
    Run,    
    Unknown 
  };
 
  using DataObject = std::optional<std::pair<QJsonObject, qint64>>;
 
  using DataArray = std::optional<std::pair<QJsonArray, qint64>>;
  using Error = std::optional<QString>;
  using Message = std::optional<std::pair<QJsonDocument, quint32>>;
 
  explicit qi3pc(QObject* parent = nullptr);
 
  virtual ~qi3pc();
 
  bool connect();
 
  bool connected();
 
  bool disconnect();
 
  void subscribe(const QStringList& events);
 
  QString socketPath() const;
 
  void sendMessage(IpcType type, const QByteArray& payload = QByteArray());
 
  DataArray workspaces() const;
 
  DataObject tree() const;
 
  DataArray outputs() const;
 
  DataArray marks() const;
 
  DataObject barConfigs() const;
 
  DataObject version() const;
 
  DataArray modes() const;
 
  DataObject config() const;
 
private:
  Message processMessage(QLocalSocket& socket);
 
  void processEvent();
 
  void processReply();
 
  void processWorkspaceEvent(const QJsonDocument& doc);
 
  void processOutputEvent(const QJsonDocument& doc);
 
  void processModeEvent(const QJsonDocument& doc);
 
  void processWindowEvent(const QJsonDocument& doc);
 
  void processBarUpdateEvent(const QJsonDocument& doc);
 
  void processBindingEvent(const QJsonDocument& doc);
 
  void processShutdownEvent(const QJsonDocument& doc);
 
  void processTickEvent(const QJsonDocument& doc);
 
  void processCommandReply(const QJsonDocument& doc);
 
  void processWorkspaceReply(const QJsonDocument& doc);
 
  void processOutputReply(const QJsonDocument& doc);
 
  void processTreeReply(const QJsonDocument& doc);
 
  void processMarkReply(const QJsonDocument& doc);
 
  void processBarConfigReply(const QJsonDocument& doc);
 
  void processVersionReply(const QJsonDocument& doc);
 
  void processModeReply(const QJsonDocument& doc);
 
  void processConfigReply(const QJsonDocument& doc);
 
  void processTickReply(const QJsonDocument& doc);
 
  void processSyncReply(const QJsonDocument& doc);
 
  WorkspaceChange workspaceChangeFromString(const QString& s) const;
 
  WindowChange windowChangeFromString(const QString& s) const;
 
  ShutdownChange shutdownChangeFromString(const QString& s) const;
 
  OutputChange outputChangeFromString(const QString& s) const;
 
  BindingChange bindingChangeFromString(const QString& s) const;
 
private:
  QString m_socketPath; 
  QLocalSocket m_eventSocket; 
  QLocalSocket m_messageSocket; 
  DataObject m_tree;       
  DataArray m_workspaces;  
  DataArray m_outputs;     
  DataArray m_marks;       
  DataObject m_barConfigs; 
  DataObject m_version;    
  DataArray m_modes;       
  DataObject m_config;     
signals:
  void commandRan(bool success, qi3pc::Error error);
 
  void tickSent(bool success);
 
  void synced(bool success);
 
  void subscribed(bool success);
 
  void workspaceEvent(qi3pc::WorkspaceChange change,
                      const QJsonObject& current,
                      const QJsonObject& old);
  void outputEvent(qi3pc::OutputChange change);
 
  void modeEvent(QString change, bool pango);
 
  void windowEvent(qi3pc::WindowChange change, const QJsonObject& container);
 
  void barUpdateEvent(const QJsonObject& doc);
 
  void bindingEvent(qi3pc::BindingChange change, const QJsonObject& binding);
 
  void shutdownEvent(qi3pc::ShutdownChange change);
 
  void tickEvent(bool first, const QJsonObject& payload);
 
  void fetchWorkspaces();
 
  void workspacesUpdated(const qi3pc::DataArray& workspaces);
 
  void fetchTree();
 
  void treeUpdated(const qi3pc::DataObject& tree);
 
  void fetchOutputs();
 
  void outputsUpdated(const qi3pc::DataArray& outputs);
 
  void fetchMarks();
 
  void marksUpdated(const qi3pc::DataArray& marks);
 
  void fetchBarConfig(const QString& id);
 
  void fetchBarConfigs();
 
  void barConfigUpdated(const QJsonObject& config);
 
  void newBarConfig(const QString& id);
 
  void fetchVersion();
 
  void versionUpdated(const qi3pc::DataObject& version);
 
  void fetchModes();
 
  void modesUpdated(const qi3pc::DataArray& modes);
 
  void fetchConfig();
 
  void configUpdated(const qi3pc::DataObject& config);
};
 
#endif // QI3PC_H