split code into files

Author: abresas

Makefile

@@ -1,4 +1,4 @@
-CFLAGS+= -Wall
+CFLAGS+= -Wall -Os
 LDADD+= -lxcb -lxcb-keysyms
 LDFLAGS=
 EXEC=yawn
@@ -13,8 +13,8 @@ CC=clang
 
 all: $(EXEC)
 
-yawn: yawn.o
-	$(CC) $(LDFLAGS) -Os -o $@ $+ $(LDADD)
+yawn: action.o client.o configuration.o desktop.o event.o keyboard.o stack.o string.o window.o yawn.o
+	$(CC) $(LDFLAGS) -o $@ $+ $(LDADD)
 
 install: all
 	install -Dm 755 yawn $(DESTDIR)$(BINDIR)/yawn

action.c

@@ -0,0 +1,24 @@
+#include <string.h>
+#include "action.h"
+#include "yawn.h"
+#include "keyboard.h"
+#include "client.h"
+#include "desktop.h"
+
+int (*get_action(char * name ))(int , char **) {
+    if ( !strcmp( name, "bind" ) ) {
+        return &keyboard_bind;
+    }
+    else if ( !strcmp( name, "change_desktop" ) ) {
+        return &desktop_change;
+    }
+    else if ( !strcmp( name, "quit" ) ) {
+        return &quit;
+    }
+    else if ( !strcmp( name, "kill_client" ) ) {
+        return &client_kill;
+    }
+    else {
+        return &spawn;
+    }
+}

action.h

@@ -0,0 +1,17 @@
+#ifndef ACTION_H
+#define ACTION_H
+
+typedef struct action_t {
+    int (*action)(int argc, char ** argv);
+    char * name;
+} action_t;
+
+/*
+action_t actions[] = {
+    { spawn, "spawn" }
+};
+*/
+
+int (*get_action(char * name ))(int , char **);
+
+#endif

client.c

@@ -0,0 +1,38 @@
+#include "client.h"
+#include "globals.h"
+#include "keyboard.h"
+#include "window.h"
+
+void client_manage( xcb_window_t w ) {
+    const uint32_t select_input_val[] = { CLIENT_SELECT_INPUT_EVENT_MASK };
+    xcb_map_window( xconn, w );
+    xcb_change_window_attributes( xconn, w, XCB_CW_EVENT_MASK, select_input_val );
+    xcb_configure_window(xconn, w, XCB_CONFIG_WINDOW_STACK_MODE, (uint32_t[]) { XCB_STACK_MODE_ABOVE } );
+    window_grabkeys( w, keybindings );
+}
+
+struct client_t * client_get_by_window( xcb_window_t w ) {
+    struct client_t * c;
+    for ( c = head; c; c = c->next ) {
+        if ( c->win == w ) {
+            return c;
+        }
+    }
+    return NULL;
+}
+
+int client_kill( int argc, char ** argv ) {
+    xcb_destroy_window( xconn, current->win );
+
+    /* Remove this window from the save set since this shouldn't be made visible
+     * after a restart anymore. */
+    xcb_change_save_set( xconn, XCB_SET_MODE_DELETE, current->win );
+
+    /* Do this last to avoid races with clients. According to ICCCM, clients
+     * arent allowed to re-use the window until after this. */
+    // xwindow_set_state(c->window, XCB_ICCCM_WM_STATE_WITHDRAWN);
+
+    current->win = XCB_NONE;
+    
+    return 0;
+}

client.h

@@ -0,0 +1,18 @@
+#ifndef CLIENT_H
+#define CLIENT_H
+
+#include <xcb/xcb.h>
+
+#define CLIENT_SELECT_INPUT_EVENT_MASK ( XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_PROPERTY_CHANGE | XCB_EVENT_MASK_FOCUS_CHANGE | XCB_EVENT_MASK_KEY_PRESS )
+
+struct client_t {
+    struct client_t *next;
+    struct client_t *prev;
+    xcb_window_t win;
+};
+
+void client_manage( xcb_window_t w );
+struct client_t *client_get_by_window( xcb_window_t w );
+int client_kill( int argc, char ** argv );
+
+#endif

configuration.c

@@ -0,0 +1,70 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "configuration.h"
+#include "string.h"
+#include "yawn.h"
+#include "action.h"
+
+char * xdg_config_dir( int directory_type ) {
+    char * config_dir;
+    if ( directory_type == CONFIG_DIR_HOME ) {
+        config_dir = getenv( "XDG_CONFIG_HOME" );
+        if ( config_dir == NULL ) {
+            config_dir = getenv( "HOME" );
+            if ( config_dir == NULL ) {
+                die( "Please define HOME environment variable.\n" );
+            }
+        }
+    }
+    else {
+        config_dir = getenv( "XDG_CONFIG_DIRS" );
+        if ( config_dir == NULL ) {
+            config_dir = (char*)malloc( 4 * sizeof( char ) );
+            strcpy( config_dir, "/etc" );
+        }
+    }
+    return config_dir;
+}
+
+char * xdg_config_path( char * filename, int directory_type ) {
+    char * config_path, * basedir = xdg_config_dir( directory_type );
+    struct stat st;
+
+    config_path = (char*)malloc( ( strlen( basedir ) + strlen( "/yawn/" ) + strlen( filename ) ) * sizeof( char ) );
+    sprintf( config_path, "%s/yawn/%s", basedir, filename );
+
+    if ( stat( config_path, &st ) != 0 ) {
+        if ( directory_type == CONFIG_DIR_HOME ) {
+            // local configuration file not found. Try reading system configuration file instead.
+            return xdg_config_path( filename, CONFIG_DIR_SYSTEM );
+        }
+        else {
+            printf( "System configuration file %s not found. Please reinstall yawn.\n", config_path );
+            exit( 1 );
+        }
+    }
+
+    return config_path;
+}
+
+void configuration_read( char * filename ) {
+    int argc, (*callback)( int, char ** );
+    char line[ 256 ], section[ 256 ], * argv[ 128 ];
+    FILE * fp = fopen( xdg_config_path( "yawn.conf", CONFIG_DIR_HOME ), "r" );
+
+    while ( freadline( fp, line ) != EOF ) {
+        int length = strlen( line );
+        if ( !length || line[ 0 ] == '#' ) {
+            continue;
+        }
+        if ( line[ 0 ] == '[' && line[ length - 1 ] == ']' ) {
+            line[ length - 1 ] = '\0';
+            strcpy( section, line + 1 );
+            continue;
+        }
+        argc = string_split( line, " ", argv );
+        callback = get_action( section );
+        callback( argc, argv );
+    }
+}

configuration.h

@@ -0,0 +1,12 @@
+#ifndef CONFIGURATION_H
+#define CONFIGURATION_H
+
+#define CONFIG_DIR_HOME 0
+#define CONFIG_DIR_SYSTEM 1
+
+char * xdg_config_dir( int directory_type );
+char * xdg_config_path( char * filename, int directory_type );
+void configuration_read( char * filename );
+
+#endif
+

desktop.c

@@ -0,0 +1,48 @@
+#include <stdio.h>
+#include "globals.h"
+#include "desktop.h"
+#include "client.h"
+#include "stack.h"
+#include "window.h"
+
+int desktop_change( int argc, char ** argv ) {
+    int i;
+    struct client_t *c;
+
+    sscanf( argv[ 0 ], "%s", &i );
+
+    if ( i == current_desktop ) {
+        return 0;
+    }
+
+    if ( head != NULL ) {
+        for( c = head; c; c= c->next ) {
+            xcb_unmap_window( xconn, c->win );
+        }
+    }
+
+    desktop_save( current_desktop );
+    desktop_select( i );
+
+    if ( head != NULL ) {
+        for( c = head; c; c = c->next ) {
+            xcb_map_window( xconn, c->win );
+        }
+    }
+
+    stack_tile();
+    window_current_update();
+
+    return 0;
+}
+
+void desktop_save( int i ) {
+    desktops[ i ].head = head;
+    desktops[ i ].current = current;
+}
+
+void desktop_select( int i ) {
+    head = desktops[ i ].head;
+    current = desktops[ i ].current;
+    current_desktop = i;
+}

desktop.h

@@ -0,0 +1,13 @@
+#ifndef DESKTOP_H
+#define DESKTOP_H
+
+struct desktop_t {
+    struct client_t *head;
+    struct client_t *current;
+};
+
+int desktop_change( int argc, char ** argv );
+void desktop_save( int i );
+void desktop_select( int i );
+
+#endif

event.c

@@ -0,0 +1,83 @@
+#include <stdio.h>
+#include "event.h"
+#include "globals.h"
+
+void (*events[256])( xcb_generic_event_t * ) = {
+    [XCB_KEY_PRESS] = event_keypress,
+    [XCB_CONFIGURE_REQUEST] = event_configurerequest,
+    [XCB_DESTROY_NOTIFY] = event_destroynotify,
+    [XCB_CONFIGURE_NOTIFY] = event_configurenotify,
+    [XCB_MAP_REQUEST] = event_maprequest,
+    [XCB_ENTER_NOTIFY] = event_enternotify
+};
+
+void event_keypress( xcb_generic_event_t* e ) {
+    xcb_key_press_event_t * ev = (xcb_key_press_event_t*)e;
+    timestamp = ev->time;
+    xcb_keysym_t keysym = xcb_key_symbols_get_keysym( symbols, ev->detail, 0 );
+    printf( "yawn: keypress %i %i %i\n", ev->detail, keysym, ev->state );
+    int i = 0;
+    printf( "keybinding count: %i\n", bindingsCount );
+    for ( i = 0; i < bindingsCount; ++i ) {
+        struct keybinding_t k = keybindings[ i ];
+        printf( "key sym: %i state: %i\n", k.key, k.state );
+        if ( k.key == keysym && ev->state & k.state ) {
+            printf( "found key binding! calling callback! %i %s\n", k.argc, k.argv[ 0 ] );
+            k.callback( k.argc, k.argv );
+        }
+    }
+}
+
+void event_maprequest( xcb_generic_event_t* e ) {
+    printf( "yawn: maprequest\n" );
+
+    xcb_map_request_event_t* ev = (xcb_map_request_event_t*)e;
+    stack_add( ev->window );
+    client_manage( ev->window );
+    stack_tile();
+    window_current_update();
+}
+
+void event_destroynotify( xcb_generic_event_t* e ) {
+    printf( "yawn: destroynotify\n" );
+    xcb_destroy_notify_event_t* ev = (xcb_destroy_notify_event_t*)e;
+    stack_remove( ev->window );
+    stack_tile();
+    window_current_update();
+}
+
+void event_configurenotify( xcb_generic_event_t* e ) {
+    printf( "yawn: configurenotify\n" );
+}
+
+void event_configurerequest( xcb_generic_event_t * e ) {
+    xcb_configure_request_event_t * ev = (xcb_configure_request_event_t*)e;
+
+    printf( "yawn: configurerequest\n" );
+
+    uint16_t config_win_mask = 0;
+    uint32_t config_win_vals[ 7 ];
+
+    uint16_t masks[ 7 ] = { XCB_CONFIG_WINDOW_X, XCB_CONFIG_WINDOW_Y, XCB_CONFIG_WINDOW_WIDTH, XCB_CONFIG_WINDOW_HEIGHT, XCB_CONFIG_WINDOW_BORDER_WIDTH, XCB_CONFIG_WINDOW_SIBLING, XCB_CONFIG_WINDOW_STACK_MODE };
+
+    uint32_t values[ 7 ] = { ev->x, ev->y, ev->width, ev->height, ev->border_width, ev->sibling, ev->stack_mode };
+
+    unsigned int i;
+    unsigned int count = 0;
+    for ( i = 0; i < 7; ++i ) {
+        uint16_t mask = masks[ i ];
+        if ( ev->value_mask & mask ) {
+            config_win_mask |= mask;
+            config_win_vals[ count++ ] = values[ i ];
+        }
+    }
+
+    xcb_configure_window( xconn, ev->window, config_win_mask, config_win_vals );
+    xcb_flush( xconn );
+}
+
+void event_enternotify( xcb_generic_event_t * e ) {
+    printf( "yawn: enternotify\n" );
+    xcb_enter_notify_event_t * ev = (xcb_enter_notify_event_t*)e;
+    timestamp = ev->time;
+}

event.h

@@ -0,0 +1,17 @@
+#ifndef EVENT_H
+#define EVENT_H
+
+#include <xcb/xcb.h>
+#include "client.h"
+#include "keyboard.h"
+#include "stack.h"
+#include "window.h"
+
+void event_keypress( xcb_generic_event_t *e );
+void event_maprequest( xcb_generic_event_t *e );
+void event_destroynotify( xcb_generic_event_t *e );
+void event_configurenotify( xcb_generic_event_t *e );
+void event_configurerequest( xcb_generic_event_t *e );
+void event_enternotify( xcb_generic_event_t *e );
+
+#endif

globals.h

@@ -0,0 +1,28 @@
+#ifndef GLOBALS_H
+#define GLOBALS_H
+
+#include <xcb/xcb.h>
+#include <xcb/xcb_keysyms.h>
+#include "client.h"
+#include "desktop.h"
+
+extern int current_desktop;
+extern struct desktop_t desktops[10];
+extern xcb_connection_t * xconn;
+extern xcb_screen_t * screen;
+extern xcb_timestamp_t timestamp;
+extern struct client_t *head;
+extern struct client_t *current;
+extern xcb_key_symbols_t *symbols;
+extern uint32_t sh;
+extern uint32_t sw;
+extern uint8_t default_depth;
+extern int bindingsCount;
+extern int default_screen;
+extern xcb_query_tree_cookie_t tree_c;
+extern void (*events[256])( xcb_generic_event_t * );
+extern int modifierAsciiToMask[ 256 ];
+
+
+#endif
+