--- /dev/null
+TOPDIR=$(shell pwd)
+
+include $(TOPDIR)/common.mk
+
+FILES:=$(wildcard src/*.c)
+FILES:=$(FILES:.c=.o)
+HEADERS:=$(wildcard include/*.h)
+
+all: ${FILES}
+ echo "LINK"
+ $(CC) -o i3bar ${FILES} ${LDFLAGS}
+
+src/%.o: src/%.c ${HEADERS}
+ echo "CC $<"
+ $(CC) $(CFLAGS) -c -o $@ $<
+
+clean:
+ rm src/*.o
--- /dev/null
+CFLAGS += -Wall
+CFLAGS += -pipe
+CFLAGS += -Iinclude
+CFLAGS += -g
+LDFLAGS += -lev
+LDFLAGS += -lyajl
+LDFLAGS += -lxcb
+LDFLAGS += -lxcb-atom
+.SILENT:
--- /dev/null
+#ifndef COMMON_H_
+#define COMMON_H_
+
+#include "util.h"
+
+typedef int bool;
+
+typedef struct rect_t rect;
+
+struct rect_t {
+ int x;
+ int y;
+ int w;
+ int h;
+};
+
+struct ev_loop* main_loop;
+
+#endif
--- /dev/null
+#ifndef IPC_H_
+#define IPC_H_
+
+#include <ev.h>
+
+ev_io* i3_events;
+ev_io* outputs_watcher;
+ev_io* workspaces_watcher;
+
+void init_i3(const char* socket_path);
+void get_outputs_json(void (*callback)(char*, void*), void* params);
+void get_workspaces_json(void (*callback)(char*, void*), void* params);
+
+#endif
--- /dev/null
+#ifndef OUTPUTS_H_
+#define OUTPUTS_H_
+
+#include "common.h"
+#include <xcb/xcb.h>
+
+typedef struct i3_output_t i3_output;
+
+i3_output* outputs;
+
+void refresh_outputs();
+void free_outputs();
+i3_output* get_output_by_name(char* name);
+
+struct i3_output_t {
+ char* name;
+ bool active;
+ int ws;
+ rect rect;
+
+ xcb_window_t win;
+ xcb_gcontext_t gctx;
+
+ i3_output* next;
+};
+
+#endif
--- /dev/null
+/* $OpenBSD: queue.h,v 1.1 2007/10/26 03:14:08 niallo Exp $ */
+/* $NetBSD: queue.h,v 1.11 1996/05/16 05:17:14 mycroft Exp $ */
+
+/*
+ * Copyright (c) 1991, 1993
+ * The Regents of the University of California. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)queue.h 8.5 (Berkeley) 8/20/94
+ */
+
+#ifndef _SYS_QUEUE_H_
+#define _SYS_QUEUE_H_
+
+/*
+ * This file defines five types of data structures: singly-linked lists,
+ * lists, simple queues, tail queues, and circular queues.
+ *
+ *
+ * A singly-linked list is headed by a single forward pointer. The elements
+ * are singly linked for minimum space and pointer manipulation overhead at
+ * the expense of O(n) removal for arbitrary elements. New elements can be
+ * added to the list after an existing element or at the head of the list.
+ * Elements being removed from the head of the list should use the explicit
+ * macro for this purpose for optimum efficiency. A singly-linked list may
+ * only be traversed in the forward direction. Singly-linked lists are ideal
+ * for applications with large datasets and few or no removals or for
+ * implementing a LIFO queue.
+ *
+ * A list is headed by a single forward pointer (or an array of forward
+ * pointers for a hash table header). The elements are doubly linked
+ * so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before
+ * or after an existing element or at the head of the list. A list
+ * may only be traversed in the forward direction.
+ *
+ * A simple queue is headed by a pair of pointers, one the head of the
+ * list and the other to the tail of the list. The elements are singly
+ * linked to save space, so elements can only be removed from the
+ * head of the list. New elements can be added to the list before or after
+ * an existing element, at the head of the list, or at the end of the
+ * list. A simple queue may only be traversed in the forward direction.
+ *
+ * A tail queue is headed by a pair of pointers, one to the head of the
+ * list and the other to the tail of the list. The elements are doubly
+ * linked so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before or
+ * after an existing element, at the head of the list, or at the end of
+ * the list. A tail queue may be traversed in either direction.
+ *
+ * A circle queue is headed by a pair of pointers, one to the head of the
+ * list and the other to the tail of the list. The elements are doubly
+ * linked so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before or after
+ * an existing element, at the head of the list, or at the end of the list.
+ * A circle queue may be traversed in either direction, but has a more
+ * complex end of list detection.
+ *
+ * For details on the use of these macros, see the queue(3) manual page.
+ */
+
+#if defined(QUEUE_MACRO_DEBUG) || (defined(_KERNEL) && defined(DIAGNOSTIC))
+#define _Q_INVALIDATE(a) (a) = ((void *)-1)
+#else
+#define _Q_INVALIDATE(a)
+#endif
+
+/*
+ * Singly-linked List definitions.
+ */
+#define SLIST_HEAD(name, type) \
+struct name { \
+ struct type *slh_first; /* first element */ \
+}
+
+#define SLIST_HEAD_INITIALIZER(head) \
+ { NULL }
+
+#define SLIST_ENTRY(type) \
+struct { \
+ struct type *sle_next; /* next element */ \
+}
+
+/*
+ * Singly-linked List access methods.
+ */
+#define SLIST_FIRST(head) ((head)->slh_first)
+#define SLIST_END(head) NULL
+#define SLIST_EMPTY(head) (SLIST_FIRST(head) == SLIST_END(head))
+#define SLIST_NEXT(elm, field) ((elm)->field.sle_next)
+
+#define SLIST_FOREACH(var, head, field) \
+ for((var) = SLIST_FIRST(head); \
+ (var) != SLIST_END(head); \
+ (var) = SLIST_NEXT(var, field))
+
+#define SLIST_FOREACH_PREVPTR(var, varp, head, field) \
+ for ((varp) = &SLIST_FIRST((head)); \
+ ((var) = *(varp)) != SLIST_END(head); \
+ (varp) = &SLIST_NEXT((var), field))
+
+/*
+ * Singly-linked List functions.
+ */
+#define SLIST_INIT(head) { \
+ SLIST_FIRST(head) = SLIST_END(head); \
+}
+
+#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \
+ (elm)->field.sle_next = (slistelm)->field.sle_next; \
+ (slistelm)->field.sle_next = (elm); \
+} while (0)
+
+#define SLIST_INSERT_HEAD(head, elm, field) do { \
+ (elm)->field.sle_next = (head)->slh_first; \
+ (head)->slh_first = (elm); \
+} while (0)
+
+#define SLIST_REMOVE_NEXT(head, elm, field) do { \
+ (elm)->field.sle_next = (elm)->field.sle_next->field.sle_next; \
+} while (0)
+
+#define SLIST_REMOVE_HEAD(head, field) do { \
+ (head)->slh_first = (head)->slh_first->field.sle_next; \
+} while (0)
+
+#define SLIST_REMOVE(head, elm, type, field) do { \
+ if ((head)->slh_first == (elm)) { \
+ SLIST_REMOVE_HEAD((head), field); \
+ } else { \
+ struct type *curelm = (head)->slh_first; \
+ \
+ while (curelm->field.sle_next != (elm)) \
+ curelm = curelm->field.sle_next; \
+ curelm->field.sle_next = \
+ curelm->field.sle_next->field.sle_next; \
+ _Q_INVALIDATE((elm)->field.sle_next); \
+ } \
+} while (0)
+
+/*
+ * List definitions.
+ */
+#define LIST_HEAD(name, type) \
+struct name { \
+ struct type *lh_first; /* first element */ \
+}
+
+#define LIST_HEAD_INITIALIZER(head) \
+ { NULL }
+
+#define LIST_ENTRY(type) \
+struct { \
+ struct type *le_next; /* next element */ \
+ struct type **le_prev; /* address of previous next element */ \
+}
+
+/*
+ * List access methods
+ */
+#define LIST_FIRST(head) ((head)->lh_first)
+#define LIST_END(head) NULL
+#define LIST_EMPTY(head) (LIST_FIRST(head) == LIST_END(head))
+#define LIST_NEXT(elm, field) ((elm)->field.le_next)
+
+#define LIST_FOREACH(var, head, field) \
+ for((var) = LIST_FIRST(head); \
+ (var)!= LIST_END(head); \
+ (var) = LIST_NEXT(var, field))
+
+/*
+ * List functions.
+ */
+#define LIST_INIT(head) do { \
+ LIST_FIRST(head) = LIST_END(head); \
+} while (0)
+
+#define LIST_INSERT_AFTER(listelm, elm, field) do { \
+ if (((elm)->field.le_next = (listelm)->field.le_next) != NULL) \
+ (listelm)->field.le_next->field.le_prev = \
+ &(elm)->field.le_next; \
+ (listelm)->field.le_next = (elm); \
+ (elm)->field.le_prev = &(listelm)->field.le_next; \
+} while (0)
+
+#define LIST_INSERT_BEFORE(listelm, elm, field) do { \
+ (elm)->field.le_prev = (listelm)->field.le_prev; \
+ (elm)->field.le_next = (listelm); \
+ *(listelm)->field.le_prev = (elm); \
+ (listelm)->field.le_prev = &(elm)->field.le_next; \
+} while (0)
+
+#define LIST_INSERT_HEAD(head, elm, field) do { \
+ if (((elm)->field.le_next = (head)->lh_first) != NULL) \
+ (head)->lh_first->field.le_prev = &(elm)->field.le_next;\
+ (head)->lh_first = (elm); \
+ (elm)->field.le_prev = &(head)->lh_first; \
+} while (0)
+
+#define LIST_REMOVE(elm, field) do { \
+ if ((elm)->field.le_next != NULL) \
+ (elm)->field.le_next->field.le_prev = \
+ (elm)->field.le_prev; \
+ *(elm)->field.le_prev = (elm)->field.le_next; \
+ _Q_INVALIDATE((elm)->field.le_prev); \
+ _Q_INVALIDATE((elm)->field.le_next); \
+} while (0)
+
+#define LIST_REPLACE(elm, elm2, field) do { \
+ if (((elm2)->field.le_next = (elm)->field.le_next) != NULL) \
+ (elm2)->field.le_next->field.le_prev = \
+ &(elm2)->field.le_next; \
+ (elm2)->field.le_prev = (elm)->field.le_prev; \
+ *(elm2)->field.le_prev = (elm2); \
+ _Q_INVALIDATE((elm)->field.le_prev); \
+ _Q_INVALIDATE((elm)->field.le_next); \
+} while (0)
+
+/*
+ * Simple queue definitions.
+ */
+#define SIMPLEQ_HEAD(name, type) \
+struct name { \
+ struct type *sqh_first; /* first element */ \
+ struct type **sqh_last; /* addr of last next element */ \
+}
+
+#define SIMPLEQ_HEAD_INITIALIZER(head) \
+ { NULL, &(head).sqh_first }
+
+#define SIMPLEQ_ENTRY(type) \
+struct { \
+ struct type *sqe_next; /* next element */ \
+}
+
+/*
+ * Simple queue access methods.
+ */
+#define SIMPLEQ_FIRST(head) ((head)->sqh_first)
+#define SIMPLEQ_END(head) NULL
+#define SIMPLEQ_EMPTY(head) (SIMPLEQ_FIRST(head) == SIMPLEQ_END(head))
+#define SIMPLEQ_NEXT(elm, field) ((elm)->field.sqe_next)
+
+#define SIMPLEQ_FOREACH(var, head, field) \
+ for((var) = SIMPLEQ_FIRST(head); \
+ (var) != SIMPLEQ_END(head); \
+ (var) = SIMPLEQ_NEXT(var, field))
+
+/*
+ * Simple queue functions.
+ */
+#define SIMPLEQ_INIT(head) do { \
+ (head)->sqh_first = NULL; \
+ (head)->sqh_last = &(head)->sqh_first; \
+} while (0)
+
+#define SIMPLEQ_INSERT_HEAD(head, elm, field) do { \
+ if (((elm)->field.sqe_next = (head)->sqh_first) == NULL) \
+ (head)->sqh_last = &(elm)->field.sqe_next; \
+ (head)->sqh_first = (elm); \
+} while (0)
+
+#define SIMPLEQ_INSERT_TAIL(head, elm, field) do { \
+ (elm)->field.sqe_next = NULL; \
+ *(head)->sqh_last = (elm); \
+ (head)->sqh_last = &(elm)->field.sqe_next; \
+} while (0)
+
+#define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do { \
+ if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\
+ (head)->sqh_last = &(elm)->field.sqe_next; \
+ (listelm)->field.sqe_next = (elm); \
+} while (0)
+
+#define SIMPLEQ_REMOVE_HEAD(head, field) do { \
+ if (((head)->sqh_first = (head)->sqh_first->field.sqe_next) == NULL) \
+ (head)->sqh_last = &(head)->sqh_first; \
+} while (0)
+
+/*
+ * Tail queue definitions.
+ */
+#define TAILQ_HEAD(name, type) \
+struct name { \
+ struct type *tqh_first; /* first element */ \
+ struct type **tqh_last; /* addr of last next element */ \
+}
+
+#define TAILQ_HEAD_INITIALIZER(head) \
+ { NULL, &(head).tqh_first }
+
+#define TAILQ_ENTRY(type) \
+struct { \
+ struct type *tqe_next; /* next element */ \
+ struct type **tqe_prev; /* address of previous next element */ \
+}
+
+/*
+ * tail queue access methods
+ */
+#define TAILQ_FIRST(head) ((head)->tqh_first)
+#define TAILQ_END(head) NULL
+#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
+#define TAILQ_LAST(head, headname) \
+ (*(((struct headname *)((head)->tqh_last))->tqh_last))
+/* XXX */
+#define TAILQ_PREV(elm, headname, field) \
+ (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
+#define TAILQ_EMPTY(head) \
+ (TAILQ_FIRST(head) == TAILQ_END(head))
+
+#define TAILQ_FOREACH(var, head, field) \
+ for((var) = TAILQ_FIRST(head); \
+ (var) != TAILQ_END(head); \
+ (var) = TAILQ_NEXT(var, field))
+
+#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \
+ for((var) = TAILQ_LAST(head, headname); \
+ (var) != TAILQ_END(head); \
+ (var) = TAILQ_PREV(var, headname, field))
+
+/*
+ * Tail queue functions.
+ */
+#define TAILQ_INIT(head) do { \
+ (head)->tqh_first = NULL; \
+ (head)->tqh_last = &(head)->tqh_first; \
+} while (0)
+
+#define TAILQ_INSERT_HEAD(head, elm, field) do { \
+ if (((elm)->field.tqe_next = (head)->tqh_first) != NULL) \
+ (head)->tqh_first->field.tqe_prev = \
+ &(elm)->field.tqe_next; \
+ else \
+ (head)->tqh_last = &(elm)->field.tqe_next; \
+ (head)->tqh_first = (elm); \
+ (elm)->field.tqe_prev = &(head)->tqh_first; \
+} while (0)
+
+#define TAILQ_INSERT_TAIL(head, elm, field) do { \
+ (elm)->field.tqe_next = NULL; \
+ (elm)->field.tqe_prev = (head)->tqh_last; \
+ *(head)->tqh_last = (elm); \
+ (head)->tqh_last = &(elm)->field.tqe_next; \
+} while (0)
+
+#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \
+ if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\
+ (elm)->field.tqe_next->field.tqe_prev = \
+ &(elm)->field.tqe_next; \
+ else \
+ (head)->tqh_last = &(elm)->field.tqe_next; \
+ (listelm)->field.tqe_next = (elm); \
+ (elm)->field.tqe_prev = &(listelm)->field.tqe_next; \
+} while (0)
+
+#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \
+ (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \
+ (elm)->field.tqe_next = (listelm); \
+ *(listelm)->field.tqe_prev = (elm); \
+ (listelm)->field.tqe_prev = &(elm)->field.tqe_next; \
+} while (0)
+
+#define TAILQ_REMOVE(head, elm, field) do { \
+ if (((elm)->field.tqe_next) != NULL) \
+ (elm)->field.tqe_next->field.tqe_prev = \
+ (elm)->field.tqe_prev; \
+ else \
+ (head)->tqh_last = (elm)->field.tqe_prev; \
+ *(elm)->field.tqe_prev = (elm)->field.tqe_next; \
+ _Q_INVALIDATE((elm)->field.tqe_prev); \
+ _Q_INVALIDATE((elm)->field.tqe_next); \
+} while (0)
+
+#define TAILQ_REPLACE(head, elm, elm2, field) do { \
+ if (((elm2)->field.tqe_next = (elm)->field.tqe_next) != NULL) \
+ (elm2)->field.tqe_next->field.tqe_prev = \
+ &(elm2)->field.tqe_next; \
+ else \
+ (head)->tqh_last = &(elm2)->field.tqe_next; \
+ (elm2)->field.tqe_prev = (elm)->field.tqe_prev; \
+ *(elm2)->field.tqe_prev = (elm2); \
+ _Q_INVALIDATE((elm)->field.tqe_prev); \
+ _Q_INVALIDATE((elm)->field.tqe_next); \
+} while (0)
+
+/*
+ * Circular queue definitions.
+ */
+#define CIRCLEQ_HEAD(name, type) \
+struct name { \
+ struct type *cqh_first; /* first element */ \
+ struct type *cqh_last; /* last element */ \
+}
+
+#define CIRCLEQ_HEAD_INITIALIZER(head) \
+ { CIRCLEQ_END(&head), CIRCLEQ_END(&head) }
+
+#define CIRCLEQ_ENTRY(type) \
+struct { \
+ struct type *cqe_next; /* next element */ \
+ struct type *cqe_prev; /* previous element */ \
+}
+
+/*
+ * Circular queue access methods
+ */
+#define CIRCLEQ_FIRST(head) ((head)->cqh_first)
+#define CIRCLEQ_LAST(head) ((head)->cqh_last)
+#define CIRCLEQ_END(head) ((void *)(head))
+#define CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next)
+#define CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev)
+#define CIRCLEQ_EMPTY(head) \
+ (CIRCLEQ_FIRST(head) == CIRCLEQ_END(head))
+
+#define CIRCLEQ_FOREACH(var, head, field) \
+ for((var) = CIRCLEQ_FIRST(head); \
+ (var) != CIRCLEQ_END(head); \
+ (var) = CIRCLEQ_NEXT(var, field))
+
+#define CIRCLEQ_FOREACH_REVERSE(var, head, field) \
+ for((var) = CIRCLEQ_LAST(head); \
+ (var) != CIRCLEQ_END(head); \
+ (var) = CIRCLEQ_PREV(var, field))
+
+/*
+ * Circular queue functions.
+ */
+#define CIRCLEQ_INIT(head) do { \
+ (head)->cqh_first = CIRCLEQ_END(head); \
+ (head)->cqh_last = CIRCLEQ_END(head); \
+} while (0)
+
+#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \
+ (elm)->field.cqe_next = (listelm)->field.cqe_next; \
+ (elm)->field.cqe_prev = (listelm); \
+ if ((listelm)->field.cqe_next == CIRCLEQ_END(head)) \
+ (head)->cqh_last = (elm); \
+ else \
+ (listelm)->field.cqe_next->field.cqe_prev = (elm); \
+ (listelm)->field.cqe_next = (elm); \
+} while (0)
+
+#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \
+ (elm)->field.cqe_next = (listelm); \
+ (elm)->field.cqe_prev = (listelm)->field.cqe_prev; \
+ if ((listelm)->field.cqe_prev == CIRCLEQ_END(head)) \
+ (head)->cqh_first = (elm); \
+ else \
+ (listelm)->field.cqe_prev->field.cqe_next = (elm); \
+ (listelm)->field.cqe_prev = (elm); \
+} while (0)
+
+#define CIRCLEQ_INSERT_HEAD(head, elm, field) do { \
+ (elm)->field.cqe_next = (head)->cqh_first; \
+ (elm)->field.cqe_prev = CIRCLEQ_END(head); \
+ if ((head)->cqh_last == CIRCLEQ_END(head)) \
+ (head)->cqh_last = (elm); \
+ else \
+ (head)->cqh_first->field.cqe_prev = (elm); \
+ (head)->cqh_first = (elm); \
+} while (0)
+
+#define CIRCLEQ_INSERT_TAIL(head, elm, field) do { \
+ (elm)->field.cqe_next = CIRCLEQ_END(head); \
+ (elm)->field.cqe_prev = (head)->cqh_last; \
+ if ((head)->cqh_first == CIRCLEQ_END(head)) \
+ (head)->cqh_first = (elm); \
+ else \
+ (head)->cqh_last->field.cqe_next = (elm); \
+ (head)->cqh_last = (elm); \
+} while (0)
+
+#define CIRCLEQ_REMOVE(head, elm, field) do { \
+ if ((elm)->field.cqe_next == CIRCLEQ_END(head)) \
+ (head)->cqh_last = (elm)->field.cqe_prev; \
+ else \
+ (elm)->field.cqe_next->field.cqe_prev = \
+ (elm)->field.cqe_prev; \
+ if ((elm)->field.cqe_prev == CIRCLEQ_END(head)) \
+ (head)->cqh_first = (elm)->field.cqe_next; \
+ else \
+ (elm)->field.cqe_prev->field.cqe_next = \
+ (elm)->field.cqe_next; \
+ _Q_INVALIDATE((elm)->field.cqe_prev); \
+ _Q_INVALIDATE((elm)->field.cqe_next); \
+} while (0)
+
+#define CIRCLEQ_REPLACE(head, elm, elm2, field) do { \
+ if (((elm2)->field.cqe_next = (elm)->field.cqe_next) == \
+ CIRCLEQ_END(head)) \
+ (head)->cqh_last = (elm2); \
+ else \
+ (elm2)->field.cqe_next->field.cqe_prev = (elm2); \
+ if (((elm2)->field.cqe_prev = (elm)->field.cqe_prev) == \
+ CIRCLEQ_END(head)) \
+ (head)->cqh_first = (elm2); \
+ else \
+ (elm2)->field.cqe_prev->field.cqe_next = (elm2); \
+ _Q_INVALIDATE((elm)->field.cqe_prev); \
+ _Q_INVALIDATE((elm)->field.cqe_next); \
+} while (0)
+
+#endif /* !_SYS_QUEUE_H_ */
--- /dev/null
+#ifndef UTIL_H_
+#define UTIL_H_
+
+/* Securely free p */
+#define FREE(p) do { \
+ if (p != NULL) { \
+ free(p); \
+ p = NULL; \
+ } \
+} while (0)
+
+/* Securely fee single-linked list */
+#define FREE_LIST(l, type) do { \
+ type* FREE_LIST_TMP; \
+ while (l != NULL) { \
+ FREE_LIST_TMP = l; \
+ free(l); \
+ l = l->next; \
+ } \
+} while (0)
+
+#endif
--- /dev/null
+#ifndef WORKSPACES_H_
+#define WORKSPACES_H_
+
+#include "common.h"
+#include "outputs.h"
+
+typedef struct i3_ws_t i3_ws;
+
+i3_ws* workspaces;
+
+void refresh_workspaces();
+void free_workspaces();
+
+struct i3_ws_t {
+ int num;
+ char* name;
+ bool visible;
+ bool focused;
+ bool urgent;
+ rect rect;
+ i3_output* output;
+
+ i3_ws* next;
+};
+
+#endif
--- /dev/null
+#ifndef XCB_H_
+#define XCB_H_
+
+#include <xcb/xcb.h>
+
+#define NUM_ATOMS 3
+
+enum {
+ #define ATOM_DO(name) name,
+ #include "xcb_atoms.def"
+};
+
+xcb_atom_t atoms[NUM_ATOMS];
+
+xcb_connection_t* xcb_connection;
+xcb_screen_t* xcb_screens;
+xcb_window_t xcb_root;
+
+void init_xcb();
+void clean_xcb();
+void get_atoms();
+void create_windows();
+
+#endif
--- /dev/null
+ATOM_DO(ATOM)
+ATOM_DO(_NET_WM_WINDOW_TYPE)
+ATOM_DO(_NET_WM_WINDOW_TYPE_DOCK)
+#undef ATOM_DO
--- /dev/null
+#include <stdio.h>
+#include <ev.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <i3/ipc.h>
+
+#include "common.h"
+#include "ipc.h"
+
+struct callback_t {
+ void (*callback)(char*, void*);
+ void* params;
+ struct callback_t* next;
+};
+
+struct callback_t* outputs_cb_queue;
+struct callback_t* workspaces_cb_queue;
+
+int get_ipc_fd(const char* socket_path) {
+ int sockfd = socket(AF_LOCAL, SOCK_STREAM, 0);
+ if (sockfd == -1) {
+ printf("ERROR: Could not create Socket!\n");
+ exit(EXIT_FAILURE);
+ }
+
+ struct sockaddr_un addr;
+ memset(&addr, 0, sizeof(struct sockaddr_un));
+ addr.sun_family = AF_LOCAL;
+ strcpy(addr.sun_path, socket_path);
+ if (connect(sockfd, (const struct sockaddr*) &addr, sizeof(struct sockaddr_un)) < 0) {
+ printf("ERROR: Could not connct to i3\n");
+ exit(EXIT_FAILURE);
+ }
+ return sockfd;
+}
+
+void get_outputs_cb(struct ev_loop* loop, ev_io *watcher, int revents) {
+
+}
+
+void init_i3(const char* socket_path) {
+ int sockfd = get_ipc_fd(socket_path);
+
+ struct get_outputs_callback* cb = malloc(sizeof(struct get_outputs_callback));
+ cb->callback = callback;
+ cb->params = params;
+
+ ev_io* get_outputs_write = malloc(sizeof(ev_io));
+
+ ev_io_init(get_outputs_write, &get_outputs_write_cb, sockfd, EV_WRITE);
+ get_outputs_write->data = (void*) cb;
+ ev_io_start(main_loop, get_outputs_write);
+
+ ev_io* get_outputs_read = malloc(sizeof(ev_io));
+ ev_io_init(get_outputs_read, &get_outputs_read_cb, sockfd, EV_READ);
+ get_outputs_read->data = (void*) cb;
+ ev_io_start(main_loop, get_outputs_read);
+}
+
+
+void get_outputs_write_cb(struct ev_loop* loop, ev_io *watcher, int revents) {
+ ev_io_stop(loop, watcher);
+
+ int buffer_size = strlen(I3_IPC_MAGIC) + sizeof(uint32_t) + sizeof(uint32_t);
+ char msg[buffer_size];
+ char *walk = msg;
+ uint32_t msg_size = 0;
+ uint32_t msg_type = I3_IPC_MESSAGE_TYPE_GET_OUTPUTS;
+ int sockfd = watcher->fd;
+
+ strcpy(walk, I3_IPC_MAGIC);
+ walk += strlen(I3_IPC_MAGIC);
+ memcpy(walk, &msg_size, sizeof(uint32_t));
+ walk += sizeof(uint32_t);
+ memcpy(walk, &msg_type, sizeof(uint32_t));
+
+ int sent_bytes = 0;
+ int bytes_to_go = buffer_size;
+ while (sent_bytes < bytes_to_go) {
+ int n = write(sockfd, msg + sent_bytes, bytes_to_go);
+ if (n == -1) {
+ printf("ERROR: write() failed!\n");
+ exit(EXIT_FAILURE);
+ }
+
+ sent_bytes += n;
+ bytes_to_go -= n;
+ }
+ FREE(watcher);
+}
+
+void get_outputs_read_cb(struct ev_loop* loop, ev_io *watcher, int revents) {
+ ev_io_stop(loop, watcher);
+
+ int to_read = strlen(I3_IPC_MAGIC) + sizeof(uint32_t) + sizeof(uint32_t);
+ char msg[to_read];
+ char *walk = msg;
+ int sockfd = watcher->fd;
+ uint8_t *reply;
+ struct get_outputs_callback* cb = watcher->data;
+
+ uint32_t reply_length;
+
+ uint32_t read_bytes = 0;
+ while (read_bytes < to_read) {
+ int n = read(sockfd, msg + read_bytes, to_read);
+ if (n == -1) {
+ printf("ERROR: read() failed!\n");
+ exit(EXIT_FAILURE);
+ }
+ if (n == 0) {
+ printf("ERROR: No reply!\n");
+ exit(EXIT_FAILURE);
+ }
+
+ read_bytes += n;
+ to_read -= n;
+ }
+
+ if (memcmp(walk, I3_IPC_MAGIC, strlen(I3_IPC_MAGIC)) != 0) {
+ printf("ERROR: Wrong magic!\n");
+ exit(EXIT_FAILURE);
+ }
+
+ walk += strlen(I3_IPC_MAGIC);
+ reply_length = *((uint32_t*) walk);
+ walk += sizeof(uint32_t);
+ if (*((uint32_t*) walk) != I3_IPC_MESSAGE_TYPE_GET_OUTPUTS) {
+ printf("ERROR: Wrong reply type (%d) expected %d!\n",
+ *((uint32_t*) walk),
+ I3_IPC_MESSAGE_TYPE_GET_OUTPUTS);
+ exit(EXIT_FAILURE);
+ }
+ walk += sizeof(uint32_t);
+
+ reply = malloc(reply_length);
+ if (reply == NULL) {
+ printf("ERROR: malloc() failed!\n");
+ exit(EXIT_FAILURE);
+ }
+
+ to_read = reply_length;
+ read_bytes = 0;
+ while (read_bytes < to_read) {
+ int n = read(sockfd, reply + read_bytes, to_read);
+ if (n == -1) {
+ printf("ERROR: read() failed!\n");
+ exit(EXIT_FAILURE);
+ }
+
+ read_bytes += n;
+ to_read -= n;
+ }
+
+ cb->callback((char*) reply, cb->params);
+ FREE(cb);
+ FREE(watcher);
+}
+
+void get_outputs_json(void (*callback)(char*, void*), void* params) {
+}
+
+
+
+struct get_workspaces_callback {
+ void (*callback)(char*, void*);
+ void* params;
+};
+
+void get_workspaces_write_cb(struct ev_loop* loop, ev_io *watcher, int revents) {
+ ev_io_stop(loop, watcher);
+ //FREE(watcher);
+
+ int buffer_size = strlen(I3_IPC_MAGIC) + sizeof(uint32_t) + sizeof(uint32_t);
+ char msg[buffer_size];
+ char *walk = msg;
+ uint32_t msg_size = 0;
+ uint32_t msg_type = I3_IPC_MESSAGE_TYPE_GET_WORKSPACES;
+ int sockfd = watcher->fd;
+
+ strcpy(walk, I3_IPC_MAGIC);
+ walk += strlen(I3_IPC_MAGIC);
+ memcpy(walk, &msg_size, sizeof(uint32_t));
+ walk += sizeof(uint32_t);
+ memcpy(walk, &msg_type, sizeof(uint32_t));
+
+ int sent_bytes = 0;
+ int bytes_to_go = buffer_size;
+ while (sent_bytes < bytes_to_go) {
+ int n = write(sockfd, msg + sent_bytes, bytes_to_go);
+ if (n == -1) {
+ printf("ERROR: write() failed!\n");
+ exit(EXIT_FAILURE);
+ }
+
+ sent_bytes += n;
+ bytes_to_go -= n;
+ }
+ FREE(watcher);
+}
+
+void get_workspaces_read_cb(struct ev_loop* loop, ev_io *watcher, int revents) {
+ ev_io_stop(loop, watcher);
+ //FREE(watcher);
+
+ int to_read = strlen(I3_IPC_MAGIC) + sizeof(uint32_t) + sizeof(uint32_t);
+ char msg[to_read];
+ char *walk = msg;
+ int sockfd = watcher->fd;
+ uint8_t *reply;
+ struct get_workspaces_callback* cb = watcher->data;
+
+ uint32_t reply_length;
+
+ uint32_t read_bytes = 0;
+ while (read_bytes < to_read) {
+ int n = read(sockfd, msg + read_bytes, to_read);
+ if (n == -1) {
+ printf("ERROR: read() failed!\n");
+ exit(EXIT_FAILURE);
+ }
+ if (n == 0) {
+ printf("ERROR: No reply!\n");
+ exit(EXIT_FAILURE);
+ }
+
+ read_bytes += n;
+ to_read -= n;
+ }
+
+ if (memcmp(walk, I3_IPC_MAGIC, strlen(I3_IPC_MAGIC)) != 0) {
+ printf("ERROR: Wrong magic!\n");
+ exit(EXIT_FAILURE);
+ }
+
+ walk += strlen(I3_IPC_MAGIC);
+ reply_length = *((uint32_t*) walk);
+ walk += sizeof(uint32_t);
+ if (*((uint32_t*) walk) != I3_IPC_MESSAGE_TYPE_GET_WORKSPACES) {
+ printf("ERROR: Wrong reply type (%d) expected %d!\n",
+ *((uint32_t*) walk),
+ I3_IPC_MESSAGE_TYPE_GET_WORKSPACES);
+ exit(EXIT_FAILURE);
+ }
+ walk += sizeof(uint32_t);
+
+ reply = malloc(reply_length);
+ if (reply == NULL) {
+ printf("ERROR: malloc() failed!\n");
+ exit(EXIT_FAILURE);
+ }
+
+ to_read = reply_length;
+ read_bytes = 0;
+ while (read_bytes < to_read) {
+ int n = read(sockfd, reply + read_bytes, to_read);
+ if (n == -1) {
+ printf("ERROR: read() failed!\n");
+ exit(EXIT_FAILURE);
+ }
+
+ read_bytes += n;
+ to_read -= n;
+ }
+
+ cb->callback((char*) reply, cb->params);
+ FREE(cb);
+
+ FREE(watcher);
+}
+
+void get_workspaces_json(void (*callback)(char*, void*), void* params) {
+ socket_path = "/home/mero/.i3/ipc.sock";
+
+ int sockfd = socket(AF_LOCAL, SOCK_STREAM, 0);
+ if (sockfd == -1) {
+ printf("ERROR: Could not create Socket!\n");
+ exit(EXIT_FAILURE);
+ }
+
+ struct sockaddr_un addr;
+ memset(&addr, 0, sizeof(struct sockaddr_un));
+ addr.sun_family = AF_LOCAL;
+ strcpy(addr.sun_path, socket_path);
+ if (connect(sockfd, (const struct sockaddr*) &addr, sizeof(struct sockaddr_un)) < 0) {
+ printf("ERROR: Could not connct to i3\n");
+ exit(EXIT_FAILURE);
+ }
+
+ struct get_workspaces_callback* cb = malloc(sizeof(struct get_workspaces_callback));
+ cb->callback = callback;
+ cb->params = params;
+
+ ev_io* get_workspaces_write = malloc(sizeof(ev_io));
+
+ ev_io_init(get_workspaces_write, &get_workspaces_write_cb, sockfd, EV_WRITE);
+ get_workspaces_write->data = (void*) cb;
+ ev_io_start(main_loop, get_workspaces_write);
+
+ ev_io* get_workspaces_read = malloc(sizeof(ev_io));
+ ev_io_init(get_workspaces_read, &get_workspaces_read_cb, sockfd, EV_READ);
+ get_workspaces_read->data = (void*) cb;
+ ev_io_start(main_loop, get_workspaces_read);
+}
--- /dev/null
+#include "ipc.h"
+#include "outputs.h"
+#include "workspaces.h"
+#include "common.h"
+#include "xcb.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <ev.h>
+
+int main(int argc, char **argv) {
+ main_loop = ev_default_loop(0);
+
+ init_xcb();
+
+ refresh_outputs(&create_windows, NULL);
+ refresh_workspaces(NULL, NULL);
+
+ ev_loop(main_loop, 0);
+
+ ev_default_destroy();
+ clean_xcb();
+ free_outputs();
+ free_workspaces();
+
+ //sleep(5);
+ return 0;
+}
--- /dev/null
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <yajl/yajl_parse.h>
+
+#include "common.h"
+#include "outputs.h"
+#include "ipc.h"
+
+struct outputs_json_params {
+ i3_output* outputs;
+ i3_output* outputs_walk;
+ char* cur_key;
+ char* json;
+ void (*callback)(void*);
+ void* cb_params;
+};
+
+static int outputs_null_cb(void* params_) {
+ struct outputs_json_params* params = (struct outputs_json_params*) params_;
+
+ if (strcmp(params->cur_key, "current_workspace")) {
+ return 0;
+ }
+
+ FREE(params->cur_key);
+
+ return 1;
+}
+
+static int outputs_boolean_cb(void* params_, bool val) {
+ struct outputs_json_params* params = (struct outputs_json_params*) params_;
+
+ if (strcmp(params->cur_key, "active")) {
+ return 0;
+ }
+
+ params->outputs_walk->active = val;
+
+ FREE(params->cur_key);
+
+ return 1;
+}
+
+static int outputs_integer_cb(void* params_, long val) {
+ struct outputs_json_params* params = (struct outputs_json_params*) params_;
+
+ if (!strcmp(params->cur_key, "current_workspace")) {
+ params->outputs_walk->ws = (int) val;
+ FREE(params->cur_key);
+ return 1;
+ }
+
+ if (!strcmp(params->cur_key, "x")) {
+ params->outputs_walk->rect.x = (int) val;
+ FREE(params->cur_key);
+ return 1;
+ }
+
+ if (!strcmp(params->cur_key, "y")) {
+ params->outputs_walk->rect.y = (int) val;
+ FREE(params->cur_key);
+ return 1;
+ }
+
+ if (!strcmp(params->cur_key, "width")) {
+ params->outputs_walk->rect.w = (int) val;
+ FREE(params->cur_key);
+ return 1;
+ }
+
+ if (!strcmp(params->cur_key, "height")) {
+ params->outputs_walk->rect.h = (int) val;
+ FREE(params->cur_key);
+ return 1;
+ }
+
+ return 0;
+}
+
+static int outputs_string_cb(void* params_, const unsigned char* val, unsigned int len) {
+ struct outputs_json_params* params = (struct outputs_json_params*) params_;
+
+ if (strcmp(params->cur_key, "name")) {
+ return 0;
+ }
+
+ params->outputs_walk->name = malloc(sizeof(const unsigned char) * (len + 1));
+ strncpy(params->outputs_walk->name, (const char*) val, len);
+ params->outputs_walk->name[len] = '\0';
+
+ FREE(params->cur_key);
+
+ return 1;
+}
+
+static int outputs_start_map_cb(void* params_) {
+ struct outputs_json_params* params = (struct outputs_json_params*) params_;
+ i3_output* new_output = NULL;
+
+ if (params->cur_key == NULL) {
+ new_output = malloc(sizeof(i3_output));
+ new_output->name = NULL;
+ new_output->ws = 0,
+ memset(&new_output->rect, 0, sizeof(rect));
+ new_output->next = NULL;
+
+ if (params->outputs == NULL) {
+ params->outputs = new_output;
+ } else {
+ params->outputs_walk->next = new_output;
+ }
+
+ params->outputs_walk = new_output;
+ return 1;
+ }
+
+ return 1;
+}
+
+static int outputs_map_key_cb(void* params_, const unsigned char* keyVal, unsigned int keyLen) {
+ struct outputs_json_params* params = (struct outputs_json_params*) params_;
+ FREE(params->cur_key);
+
+ params->cur_key = malloc(sizeof(unsigned char) * (keyLen + 1));
+ strncpy(params->cur_key, (const char*) keyVal, keyLen);
+ params->cur_key[keyLen] = '\0';
+
+ return 1;
+}
+
+yajl_callbacks outputs_callbacks = {
+ &outputs_null_cb,
+ &outputs_boolean_cb,
+ &outputs_integer_cb,
+ NULL,
+ NULL,
+ &outputs_string_cb,
+ &outputs_start_map_cb,
+ &outputs_map_key_cb,
+ NULL,
+ NULL,
+ NULL
+};
+
+void got_outputs_json_cb(char* json, void* params_) {
+ /* FIXME: Fasciliate stream-processing, i.e. allow starting to interpret
+ * JSON in chunks */
+ struct outputs_json_params* params = (struct outputs_json_params*) params_;
+
+ yajl_handle handle;
+ yajl_parser_config parse_conf = { 0, 0 };
+ yajl_status state;
+
+ params->json = json;
+
+ handle = yajl_alloc(&outputs_callbacks, &parse_conf, NULL, (void*) params);
+
+ state = yajl_parse(handle, (const unsigned char*) json, strlen(json));
+
+ /* FIXME: Propper errorhandling for JSON-parsing */
+ switch (state) {
+ case yajl_status_ok:
+ break;
+ case yajl_status_client_canceled:
+ case yajl_status_insufficient_data:
+ case yajl_status_error:
+ printf("ERROR: Could not parse outputs-reply!\n");
+ exit(EXIT_FAILURE);
+ break;
+ }
+
+ yajl_free(handle);
+
+ free_outputs();
+ outputs = params->outputs;
+
+ if (params->callback != NULL) {
+ params->callback(params->cb_params);
+ }
+
+ FREE(params->json);
+ FREE(params);
+}
+
+void refresh_outputs(void (*callback)(void*), void* cb_params) {
+ struct outputs_json_params* params = malloc(sizeof(struct outputs_json_params));
+
+ params->outputs = NULL;
+ params->outputs_walk = NULL;
+ params->cur_key = NULL;
+ params->json = NULL;
+ params->callback = callback;
+ params->cb_params = cb_params;
+
+ get_outputs_json(&got_outputs_json_cb, params);
+}
+
+void free_outputs() {
+ i3_output* tmp;
+ while (outputs != NULL) {
+ tmp = outputs;
+ outputs = outputs->next;
+ FREE(tmp->name);
+ FREE(tmp);
+ }
+}
+
+i3_output* get_output_by_name(char* name) {
+ if (outputs == NULL) {
+ refresh_outputs(NULL, NULL);
+ return NULL;
+ }
+
+ i3_output* walk;
+
+ for (walk = outputs; walk != NULL; walk = walk->next) {
+ if (strcmp(walk->name, name)) {
+ break;
+ }
+ }
+
+ return walk;
+}
--- /dev/null
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <yajl/yajl_parse.h>
+
+#include "common.h"
+#include "workspaces.h"
+#include "ipc.h"
+
+struct workspaces_json_params {
+ i3_ws* workspaces;
+ i3_ws* workspaces_walk;
+ char* cur_key;
+ char* json;
+};
+
+static int workspaces_null_cb(void* params_) {
+ struct workspaces_json_params* params = (struct workspaces_json_params*) params_;
+
+ if (strcmp(params->cur_key, "current_workspace")) {
+ return 0;
+ }
+
+ FREE(params->cur_key);
+
+ return 1;
+}
+
+static int workspaces_boolean_cb(void* params_, bool val) {
+ struct workspaces_json_params* params = (struct workspaces_json_params*) params_;
+
+ if (!strcmp(params->cur_key, "visible")) {
+ params->workspaces_walk->visible = val;
+ FREE(params->cur_key);
+ return 1;
+ }
+
+ if (!strcmp(params->cur_key, "focused")) {
+ params->workspaces_walk->focused = val;
+ FREE(params->cur_key);
+ return 1;
+ }
+
+ if (!strcmp(params->cur_key, "urgent")) {
+ params->workspaces_walk->focused = val;
+ FREE(params->cur_key);
+ return 1;
+ }
+
+ FREE(params->cur_key);
+
+ return 0;
+}
+
+static int workspaces_integer_cb(void* params_, long val) {
+ struct workspaces_json_params* params = (struct workspaces_json_params*) params_;
+
+ if (!strcmp(params->cur_key, "num")) {
+ params->workspaces_walk->num = (int) val;
+ FREE(params->cur_key);
+ return 1;
+ }
+
+ if (!strcmp(params->cur_key, "x")) {
+ params->workspaces_walk->rect.x = (int) val;
+ FREE(params->cur_key);
+ return 1;
+ }
+
+ if (!strcmp(params->cur_key, "y")) {
+ params->workspaces_walk->rect.y = (int) val;
+ FREE(params->cur_key);
+ return 1;
+ }
+
+ if (!strcmp(params->cur_key, "width")) {
+ params->workspaces_walk->rect.w = (int) val;
+ FREE(params->cur_key);
+ return 1;
+ }
+
+ if (!strcmp(params->cur_key, "height")) {
+ params->workspaces_walk->rect.h = (int) val;
+ FREE(params->cur_key);
+ return 1;
+ }
+
+ FREE(params->cur_key);
+ return 0;
+}
+
+static int workspaces_string_cb(void* params_, const unsigned char* val, unsigned int len) {
+ struct workspaces_json_params* params = (struct workspaces_json_params*) params_;
+
+ char* output_name;
+
+ if (!strcmp(params->cur_key, "name")) {
+ params->workspaces_walk->name = malloc(sizeof(const unsigned char) * (len + 1));
+ strncpy(params->workspaces_walk->name, (const char*) val, len);
+ params->workspaces_walk->name[len] = '\0';
+
+ FREE(params->cur_key);
+
+ return 1;
+ }
+
+ if (!strcmp(params->cur_key, "output")) {
+ output_name = malloc(sizeof(const unsigned char) * (len + 1));
+ strncpy(output_name, (const char*) val, len);
+ output_name[len] = '\0';
+ params->workspaces_walk->output = get_output_by_name(output_name);
+ free(output_name);
+
+ return 1;
+ }
+
+ return 0;
+}
+
+static int workspaces_start_map_cb(void* params_) {
+ struct workspaces_json_params* params = (struct workspaces_json_params*) params_;
+ i3_ws* new_workspace = NULL;
+
+ if (params->cur_key == NULL) {
+ new_workspace = malloc(sizeof(i3_ws));
+ new_workspace->num = -1;
+ new_workspace->name = NULL;
+ new_workspace->visible = 0;
+ new_workspace->focused = 0;
+ new_workspace->urgent = 0;
+ memset(&new_workspace->rect, 0, sizeof(rect));
+ new_workspace->output = NULL;
+ new_workspace->next = NULL;
+
+ if (params->workspaces == NULL) {
+ params->workspaces = new_workspace;
+ } else {
+ params->workspaces_walk->next = new_workspace;
+ }
+
+ params->workspaces_walk = new_workspace;
+ return 1;
+ }
+
+ return 1;
+}
+
+static int workspaces_map_key_cb(void* params_, const unsigned char* keyVal, unsigned int keyLen) {
+ struct workspaces_json_params* params = (struct workspaces_json_params*) params_;
+ FREE(params->cur_key);
+
+ params->cur_key = malloc(sizeof(unsigned char) * (keyLen + 1));
+ strncpy(params->cur_key, (const char*) keyVal, keyLen);
+ params->cur_key[keyLen] = '\0';
+
+ return 1;
+}
+
+yajl_callbacks workspaces_callbacks = {
+ &workspaces_null_cb,
+ &workspaces_boolean_cb,
+ &workspaces_integer_cb,
+ NULL,
+ NULL,
+ &workspaces_string_cb,
+ &workspaces_start_map_cb,
+ &workspaces_map_key_cb,
+ NULL,
+ NULL,
+ NULL
+};
+
+void got_workspaces_json_cb(char* json, void* params_) {
+ /* FIXME: Fasciliate stream-processing, i.e. allow starting to interpret
+ * JSON in chunks */
+ struct workspaces_json_params* params = (struct workspaces_json_params*) params_;
+
+ yajl_handle handle;
+ yajl_parser_config parse_conf = { 0, 0 };
+ yajl_status state;
+
+ params->json = json;
+
+ handle = yajl_alloc(&workspaces_callbacks, &parse_conf, NULL, (void*) params);
+
+ state = yajl_parse(handle, (const unsigned char*) json, strlen(json));
+
+ /* FIXME: Propper errorhandling for JSON-parsing */
+ switch (state) {
+ case yajl_status_ok:
+ break;
+ case yajl_status_client_canceled:
+ case yajl_status_insufficient_data:
+ case yajl_status_error:
+ printf("ERROR: Could not parse workspaces-reply!\n");
+ exit(EXIT_FAILURE);
+ break;
+ }
+
+ yajl_free(handle);
+
+ free_workspaces();
+ workspaces = params->workspaces;
+
+ FREE(params->json);
+ FREE(params);
+}
+
+void refresh_workspaces() {
+ struct workspaces_json_params* params = malloc(sizeof(struct workspaces_json_params));
+
+ params->workspaces = NULL;
+ params->workspaces_walk = NULL;
+ params->cur_key = NULL;
+ params->json = NULL;
+
+ get_workspaces_json(&got_workspaces_json_cb, params);
+}
+
+void free_workspaces() {
+ i3_ws* tmp;
+ while (workspaces != NULL) {
+ tmp = workspaces;
+ workspaces = workspaces->next;
+ FREE(tmp->name);
+ FREE(tmp);
+ }
+}
--- /dev/null
+#include <xcb/xcb.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "xcb.h"
+#include "outputs.h"
+
+xcb_intern_atom_cookie_t atom_cookies[NUM_ATOMS];
+
+void init_xcb() {
+ /* LEAK: xcb_connect leaks Memory */
+ xcb_connection = xcb_connect(NULL, NULL);
+ if (xcb_connection_has_error(xcb_connection)) {
+ printf("Cannot open display\n");
+ exit(EXIT_FAILURE);
+ }
+ printf("Connected to xcb\n");
+
+ /* We have to request the atoms we need */
+ #define ATOM_DO(name) atom_cookies[name] = xcb_intern_atom(xcb_connection, 0, strlen(#name), #name);
+ #include "xcb_atoms.def"
+
+ xcb_screens = xcb_setup_roots_iterator(xcb_get_setup(xcb_connection)).data;
+ xcb_root = xcb_screens->root;
+
+ /* FIXME: Maybe we can push that further backwards */
+ get_atoms();
+}
+
+void clean_xcb() {
+ xcb_disconnect(xcb_connection);
+}
+
+void get_atoms() {
+ xcb_intern_atom_reply_t* reply;
+ #define ATOM_DO(name) reply = xcb_intern_atom_reply(xcb_connection, atom_cookies[name], NULL); \
+ atoms[name] = reply->atom; \
+ free(reply);
+
+ #include "xcb_atoms.def"
+ printf("Got Atoms\n");
+}
+
+void create_windows() {
+ uint32_t mask;
+ uint32_t values[2];
+
+ i3_output* walk = outputs;
+ while (walk != NULL) {
+ if (!walk->active) {
+ walk = walk->next;
+ continue;
+ }
+ printf("Creating Window for output %s\n", walk->name);
+
+ walk->win = xcb_generate_id(xcb_connection);
+ mask = XCB_CW_BACK_PIXEL;
+ values[0] = xcb_screens->black_pixel;
+ xcb_create_window(xcb_connection,
+ xcb_screens->root_depth,
+ walk->win,
+ xcb_root,
+ walk->rect.x, walk->rect.y,
+ walk->rect.w, 20,
+ 1,
+ XCB_WINDOW_CLASS_INPUT_OUTPUT,
+ xcb_screens->root_visual,
+ mask,
+ values);
+
+ xcb_change_property(xcb_connection,
+ XCB_PROP_MODE_REPLACE,
+ walk->win,
+ atoms[_NET_WM_WINDOW_TYPE],
+ atoms[ATOM],
+ 32,
+ 1,
+ (unsigned char*) &atoms[_NET_WM_WINDOW_TYPE_DOCK]);
+
+ xcb_map_window(xcb_connection, walk->win);
+ walk = walk->next;
+ }
+ xcb_flush(xcb_connection);
+}
+
+#if 0
+ xcb_screen_t* screens = xcb_setup_roots_iterator(xcb_get_setup(xcb_connection)).data;
+
+ xcb_gcontext_t ctx = xcb_generate_id(xcb_connection);
+
+ xcb_window_t win = screens->root;
+ uint32_t mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES;
+ uint32_t values[2];
+ values[0] = screens->black_pixel;
+ values[1] = 0;
+ xcb_create_gc(xcb_connection, ctx, win, mask, values);
+
+ request_atoms();
+
+ /* Fenster erzeugen */
+ win = xcb_generate_id(xcb_connection);
+ mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
+ values[0] = screens->white_pixel;
+ values[1] = XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_KEY_PRESS;
+ xcb_create_window(xcb_connection, screens->root_depth, win, screens->root,
+ 10, 10, 20, 20, 1,
+ XCB_WINDOW_CLASS_INPUT_OUTPUT, screens->root_visual,
+ mask, values);
+
+ get_atoms();
+
+ xcb_change_property(xcb_connection,
+ XCB_PROP_MODE_REPLACE,
+ win,
+ atoms[_NET_WM_WINDOW_TYPE],
+ atoms[ATOM],
+ 32,
+ 1,
+ (unsigned char *) &atoms[_NET_WM_WINDOW_TYPE_DOCK]);
+
+ xcb_map_window(xcb_connection, win);
+
+ xcb_flush(xcb_connection);
+#endif
projects / i3 / i3 / commitdiff