qi3pc.h

#ifndef QI3PC_H
#define QI3PC_H
 
#include "qi3pc_global.h"
#include <QtNetwork/qlocalsocket.h>
#include <QDebug>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QMutexLocker>
#include <QProcessEnvironment>
#include <QTime>
 
#include <i3/ipc.h>
 
#include <optional>
#include <string>

class QI3PCSHARED_EXPORT qi3pc : public QObject
{
  Q_OBJECT
 
public:
  // magic string used by the current API
  static constexpr auto IpcMagicString = std::string("i3-ipc");
  static constexpr auto IpcMagicLength = IpcMagicString.length();

  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,
    BindingState = I3_IPC_REPLY_TYPE_GET_BINDING_STATE
  };

  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 String = std::optional<std::pair<QString, qint64>>;
  using Error = std::optional<QString>;
  using Message = std::optional<std::pair<QJsonDocument, quint32>>;

  explicit qi3pc(QObject* parent = nullptr);

  virtual ~qi3pc();

  bool connect();

  bool isConnected();

  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 bindingModes() const;

  DataObject config() const;

  String bindingState() const;
 
public slots:
  void fetchWorkspaces();

  void fetchTree();

  void fetchOutputs();

  void fetchMarks();

  void fetchBarConfig(const QString& id);

  void fetchBarConfigs();

  void fetchVersion();

  void fetchBindingModes();

  void fetchConfig();

  void fetchBindingState();
 
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 processBindingModesReply(const QJsonDocument& doc);

  void processConfigReply(const QJsonDocument& doc);

  void processTickReply(const QJsonDocument& doc);

  void processSyncReply(const QJsonDocument& doc);

  void processBindingStateReply(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;
 
  void writeMagicString(QLocalSocket& socket) const;
 
  void writePayload(QLocalSocket& socket, const QByteArray& payload, IpcType type) 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_bindingModes; 
  String m_bindingState; 
  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 workspacesUpdated(const qi3pc::DataArray& workspaces);

  void treeUpdated(const qi3pc::DataObject& tree);

  void outputsUpdated(const qi3pc::DataArray& outputs);

  void marksUpdated(const qi3pc::DataArray& marks);

  void barConfigUpdated(const QJsonObject& config);

  void newBarConfig(const QString& id);

  void versionUpdated(const qi3pc::DataObject& version);

  void bindingModesUpdated(const qi3pc::DataArray& modes);

  void configUpdated(const qi3pc::DataObject& config);

  void bindingStateUpdated(const qi3pc::String& state);
};
 
#endif // QI3PC_H