source: neercs/trunk/src/main.c @ 2382

/*
 *  neercs        console-based window manager
 *  Copyright (c) 2006 Sam Hocevar <sam@zoy.org>
 *                2008 Jean-Yves Lamoureux <jylam@lnxscene.org>
 *                All Rights Reserved
 *
 *  $Id$
 *
 *  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/types.h>
#include <signal.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/wait.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"


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

int main(int argc, char **argv)
{
    static cucul_canvas_t *cv;
    static caca_display_t *dp;
    struct screen_list *screen_list = NULL;
    char *default_shell = NULL;
    int pty = 0, prevpty = 0, i, w, h, nt, args = 0;
    int eof = 0, refresh = 1, command = 0;

    /* Add-ons*/
    int mini = 1;
    int status = 1;
    int help = 0;


    nt = argc - 1;
    args = nt;

    if(nt == 0)
    {
        nt = 1;
    }

    default_shell = getenv("SHELL");

    if(default_shell == NULL  && !args)
    {
        fprintf(stderr, "Environment variable SHELL not set and no arguments given. kthxbye.\n");
        return -1;
    }

    /* Create main canvas and associated caca window */
    cv = cucul_create_canvas(0, 0);
    dp = caca_create_display(cv);
    if(!dp)
        return 1;
    caca_set_cursor(dp, 1);


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

    w = 80;
    h = 25;


    /* Create screen list */
    screen_list = (struct screen_list*)     malloc(sizeof(struct screen_list));
    if(!screen_list)
    {
        fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__, __LINE__);
        return -1;
    }
    screen_list->screen = (struct screen**) malloc(sizeof(sizeof(struct screen*)));
    if(!screen_list->screen)
    {
        fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__, __LINE__);
        return -1;
    }
    screen_list->count = 0;
    screen_list->width  = cucul_get_canvas_width(cv);
    screen_list->height = cucul_get_canvas_height(cv) - ((mini*6) + (status));
    screen_list->wm_type = WM_VSPLIT;
    screen_list->in_bell = 0;

    for(i = 0; i < nt; i++)
    {
        struct screen *tmp;
        if(args) tmp = create_screen(w, h, argv[i + 1]);
        else     tmp = create_screen(w, h, default_shell);

        if(tmp)
        {
            if(add_screen(screen_list, tmp) < 0)
            {
                fprintf(stderr, "Can't add %p to %p\n", tmp, screen_list);
            }
        }
        else
        {
            fprintf(stderr, "Can't create screen\n");
        }
    }

    /* Windows are in a temporary state, resize them to the right dimensions */
    update_windows_props(cv, screen_list, pty);

    caca_refresh_display(dp);

    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 < screen_list->count; i++)
        {
            if(screen_list->screen[i]->fd >= 0)
                FD_SET(screen_list->screen[i]->fd, &fdset);
            if(screen_list->screen[i]->fd > maxfd)
                maxfd = screen_list->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 < screen_list->count; i++)
                    if(screen_list->screen[i]->total)
                        break;
                if(i == screen_list->count)
                    break;
            }
        }
        else if(ret)
            for(i = 0; i < screen_list->count; i++)
            {
                /* FIXME: try a new strategy: read all filedescriptors until
                 * each of them starved at least once. */

                if(screen_list->screen[i]->fd < 0 ||
                   !FD_ISSET(screen_list->screen[i]->fd, &fdset))
                    continue;

                for(;;)
                {
                    ssize_t nr;

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

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

                    if(nr == 0 || errno != EWOULDBLOCK) {
                        close(screen_list->screen[i]->fd);
                        screen_list->screen[i]->fd = -1;
                        destroy_screen(screen_list->screen[i]);
                        remove_screen(screen_list, i, 0);
                        refresh = 1;
                    }

                    break;
                }
            }

        if(!screen_list->count) break;

        for(i = 0; i < screen_list->count; i++)
        if(screen_list->screen[i]->total)
        {
            unsigned long int bytes;

            bytes = import_term(screen_list,
                                screen_list->screen[i],
                                screen_list->screen[i]->buf,
                                screen_list->screen[i]->total);

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

        /* Get events, if any */
        ret = caca_get_event(dp, CACA_EVENT_ANY, &ev, 0);
        if(ret && (caca_get_event_type(&ev) & CACA_EVENT_KEY_PRESS))
        {
            unsigned int c = caca_get_event_key_ch(&ev);

            if(command)
            {
                command = 0;

                switch(c)
                {
                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) % screen_list->count;
                    refresh = 1;
                    break;
                case 'p':
                case 0x10: //CACA_KEY_CTRL_P:
                    prevpty = pty;
                    pty = (pty + screen_list->count - 1) % screen_list->count;
                    refresh = 1;
                    break;
                case 'c':
                case 0x03: //CACA_KEY_CTRL_C:
                    prevpty = pty;
                    pty =
                        add_screen(screen_list, create_screen(w, h, default_shell));
                    refresh = 1;
                    break;
                case 'w':
                case 0x17: //CACA_KEY_CTRL_W:
                    screen_list->wm_type = (screen_list->wm_type==(WM_MAX-1)?
                                            screen_list->wm_type=0:
                                            screen_list->wm_type+1);
                    refresh = 1;
                    break;
                case 0x0b: //CACA_KEY_CTRL_K:
                    remove_screen(screen_list, pty, 1);
                    pty = prevpty;
                    refresh = 1;
                    break;
                case 'h':
                case 0x08: //CACA_KEY_CTRL_H:
                    help = !help;
                    refresh = 1;
                    break;
                }
            }
            else
            {
                switch(c)
                {
                case 0x01: //CACA_KEY_CTRL_A:
                    command = 1; break;
                case CACA_KEY_UP:
                    write(screen_list->screen[pty]->fd, "\x1b[A", 3); break;
                case CACA_KEY_DOWN:
                    write(screen_list->screen[pty]->fd, "\x1b[B", 3); break;
                case CACA_KEY_RIGHT:
                    write(screen_list->screen[pty]->fd, "\x1b[C", 3); break;
                case CACA_KEY_LEFT:
                    write(screen_list->screen[pty]->fd, "\x1b[D", 3); break;
                case CACA_KEY_ESCAPE:
                    if(help) help = 0;
                default:
                    write(screen_list->screen[pty]->fd, &c, 1); break;
                }
            }
        }
        else if(ret && (caca_get_event_type(&ev) & CACA_EVENT_RESIZE))
        {
            update_windows_props(cv, screen_list, pty);

            cucul_clear_canvas(cv);
            refresh = 1;
        }
        else if(ret && (caca_get_event_type(&ev) & CACA_EVENT_QUIT))
        {
            break;
        }

        /* Refresh screen */
        if(refresh || screen_list->in_bell)
        {
            refresh = 0;

            screen_list->width  = cucul_get_canvas_width(cv);
            screen_list->height = cucul_get_canvas_height(cv) - (mini*6);

            update_windows_props(cv, screen_list, pty);

            if(screen_list->screen[pty]->title)
                caca_set_display_title(dp, screen_list->screen[pty]->title);
            else
                caca_set_display_title(dp, PACKAGE_STRING);

            cucul_set_color_ansi(cv, CUCUL_DEFAULT, CUCUL_DEFAULT);
            cucul_clear_canvas(cv);
            cucul_set_color_ansi(cv, CUCUL_LIGHTRED, CUCUL_BLACK);

            for(i = screen_list->count - 1; i >=0; i--)
            {
                if(i!=pty)
                {
                    cucul_blit(cv,
                               screen_list->screen[i]->x,
                               screen_list->screen[i]->y,
                               screen_list->screen[i]->cv, NULL);
                    cucul_draw_cp437_box(cv,
                                         screen_list->screen[i]->x - 1,
                                         screen_list->screen[i]->y - 1,
                                         screen_list->screen[i]->w + 2,
                                         screen_list->screen[i]->h + 2);
                }

            }

            cucul_blit(cv,
                       screen_list->screen[pty]->x,
                       screen_list->screen[pty]->y,
                       screen_list->screen[pty]->cv, NULL);

            if(screen_list->screen[pty]->bell)
            {
                cucul_set_color_ansi(cv, CUCUL_RED, CUCUL_BLACK);
                screen_list->screen[pty]->bell = 0;
                screen_list->in_bell--;
            }
            else
            {
                cucul_set_color_ansi(cv, CUCUL_LIGHTGREEN, CUCUL_BLACK);
            }
            cucul_draw_cp437_box(cv,
                                 screen_list->screen[pty]->x - 1,
                                 screen_list->screen[pty]->y - 1,
                                 screen_list->screen[pty]->w + 2,
                                 screen_list->screen[pty]->h + 2);

            cucul_gotoxy(cv,
                         screen_list->screen[pty]->x +
                         cucul_get_cursor_x(screen_list->screen[pty]->cv),
                         screen_list->screen[pty]->y +
                         cucul_get_cursor_y(screen_list->screen[pty]->cv));


            if(mini)
            {
                draw_thumbnails(cv, screen_list, pty);
            }
            if(status)
            {
                draw_status(cv, screen_list, pty);
            }
            if(help)
            {
                draw_help(cv, screen_list, pty);
            }


            caca_refresh_display(dp);
        }

        eof = 1;
        for(i = 0; i < screen_list->count; i++)
            if(screen_list->screen[i]->fd >= 0)
                eof = 0;
        if(eof)
            break;
    }

    /* Clean up */
    caca_free_display(dp);
    cucul_free_canvas(cv);
    for(i = 0; i < screen_list->count; i++)
    {
        destroy_screen(screen_list->screen[i]);
    }
    free(screen_list->screen);
    free(screen_list);


    return 0;
}

static int create_pty(char *cmd, unsigned int w, unsigned int h, int *cpid)
{
    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 *));
        if(!argv)
        {
            fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__, __LINE__);
            return -1;
        }
        argv[0] = cmd;
        argv[1] = NULL;
        execvp(cmd, argv);
        fprintf(stderr, "execvp() error\n");
        return -1;
    }

    *cpid = pid;

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

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;
}




struct screen* create_screen(int w, int h, char *command)
{
    struct screen *s = (struct screen*) malloc(sizeof(struct screen));

    s->cv = cucul_create_canvas(w, h);
    cucul_set_color_ansi(s->cv, CUCUL_BLACK, CUCUL_BLACK);
    cucul_clear_canvas(s->cv);
    s->init = 0;

    s->buf = NULL;
    s->title = NULL;
    s->total = 0;
    s->w = w+1;
    s->h = h+1;
    s->bell = 0;

    s->fd = create_pty(command, w, h, &s->pid);

    if(s->fd < 0)
    {
        cucul_free_canvas(s->cv);
        free(s);
        return NULL;
    }
    return s;
}

int destroy_screen(struct screen *s)
{
    if(s->fd>0)
        close(s->fd);
    if(s->buf)
        free(s->buf);
    if(s->title)
        free(s->title);
    s->buf = NULL;
    if(s->cv)
        cucul_free_canvas(s->cv);
    s->cv = NULL;
    if(s)
        free(s);
    s = NULL;
    return 1;
}

int add_screen(struct screen_list *list, struct screen *s)
{
    if(list == NULL || s == NULL) return -1;

    else
    {
        list->screen = (struct screen**) realloc(list->screen,
                                                 sizeof(sizeof(struct screen*))
                                                 * (list->count+1));
        list->screen[list->count] = s;
        list->count++;
    }

    return list->count-1;
}

int remove_screen(struct screen_list *list, int n, int please_kill)
{
    if(n>list->count) return -1;

    if(please_kill)
    {
        int status = 0;
        int ret = 0;
        /* FIXME */
        close(list->screen[n]->fd);
        list->screen[n]->fd = -1;
        kill(list->screen[n]->pid, SIGINT);
        ret = waitpid(list->screen[n]->pid, &status,
                      WNOHANG|WUNTRACED|WCONTINUED);
        if(!ret)
            kill(list->screen[n]->pid, SIGQUIT);
        ret = waitpid(list->screen[n]->pid, &status,
                      WNOHANG|WUNTRACED|WCONTINUED);
        if(!ret)
            kill(list->screen[n]->pid, SIGABRT);
        ret = waitpid(list->screen[n]->pid, &status,
                      WNOHANG|WUNTRACED|WCONTINUED);
        if(!ret)
            kill(list->screen[n]->pid, SIGKILL);

    }

    memmove(&list->screen[n],
            &list->screen[n+1],
            sizeof(struct screen*)*(list->count-(n+1)));

    list->screen = (struct screen**) realloc(list->screen,
                                             sizeof(sizeof(struct screen*))
                                             * (list->count));

    list->count--;
    return 1;
}