source: neercs/trunk/src/main.c @ 1834 Tweet

/*
 *  neercs        console-based window manager
 *  Copyright (c) 2006 Sam Hocevar <sam@zoy.org>
 *                All Rights Reserved
 *
 *  $Id: main.c 1834 2007-09-30 17:12:21Z sam $
 *
 *  This program is free software. It comes without any warranty, to
 *  the extent permitted by applicable law. You can redistribute it
 *  and/or modify it under the terms of the Do What The Fuck You Want
 *  To Public License, Version 2, as published by Sam Hocevar. See
 *  http://sam.zoy.org/wtfpl/COPYING for more details.
 */

#include "config.h"

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#if defined HAVE_PTY_H
#   include <pty.h>  /* for openpty and forkpty */
#else
#   include <util.h> /* for OS X */
#endif
#include <errno.h>
#include <cucul.h>
#include <caca.h>

#include "neercs.h"

#define XTAB 5
#define YTAB 3

static int create_pty(char *cmd, unsigned int w, unsigned int h);
static int set_tty_size(int fd, unsigned int w, unsigned int h);

int main(int argc, char **argv)
{
    static cucul_canvas_t *cv;
    static caca_display_t *dp;
    static struct screen *screen;
    int pty = 0, prevpty = 0, i, n, w, h;
    int eof = 0, refresh = 1, command = 0, mini = 1;

    if(argc < 2)
    {
        fprintf(stderr, "usage: %s <cmd1> [<cmd2> [<cmd3> ...]]\n", argv[0]);
        fprintf(stderr, "eg. \"%s zsh bash\"\n", argv[0]);
        return 1;
    }

    cv = cucul_create_canvas(0, 0);
    dp = caca_create_display(cv);
    if(!dp)
        return 1;

    n = argc - 1;
    screen = malloc(n * sizeof(struct screen));

    w = cucul_get_canvas_width(cv);
    h = cucul_get_canvas_height(cv);

    w = w <= XTAB * n ? 1 : w - XTAB * (n - 1) - 2;
    h = h <= YTAB * n ? 1 : h - YTAB * (n - 1) - 2 - 6;

    for(i = 0; i < n; i++)
    {
        screen[i].cv = cucul_create_canvas(w, h);
        screen[i].init = 0;
    }

    cucul_set_color_ansi(cv, CUCUL_LIGHTRED, CUCUL_BLACK);
    cucul_draw_cp437_box(cv, (n - 1 - pty) * XTAB, pty * YTAB,
                         w + (n - 1 - pty) * XTAB + 1, h + pty * YTAB + 1);

    caca_refresh_display(dp);

    for(i = 0; i < n; i++)
    {
        screen[i].buf = NULL;
        screen[i].total = 0;
        screen[i].fd = create_pty(argv[i + 1], w, h);
        if(screen[i].fd < 0)
            return -1;
    }

    for(;;)
    {
        struct timeval tv;
        fd_set fdset;
        caca_event_t ev;
        int maxfd = 0, ret;

        /* Read data, if any */
        FD_ZERO(&fdset);
        for(i = 0; i < n; i++)
        {
            FD_SET(screen[i].fd, &fdset);
            if(screen[i].fd > maxfd)
                maxfd = screen[i].fd;
        }
        tv.tv_sec = 0;
        tv.tv_usec = 50000;
        ret = select(maxfd + 1, &fdset, NULL, NULL, &tv);

        if(ret < 0)
        {
            if(errno == EINTR)
                ; /* We probably got a SIGWINCH, ignore it */
            else
            {
                for(i = 0; i < n; i++)
                    if(screen[i].total)
                        break;
                if(i == n)
                    break;
            }
        }
        else if(ret) for(i = 0; i < n; i++)
        {
            /* FIXME: try a new strategy: read all filedescriptors until
             * each of them starved at least once. */

            if(!FD_ISSET(screen[i].fd, &fdset))
                continue;

            for(;;)
            {
                ssize_t nr;

                screen[i].buf = realloc(screen[i].buf, screen[i].total + 1024);
                nr = read(screen[i].fd, screen[i].buf + screen[i].total, 1024);

                if(nr > 0)
                {
                    screen[i].total += nr;
                    continue;
                }

                if(nr == 0 || errno != EWOULDBLOCK)
                    eof = 1;

                break;
            }
        }

        for(i = 0; i < n; i++) if(screen[i].total)
        {
            unsigned long int bytes;

            bytes = import_term(&screen[i], screen[i].buf, screen[i].total);

            if(bytes > 0)
            {
                screen[i].total -= bytes;
                memmove(screen[i].buf, screen[i].buf + bytes, screen[i].total);
                refresh = 1;
            }
        }

        /* Get events, if any */
        ret = caca_get_event(dp, CACA_EVENT_ANY, &ev, 0);
        if(ret && (ev.type & CACA_EVENT_KEY_PRESS))
        {
            if(command)
            {
                command = 0;

                switch(ev.data.key.ch)
                {
                case 0x01: //CACA_KEY_CTRL_A:
                    pty ^= prevpty;
                    prevpty ^= pty;
                    pty ^= prevpty;
                    refresh = 1;
                    break;
                case 'm':
                case 0x0d: //CACA_KEY_CTRL_M:
                    mini = !mini;
                    refresh = 1;
                    break;
                case 'n':
                case ' ':
                case '\0':
                case 0x0e: //CACA_KEY_CTRL_N:
                    prevpty = pty;
                    pty = (pty + 1) % n;
                    refresh = 1;
                    break;
                case 'p':
                case 0x10: //CACA_KEY_CTRL_P:
                    prevpty = pty;
                    pty = (pty + n - 1) % n;
                    refresh = 1;
                    break;
                }
            }
            else
            {
                switch(ev.data.key.ch)
                {
                case 0x01: //CACA_KEY_CTRL_A:
                    command = 1; break;
                case CACA_KEY_UP:
                    write(screen[pty].fd, "\x1b[A", 3); break;
                case CACA_KEY_DOWN:
                    write(screen[pty].fd, "\x1b[B", 3); break;
                case CACA_KEY_RIGHT:
                    write(screen[pty].fd, "\x1b[C", 3); break;
                case CACA_KEY_LEFT:
                    write(screen[pty].fd, "\x1b[D", 3); break;
                default:
                    write(screen[pty].fd, &ev.data.key.ch, 1); break;
                }
            }
        }
        else if(ret && (ev.type & CACA_EVENT_RESIZE))
        {
            w = cucul_get_canvas_width(cv);
            h = cucul_get_canvas_height(cv);
            w = w <= XTAB * n ? 1 : w - XTAB * (n - 1) - 2;
            h = h <= YTAB * n ? 1 : h - YTAB * (n - 1) - 2;
            for(i = 0; i < n; i++)
            {
                cucul_set_canvas_size(screen[i].cv, w, h);
                set_tty_size(screen[i].fd, w, h);
            }
            cucul_clear_canvas(cv);
            refresh = 1;
        }

        /* Refresh screen */
        if(refresh)
        {
            refresh = 0;

            cucul_set_color_ansi(cv, CUCUL_LIGHTRED, CUCUL_BLACK);

            for(i = 0; i < n; i++)
            {
                int j = (pty + n - 1 - i) % n;
                cucul_blit(cv, (n - 1 - j) * XTAB + 1,
                               j * YTAB + 1, screen[j].cv, NULL);
                cucul_draw_cp437_box(cv, (n - 1 - j) * XTAB, j * YTAB,
                                     w + (n - 1 - j) * XTAB + 1, h + j * YTAB + 1);
            }

            if(mini)
            {
                char const * const *fonts;
                cucul_dither_t *d;
                cucul_font_t *f;
                uint8_t *buf;
                int miniw, minih;

                fonts = cucul_get_font_list();
                f = cucul_load_font(fonts[0], 0);

                miniw = cucul_get_canvas_width(screen[0].cv)
                         * cucul_get_font_width(f);
                minih = cucul_get_canvas_height(screen[0].cv)
                         * cucul_get_font_height(f);
                buf = malloc(4 * miniw * minih);

#if defined(HAVE_ENDIAN_H)
                if(__BYTE_ORDER == __BIG_ENDIAN)
#else
                /* This is compile-time optimised with at least -O1 or -Os */
                uint32_t const tmp = 0x12345678;
                if(*(uint8_t const *)&tmp == 0x12)
#endif
                    d = cucul_create_dither(32, miniw, minih, 4 * miniw,
                                            0xff0000, 0xff00, 0xff, 0x0);
                else
                    d = cucul_create_dither(32, miniw, minih, 4 * miniw,
                                            0xff00, 0xff0000, 0xff000000, 0x0);

                for(i = 0; i < n; i++)
                {
                    cucul_render_canvas(screen[i].cv, f, buf,
                                        miniw, minih, miniw * 4);
                    cucul_dither_bitmap(cv, 20 * i,
                              cucul_get_canvas_height(cv) - 6, 19, 6, d, buf);
                    cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLUE);
                    cucul_printf(cv, 20 * i,
                                 cucul_get_canvas_height(cv) - 6, "(%i)", i);
                }

                cucul_free_dither(d);
                cucul_free_font(f);

                free(buf);
            }

            caca_refresh_display(dp);
        }

        if(eof)
        {
            for(i = 0; i < n; i++)
                if(screen[i].total)
                    break;
            if(i == n)
                break;
        }
    }

    caca_get_event(dp, CACA_EVENT_KEY_PRESS, NULL, -1);

    /* Clean up */
    caca_free_display(dp);
    cucul_free_canvas(cv);
    for(i = 0; i < n; i++)
        cucul_free_canvas(screen[i].cv);

    return 0;
}

static int create_pty(char *cmd, unsigned int w, unsigned int h)
{
    char **argv;
    int fd;
    pid_t pid;

    pid = forkpty(&fd, NULL, NULL, NULL);
    if(pid < 0)
    {
        fprintf(stderr, "forkpty() error\n");
        return -1;
    }
    else if(pid == 0)
    {
        set_tty_size(0, w, h);
        putenv("CACA_DRIVER=slang");
        putenv("TERM=xterm");
        argv = malloc(2 * sizeof(char *));
        argv[0] = cmd;
        argv[1] = NULL;
        execvp(cmd, argv);
        fprintf(stderr, "execvp() error\n");
        return -1;
    }

    fcntl(fd, F_SETFL, O_NDELAY);
    return fd;
#if 0
    fprintf(stderr, "forkpty() not available\n");
    return -1;
#endif
}

static int set_tty_size(int fd, unsigned int w, unsigned int h)
{
    struct winsize ws;

    memset(&ws, 0, sizeof(ws));
    ws.ws_row = h;
    ws.ws_col = w;
    ioctl(fd, TIOCSWINSZ, (char *)&ws);

    return 0;
}