ipc.hpp

#pragma once

#include <cstdint>
#include <string>
#include <memory>
#include <vector>
#include <map>

#include <sigc++/sigc++.h>

extern "C" {
#include <i3/ipc.h>
}

namespace i3ipc {

std::string  get_socketpath();

struct rect_t {
    int  x; 
    int  y; 
    int  width; 
    int  height; 
};

struct workspace_t {
    int  num; 
    std::string  name; 
    bool  visible; 
    bool  focused; 
    bool  urgent; 
    rect_t  rect; 
    std::string  output; 
};

struct output_t {
    std::string  name; 
    bool  active; 
    std::string  current_workspace; 
    rect_t  rect; 
};

struct version_t {
    std::string  human_readable; 
    std::string  loaded_config_file_name; 
    uint32_t  major; 
    uint32_t  minor; 
    uint32_t  patch; 
};


enum EventType {
    ET_WORKSPACE = (1 << 0), 
    ET_OUTPUT = (1 << 1), 
    ET_MODE = (1 << 2), 
    ET_WINDOW = (1 << 3), 
    ET_BARCONFIG_UPDATE = (1 << 4), 
    ET_BINDING = (1 << 5), 
};

enum class WorkspaceEventType : char {
    FOCUS = 'f', 
    INIT = 'i', 
    EMPTY = 'e', 
    URGENT = 'u', 
};

enum class WindowEventType : char {
    NEW = 'n', 
    CLOSE = 'c', 
    FOCUS = 'f', 
    TITLE = 't', 
    FULLSCREEN_MODE = 'F', 
    MOVE = 'M', 
    FLOATING = '_', 
    URGENT = 'u', 
};


enum class BorderStyle : char {
    UNKNOWN = '?', //< If got an unknown border style in reply
    NONE = 'N',
    NORMAL = 'n',
    PIXEL = 'P',
    ONE_PIXEL = '1',
};


enum class ContainerLayout : char {
    UNKNOWN = '?', //< If got an unknown border style in reply
    SPLIT_H = 'h',
    SPLIT_V = 'v',
    STACKED = 's',
    TABBED = 't',
    DOCKAREA = 'd',
    OUTPUT = 'o',
};


enum class InputType : char {
    UNKNOWN = '?', //< If got an unknown input_type in binding_event
    KEYBOARD = 'k',
    MOUSE = 'm',
};


enum class BarMode : char {
    UNKNOWN = '?',
    DOCK = 'd', 
    HIDE = 'h', 
};


enum class Position : char {
    UNKNOWN = '?',
    TOP = 't',
    BOTTOM = 'b',
};


struct container_t {
    uint64_t  id; 
    uint64_t  xwindow_id; 
    std::string  name; 
    std::string  type; 
    BorderStyle  border; 
    std::string  border_raw; 
    uint32_t  current_border_width; 
    ContainerLayout  layout; 
    std::string  layout_raw; 
    float  percent; 
    rect_t  rect; 
    rect_t  window_rect; 
    rect_t  deco_rect; 
    rect_t  geometry; 
    bool  urgent;
    bool  focused;

    std::list< std::shared_ptr<container_t> >  nodes;
};


struct workspace_event_t {
    WorkspaceEventType  type;
    std::shared_ptr<workspace_t>  current; 
    std::shared_ptr<workspace_t>  old; 
};


struct window_event_t {
    WindowEventType  type;
    std::shared_ptr<container_t>  container; 
};


struct binding_t {
    std::string  command; 
    std::vector<std::string>  event_state_mask; 
    int32_t  input_code; 
    std::string  symbol; 
    InputType  input_type;
};


struct bar_config_t {
    std::string  id; 
    BarMode  mode;
    Position  position;
    std::string  status_command; 
    std::string  font; 
    bool  workspace_buttons; 
    bool  binding_mode_indicator; 
    bool  verbose; 
    std::map<std::string, uint32_t>  colors; 
};


struct buf_t;
class connection {
public:
    connection(const std::string&  socket_path = get_socketpath());
    ~connection();

    bool  send_command(const std::string&  command) const;

    std::vector< std::shared_ptr<workspace_t> >  get_workspaces() const;

    std::vector< std::shared_ptr<output_t> >  get_outputs() const;

    version_t  get_version() const;

    std::shared_ptr<container_t>  get_tree() const;

    std::vector<std::string>  get_bar_configs_list() const;

    std::shared_ptr<bar_config_t>  get_bar_config(const std::string&  name) const;

    bool  subscribe(const int32_t  events);

    void  handle_event();

    int32_t get_main_socket_fd();

    int32_t get_event_socket_fd();

    sigc::signal<void, const workspace_event_t&>  signal_workspace_event; 
    sigc::signal<void>  signal_output_event; 
    sigc::signal<void>  signal_mode_event; 
    sigc::signal<void, const window_event_t&>  signal_window_event; 
    sigc::signal<void, const bar_config_t&>  signal_barconfig_update_event; 
    sigc::signal<void, const binding_t&>  signal_binding_event; 
    sigc::signal<void, EventType, const std::shared_ptr<const buf_t>&>  signal_event; 
protected:
    void  prepare_to_event_handling();
private:
    const int32_t  m_main_socket;
    int32_t  m_event_socket;
    int32_t  m_subscriptions;
    const std::string  m_socket_path;
};

const version_t&  get_version();

}