Changeset 3969 for neercs/trunk


Ignore:
Timestamp:
Nov 19, 2009, 5:26:53 PM (11 years ago)
Author:
Jean-Yves Lamoureux
Message:
  • Massive indentation pass, could insert odd things, blame pterjan, he doesn't care.
Location:
neercs/trunk/src
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • neercs/trunk/src/attach.c

    r3968 r3969  
    1 /*
     1/* 
    22 *  neercs        console-based window manager
    33 *  Copyright (c) 2006 Sam Hocevar <sam@zoy.org>
     
    3333#include "neercs.h"
    3434
    35 char * build_socket_path(char *socket_dir, char *session_name, enum socket_type socktype)
     35char *build_socket_path(char *socket_dir, char *session_name,
     36                        enum socket_type socktype)
    3637{
    3738    char *path, *dir;
    38     path = (char *)malloc(PATH_MAX+1);
     39    path = (char *)malloc(PATH_MAX + 1);
    3940    dir = socket_dir;
    40     if(!dir)
     41    if (!dir)
    4142        dir = getenv("NEERCSDIR");
    42     if(!dir)
     43    if (!dir)
    4344        dir = getenv("TMPDIR");
    44     if(!dir)
     45    if (!dir)
    4546        dir = "/tmp";
    46     if(path)
    47         snprintf(path, PATH_MAX+1, "%s/neercs.%s%s.sock", dir, session_name, socktype?"":".srv");
     47    if (path)
     48        snprintf(path, PATH_MAX + 1, "%s/neercs.%s%s.sock", dir, session_name,
     49                 socktype ? "" : ".srv");
    4850    return path;
    4951}
    5052
    51 static char * socket_to_session(char const * sockpath)
     53static char *socket_to_session(char const *sockpath)
    5254{
    5355    char *p, *s;
    5456    p = strrchr(sockpath, '/');
    55     if(!p)
     57    if (!p)
    5658    {
    5759        debug("Invalid socket path %s", sockpath);
    5860        return NULL;
    5961    }
    60     p+=8; /* skip neercs. */
     62    p += 8;                    /* skip neercs. */
    6163    s = strdup(p);
    6264    p = strrchr(s, '.');
    63     *p = '\0'; /* drop .sock */
     65    *p = '\0';                  /* drop .sock */
    6466    p = strrchr(s, '.');
    65     *p = '\0'; /* drop .srv */
     67    *p = '\0';                  /* drop .srv */
    6668    p = strdup(s);
    6769    free(s);
     
    6971}
    7072
    71 int create_socket(struct screen_list* screen_list, enum socket_type socktype)
     73int create_socket(struct screen_list *screen_list, enum socket_type socktype)
    7274{
    7375    int sock;
     
    7678    sock = socket(AF_UNIX, SOCK_DGRAM, 0);
    7779
    78     if(sock < 0)
     80    if (sock < 0)
    7981    {
    8082        perror("create_socket:socket");
     
    8587
    8688    myaddr.sun_family = AF_UNIX;
    87     strncpy(myaddr.sun_path, screen_list->socket_path[socktype], sizeof(myaddr.sun_path) - 1);
     89    strncpy(myaddr.sun_path, screen_list->socket_path[socktype],
     90            sizeof(myaddr.sun_path) - 1);
    8891
    8992    unlink(screen_list->socket_path[socktype]);
    9093
    91     if(bind(sock, (struct sockaddr *)&myaddr, sizeof(struct sockaddr_un)) < 0)
     94    if (bind(sock, (struct sockaddr *)&myaddr, sizeof(struct sockaddr_un)) < 0)
    9295    {
    9396        free(screen_list->socket_path[socktype]);
     
    106109}
    107110
    108 char ** list_sockets(char *socket_dir, char *session_name)
     111char **list_sockets(char *socket_dir, char *session_name)
    109112{
    110113    char *pattern, *dir;
     
    113116    globbuf.gl_pathv = NULL;
    114117
    115     pattern = (char *)malloc(PATH_MAX+1);
     118    pattern = (char *)malloc(PATH_MAX + 1);
    116119
    117120    dir = socket_dir;
    118     if(!dir)
     121    if (!dir)
    119122        dir = getenv("NEERCSDIR");
    120     if(!dir)
     123    if (!dir)
    121124        dir = getenv("TMPDIR");
    122     if(!dir)
     125    if (!dir)
    123126        dir = "/tmp";
    124127
    125     if(!pattern)
     128    if (!pattern)
    126129        return globbuf.gl_pathv;
    127130
    128     if(session_name && strlen(session_name)+strlen(dir)+13<PATH_MAX)
     131    if (session_name && strlen(session_name) + strlen(dir) + 13 < PATH_MAX)
    129132        sprintf(pattern, "%s/neercs.%s.srv.sock", dir, session_name);
    130133    else
     
    141144}
    142145
    143 char * connect_socket(struct screen_list* screen_list, enum socket_type socktype)
     146char *connect_socket(struct screen_list *screen_list,
     147                     enum socket_type socktype)
    144148{
    145149    int sock;
     
    149153
    150154    /* Open the socket */
    151     if ((sock = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) 
     155    if ((sock = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0)
    152156    {
    153157        perror("connect_server:socket");
     
    155159    }
    156160
    157     memset(&addr,0,sizeof(addr));
     161    memset(&addr, 0, sizeof(addr));
    158162    addr.sun_family = AF_UNIX;
    159     strcpy(addr.sun_path,screen_list->socket_path[socktype]);
     163    strcpy(addr.sun_path, screen_list->socket_path[socktype]);
    160164    if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0)
    161165    {
    162         debug("Failed to connect to %s: %s", screen_list->socket_path[socktype], strerror(errno));
     166        debug("Failed to connect to %s: %s",
     167              screen_list->socket_path[socktype], strerror(errno));
    163168        close(sock);
    164169        return NULL;
     
    168173    screen_list->socket[socktype] = sock;
    169174
    170     if(socktype == SOCK_SERVER)
     175    if (socktype == SOCK_SERVER)
    171176    {
    172177        return socket_to_session(screen_list->socket_path[socktype]);
     
    176181}
    177182
    178 int request_attach(struct screen_list* screen_list)
     183int request_attach(struct screen_list *screen_list)
    179184{
    180185    char buf[41];
    181186    int bytes;
    182187
    183     bytes = snprintf(buf, sizeof(buf)-1, "ATTACH %10d %10d %10d",
     188    bytes = snprintf(buf, sizeof(buf) - 1, "ATTACH %10d %10d %10d",
    184189                     caca_get_canvas_width(screen_list->cv),
    185190                     caca_get_canvas_height(screen_list->cv),
     
    190195}
    191196
    192 static char * select_socket(struct screen_list* screen_list)
     197static char *select_socket(struct screen_list *screen_list)
    193198{
    194199    char **sockets = NULL, **usable_sockets = NULL;
     
    197202
    198203    sockets = list_sockets(screen_list->socket_dir, screen_list->session_name);
    199     if(sockets)
    200     {
    201         for(i=0; sockets[i]; i++);
     204    if (sockets)
     205    {
     206        for (i = 0; sockets[i]; i++);
    202207
    203208        /* Return the socket or NULL if there is not more than one match */
    204         if(i<=1)
    205         {
    206             if(sockets[0])
     209        if (i <= 1)
     210        {
     211            if (sockets[0])
    207212                ret = strdup(sockets[0]);
    208213            goto end;
     
    210215
    211216        /* Else ask the user to chose one */
    212         usable_sockets = malloc(i*sizeof(char*));
    213         for(i=0; sockets[i]; i++)
     217        usable_sockets = malloc(i * sizeof(char *));
     218        for (i = 0; sockets[i]; i++)
    214219        {
    215220            struct sockaddr_un addr;
    216             if ((sock = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) 
     221            if ((sock = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0)
    217222            {
    218223                perror("select_socket:socket");
    219224                goto end;
    220225            }
    221             memset(&addr,0,sizeof(addr));
     226            memset(&addr, 0, sizeof(addr));
    222227            addr.sun_family = AF_UNIX;
    223228            strcpy(addr.sun_path, sockets[i]);
    224229            if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0)
    225230            {
    226                 switch(errno)
     231                switch (errno)
    227232                {
    228233                case EACCES:
     
    233238                    break;
    234239                default:
    235                     fprintf(stderr, "Unknown error on %s:%s\n", sockets[i], strerror(errno));
     240                    fprintf(stderr, "Unknown error on %s:%s\n", sockets[i],
     241                            strerror(errno));
    236242                }
    237243            }
     
    244250            }
    245251        }
    246         if(!nb_usable_sockets)
     252        if (!nb_usable_sockets)
    247253            goto end;
    248         if(nb_usable_sockets == 1)
     254        if (nb_usable_sockets == 1)
    249255        {
    250256            ret = strdup(usable_sockets[0]);
     
    259265            screen_list->cv = caca_create_canvas(0, 0);
    260266            screen_list->dp = caca_create_display(screen_list->cv);
    261             if(!screen_list->dp)
     267            if (!screen_list->dp)
    262268                goto end;
    263269            caca_set_cursor(screen_list->dp, 0);
    264270            caca_set_display_title(screen_list->dp, PACKAGE_STRING);
    265             while(1)
     271            while (1)
    266272            {
    267                 if(refresh)
     273                if (refresh)
    268274                {
    269275                    caca_set_color_ansi(screen_list->cv, CACA_BLUE, CACA_BLUE);
     
    273279                                  caca_get_canvas_height(screen_list->cv),
    274280                                  '#');
    275                     caca_set_color_ansi(screen_list->cv, CACA_DEFAULT, CACA_BLUE);
    276                     caca_draw_cp437_box(screen_list->cv,
    277                                   0, 0,
    278                                   caca_get_canvas_width(screen_list->cv),
    279                                   caca_get_canvas_height(screen_list->cv)
    280                                   );
    281                     caca_printf(screen_list->cv, 2, 2, "Please select a session to reconnect:");
    282                     for(i=0; i<nb_usable_sockets; i++)
     281                    caca_set_color_ansi(screen_list->cv, CACA_DEFAULT,
     282                                        CACA_BLUE);
     283                    caca_draw_cp437_box(screen_list->cv, 0, 0,
     284                                        caca_get_canvas_width(screen_list->cv),
     285                                        caca_get_canvas_height(screen_list->
     286                                                               cv));
     287                    caca_printf(screen_list->cv, 2, 2,
     288                                "Please select a session to reconnect:");
     289                    for (i = 0; i < nb_usable_sockets; i++)
    283290                    {
    284                         if(i == current_line-1)
     291                        if (i == current_line - 1)
    285292                        {
    286293                            caca_set_attr(screen_list->cv, CACA_BOLD);
    287                             caca_set_color_ansi(screen_list->cv, CACA_GREEN, CACA_BLUE);
    288                             caca_put_char(screen_list->cv, 1, i+3, '>');
     294                            caca_set_color_ansi(screen_list->cv, CACA_GREEN,
     295                                                CACA_BLUE);
     296                            caca_put_char(screen_list->cv, 1, i + 3, '>');
    289297                        }
    290298                        else
    291299                        {
    292300                            caca_set_attr(screen_list->cv, 0);
    293                             caca_set_color_ansi(screen_list->cv, CACA_LIGHTGRAY, CACA_BLUE);
    294                             caca_put_char(screen_list->cv, 1, i+3, ' ');
     301                            caca_set_color_ansi(screen_list->cv,
     302                                                CACA_LIGHTGRAY, CACA_BLUE);
     303                            caca_put_char(screen_list->cv, 1, i + 3, ' ');
    295304                        }
    296305                        caca_printf(screen_list->cv,
    297                                     3, i+3,
     306                                    3, i + 3,
    298307                                    "%s",
    299308                                    socket_to_session(usable_sockets[i]));
     
    303312                }
    304313
    305                 if(!caca_get_event(screen_list->dp,
    306                                   CACA_EVENT_KEY_PRESS
    307                                   |CACA_EVENT_RESIZE
    308                                   |CACA_EVENT_QUIT,
    309                                   &ev, 10000))
     314                if (!caca_get_event(screen_list->dp,
     315                                    CACA_EVENT_KEY_PRESS
     316                                    | CACA_EVENT_RESIZE
     317                                    | CACA_EVENT_QUIT, &ev, 10000))
    310318                    continue;
    311319
    312320                t = caca_get_event_type(&ev);
    313321
    314                 if(t & CACA_EVENT_KEY_PRESS)
     322                if (t & CACA_EVENT_KEY_PRESS)
    315323                {
    316324                    unsigned int c = caca_get_event_key_ch(&ev);
    317                     switch(c)
     325                    switch (c)
    318326                    {
    319327                    case CACA_KEY_UP:
    320                         if(current_line>1)
     328                        if (current_line > 1)
    321329                            current_line--;
    322330                        break;
    323331                    case CACA_KEY_DOWN:
    324                         if(current_line<nb_usable_sockets)
     332                        if (current_line < nb_usable_sockets)
    325333                            current_line++;
    326334                        break;
    327335                    case CACA_KEY_RETURN:
    328                         ret = strdup(usable_sockets[current_line-1]);
     336                        ret = strdup(usable_sockets[current_line - 1]);
    329337                        goto end;
    330338                        break;
     
    337345                    refresh = 1;
    338346                }
    339                 else if(t & CACA_EVENT_RESIZE)
     347                else if (t & CACA_EVENT_RESIZE)
    340348                {
    341349                    refresh = 1;
    342350                }
    343                 else if(t & CACA_EVENT_QUIT)
     351                else if (t & CACA_EVENT_QUIT)
    344352                    goto end;
    345353            }
     
    347355    }
    348356
    349 end:
    350     if(sockets)
    351     {
    352         for(i=0; sockets[i]; i++)
     357  end:
     358    if (sockets)
     359    {
     360        for (i = 0; sockets[i]; i++)
    353361            free(sockets[i]);
    354362        free(sockets);
    355363    }
    356     if(usable_sockets)
    357     {
    358         for(i=0; i<nb_usable_sockets; i++)
     364    if (usable_sockets)
     365    {
     366        for (i = 0; i < nb_usable_sockets; i++)
    359367            free(usable_sockets[i]);
    360368        free(usable_sockets);
    361369    }
    362     if(screen_list->dp)
     370    if (screen_list->dp)
    363371    {
    364372        caca_free_display(screen_list->dp);
    365373        screen_list->dp = NULL;
    366374    }
    367     if(screen_list->cv)
     375    if (screen_list->cv)
    368376    {
    369377        caca_free_canvas(screen_list->cv);
     
    373381}
    374382
    375 void attach(struct screen_list* screen_list)
     383void attach(struct screen_list *screen_list)
    376384{
    377385    screen_list->socket_path[SOCK_SERVER] = select_socket(screen_list);
    378386
    379     if(screen_list->socket_path[SOCK_SERVER])
     387    if (screen_list->socket_path[SOCK_SERVER])
    380388    {
    381389        char *session;
    382390        session = connect_socket(screen_list, SOCK_SERVER);
    383         if(session)
     391        if (session)
    384392        {
    385393            debug("Connected to session %s", session);
     
    387395            screen_list->cv = caca_create_canvas(0, 0);
    388396            screen_list->dp = caca_create_display(screen_list->cv);
    389             if(!screen_list->dp)
     397            if (!screen_list->dp)
    390398                return;
    391             caca_set_display_time(screen_list->dp, screen_list->delay*1000);
     399            caca_set_display_time(screen_list->dp, screen_list->delay * 1000);
    392400            caca_set_cursor(screen_list->dp, 1);
    393401
    394402            screen_list->socket_path[SOCK_CLIENT] =
    395                 build_socket_path(screen_list->socket_dir, session, SOCK_CLIENT);
     403                build_socket_path(screen_list->socket_dir, session,
     404                                  SOCK_CLIENT);
    396405            create_socket(screen_list, SOCK_CLIENT);
    397406            request_attach(screen_list);
    398             if(screen_list->session_name)
     407            if (screen_list->session_name)
    399408                free(screen_list->session_name);
    400409            screen_list->session_name = session;
     
    415424}
    416425
    417 int send_event(caca_event_t ev, struct screen_list* screen_list)
     426int send_event(caca_event_t ev, struct screen_list *screen_list)
    418427{
    419428    enum caca_event_type t;
     
    421430    t = caca_get_event_type(&ev);
    422431
    423     if(t & CACA_EVENT_KEY_PRESS)
     432    if (t & CACA_EVENT_KEY_PRESS)
    424433    {
    425434        char buf[16];
    426435        int bytes;
    427         bytes = snprintf(buf, sizeof(buf)-1, "KEY %d", caca_get_event_key_ch(&ev));
     436        bytes =
     437            snprintf(buf, sizeof(buf) - 1, "KEY %d",
     438                     caca_get_event_key_ch(&ev));
    428439        buf[bytes] = '\0';
    429440        debug("Sending key press to server: %s", buf);
    430441        return write(screen_list->socket[SOCK_SERVER], buf, strlen(buf)) <= 0;
    431442    }
    432     else if(t & CACA_EVENT_RESIZE)
     443    else if (t & CACA_EVENT_RESIZE)
    433444    {
    434445        char buf[32];
    435446        int bytes;
    436         bytes = snprintf(buf, sizeof(buf)-1, "RESIZE %10d %10d",
     447        bytes = snprintf(buf, sizeof(buf) - 1, "RESIZE %10d %10d",
    437448                         caca_get_event_resize_width(&ev),
    438449                         caca_get_event_resize_height(&ev));
     
    441452        return write(screen_list->socket[SOCK_SERVER], buf, strlen(buf)) <= 0;
    442453    }
    443     else if(t & CACA_EVENT_QUIT)
    444         return write(screen_list->socket[SOCK_SERVER], "QUIT", strlen("QUIT")) <= 0;
     454    else if (t & CACA_EVENT_QUIT)
     455        return write(screen_list->socket[SOCK_SERVER], "QUIT",
     456                     strlen("QUIT")) <= 0;
    445457
    446458    return 0;
    447459}
    448460
    449 int send_delay(struct screen_list* screen_list)
     461int send_delay(struct screen_list *screen_list)
    450462{
    451463    char buf[18];
    452464    int bytes;
    453     bytes = snprintf(buf, sizeof(buf)-1, "DELAY %10d", screen_list->delay);
     465    bytes = snprintf(buf, sizeof(buf) - 1, "DELAY %10d", screen_list->delay);
    454466    buf[bytes] = '\0';
    455467    return write(screen_list->socket[SOCK_SERVER], buf, strlen(buf)) <= 0;
  • neercs/trunk/src/configuration.c

    r3961 r3969  
    1 /*
     1/* 
    22 *  neercs        console-based window manager
    33 *  Copyright (c) 2006 Sam Hocevar <sam@zoy.org>
     
    3636
    3737    /* Check if file exist */
    38     if(stat(filename, &st) < 0)
    39     {
    40         return -1;
    41     }
    42     /* Get its size  */
     38    if (stat(filename, &st) < 0)
     39    {
     40        return -1;
     41    }
     42    /* Get its size */
    4343    size = st.st_size;
    44     if(!size)
     44    if (!size)
    4545    {
    4646        fprintf(stderr, "File too short\n");
     
    5050    /* Open it */
    5151    fp = fopen(filename, "r");
    52     if(!fp)
     52    if (!fp)
    5353    {
    5454        return -1;
     
    5656
    5757    buffer = malloc(size + 1);
    58     if(!buffer)
     58    if (!buffer)
    5959    {
    6060        fclose(fp);
    61         fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__, __LINE__);
     61        fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__,
     62                __LINE__);
    6263        return -1;
    6364    }
    6465    /* Read it */
    65     while((i = fread(buffer+total, 1, size, fp)) > 0)
    66     {
    67         total+=i;
     66    while ((i = fread(buffer + total, 1, size, fp)) > 0)
     67    {
     68        total += i;
    6869    }
    6970    buffer[total] = '\n';
     
    7172    fclose(fp);
    7273
    73     i=0;
     74    i = 0;
    7475
    7576    /* Parse it */
    76     while((i = parse_conf_line(buffer + offset, total-offset, screen_list)) > 0)
    77     {
    78         offset+=i;
     77    while ((i =
     78            parse_conf_line(buffer + offset, total - offset, screen_list)) > 0)
     79    {
     80        offset += i;
    7981        l++;
    8082    }
     
    9799    static struct option *prev = NULL;
    98100
    99     if(size <= 0) return -1;
    100 
    101     /* Find EOL  */
    102     for(i=0; i<size; i++)
    103     {
    104         if(buf[i] == '\n')
     101    if (size <= 0)
     102        return -1;
     103
     104    /* Find EOL */
     105    for (i = 0; i < size; i++)
     106    {
     107        if (buf[i] == '\n')
    105108        {
    106109            s = i + 1;
     
    110113
    111114    /* Strip comments and trailing spaces */
    112     for(i=0; i<s; i++)
    113     {
    114         if(buf[i] == ';' && !in_quote)
     115    for (i = 0; i < s; i++)
     116    {
     117        if (buf[i] == ';' && !in_quote)
    115118        {
    116119            eol = i;
    117120            break;
    118121        }
    119         else if(buf[i] == '\n')
     122        else if (buf[i] == '\n')
    120123        {
    121124            eol = i;
    122125            break;
    123126        }
    124         else if(buf[i] == ' ' && !c) {}
     127        else if (buf[i] == ' ' && !c)
     128        {
     129        }
    125130        else
    126131        {
    127             if(line == NULL)
     132            if (line == NULL)
    128133            {
    129134                line = malloc(2);
    130                 if(!line)
     135                if (!line)
    131136                {
    132137                    fprintf(stderr, "Can't allocate memory at %s:%d\n",
    133                            __FUNCTION__, __LINE__);
     138                            __FUNCTION__, __LINE__);
    134139                    return -1;
    135140                }
     
    137142            else
    138143            {
    139                 line = realloc(line, l+2);
    140                 if(!line)
     144                line = realloc(line, l + 2);
     145                if (!line)
    141146                {
    142147                    fprintf(stderr, "Can't allocate memory at %s:%d\n",
    143                            __FUNCTION__, __LINE__);
     148                            __FUNCTION__, __LINE__);
    144149                    return -1;
    145150                }
    146151            }
    147             if(buf[i] == '"')
     152            if (buf[i] == '"')
    148153                in_quote = !in_quote;
    149             if(buf[i] == ' ')
     154            if (buf[i] == ' ')
    150155                end_spaces++;
    151156            else
    152157                end_spaces = 0;
    153158
    154             line[l]   = buf[i];
    155             line[l+1] = 0;
     159            line[l] = buf[i];
     160            line[l + 1] = 0;
    156161            l++;
    157162            c = 1;
     
    159164    }
    160165
    161     if(c==0)
     166    if (c == 0)
    162167    {
    163168        /* This line is empty, do nothing */
     
    166171    {
    167172        struct option *option = malloc(sizeof(struct option));
    168         if(!option)
     173        if (!option)
    169174        {
    170175            fprintf(stderr, "Can't allocate memory at %s:%d\n",
    171                    __FUNCTION__, __LINE__);
     176                    __FUNCTION__, __LINE__);
    172177            return -1;
    173178        }
    174179        option->next = NULL;
    175         l-=end_spaces;
    176         line = realloc(line, l+1);
     180        l -= end_spaces;
     181        line = realloc(line, l + 1);
    177182        line[l] = 0;
    178183
    179184        get_key_value(line, option);
    180185
    181         if(!screen_list->config)
     186        if (!screen_list->config)
    182187            screen_list->config = option;
    183188
    184         if(prev)
     189        if (prev)
    185190            prev->next = option;
    186191
     
    193198int get_key_value(char *line, struct option *option)
    194199{
    195     unsigned int i, o = 0, b=0, end_spaces = 0;
     200    unsigned int i, o = 0, b = 0, end_spaces = 0;
    196201    char *cur = NULL;
    197202    option->value = NULL;
     
    199204
    200205    /* Line is a section delimiter */
    201     if(line[0] == '[')
     206    if (line[0] == '[')
    202207    {
    203208        option->value = malloc(strlen(line) - 1);
    204         if(!option->value)
     209        if (!option->value)
    205210        {
    206211            fprintf(stderr, "Can't allocate memory at %s:%d\n",
     
    208213            return -1;
    209214        }
    210         memcpy(option->value, line+1, strlen(line) - 1);
     215        memcpy(option->value, line + 1, strlen(line) - 1);
    211216        option->value[strlen(line) - 2] = 0;
    212217        return 0;
     
    214219
    215220    cur = malloc(1);
    216     if(!cur)
     221    if (!cur)
    217222    {
    218223        fprintf(stderr, "Can't allocate memory at %s:%d\n",
     
    222227    cur[0] = 0;
    223228
    224     for(i=0; i<strlen(line); i++)
    225     {
    226         if(line[i] == ' ' && !b) continue;
    227 
    228 
    229         if(line[i] == '=')
     229    for (i = 0; i < strlen(line); i++)
     230    {
     231        if (line[i] == ' ' && !b)
     232            continue;
     233
     234
     235        if (line[i] == '=')
    230236        {
    231237            b = 0;
    232             cur[o-end_spaces] = 0;
    233             cur = realloc(cur, (o-end_spaces)+1);
    234             if(!cur)
     238            cur[o - end_spaces] = 0;
     239            cur = realloc(cur, (o - end_spaces) + 1);
     240            if (!cur)
    235241            {
    236242                fprintf(stderr, "Can't allocate memory at %s:%d\n",
    237                        __FUNCTION__, __LINE__);
     243                        __FUNCTION__, __LINE__);
    238244                return -1;
    239245            }
     
    244250        else
    245251        {
    246             if(line[i] == ' ') end_spaces++;
    247             else end_spaces = 0;
    248 
    249             cur = realloc(cur, o+2);
    250             if(!cur)
     252            if (line[i] == ' ')
     253                end_spaces++;
     254            else
     255                end_spaces = 0;
     256
     257            cur = realloc(cur, o + 2);
     258            if (!cur)
    251259            {
    252260                fprintf(stderr, "Can't allocate memory at %s:%d\n",
    253                        __FUNCTION__, __LINE__);
     261                        __FUNCTION__, __LINE__);
    254262                return -1;
    255263            }
    256             cur[o]   = line[i];
     264            cur[o] = line[i];
    257265            o++;
    258266            b = 1;
     
    276284    char *section = NULL;
    277285
    278     while(option)
    279     {
    280         if(option->key == NULL)
     286    while (option)
     287    {
     288        if (option->key == NULL)
    281289        {
    282290            section = option->key;
     
    285293        }
    286294
    287         if(IS_TOKEN("window_manager"))
    288         {
    289             if     (IS_VALUE("full"))   screen_list->wm_type = WM_FULL;
    290             else if(IS_VALUE("hsplit")) screen_list->wm_type = WM_HSPLIT;
    291             else if(IS_VALUE("vsplit")) screen_list->wm_type = WM_VSPLIT;
    292             else if(IS_VALUE("card"))   screen_list->wm_type = WM_CARD;
    293             else if(IS_VALUE("cube"))   screen_list->wm_type = WM_CUBE;
    294             else fprintf(stderr, "Unknown window manager '%s'\n", option->key);
    295 
    296         } else if(IS_TOKEN("cube_duration"))
    297         {
    298            screen_list->cube.duration = atoi(option->value) * 1000000;
    299         } else if(IS_TOKEN("thumbnails"))
    300         {
    301             if     (IS_VALUE("true") || IS_VALUE("1")) screen_list->mini = 1;
    302             else                                       screen_list->mini = 0;
    303 
    304         } else if(IS_TOKEN("status_bar"))
    305         {
    306             if     (IS_VALUE("true") || IS_VALUE("1")) screen_list->status = 1;
    307             else                                       screen_list->status = 0;
    308 
    309         } else if(IS_TOKEN("screensaver_timeout"))
     295        if (IS_TOKEN("window_manager"))
     296        {
     297            if (IS_VALUE("full"))
     298                screen_list->wm_type = WM_FULL;
     299            else if (IS_VALUE("hsplit"))
     300                screen_list->wm_type = WM_HSPLIT;
     301            else if (IS_VALUE("vsplit"))
     302                screen_list->wm_type = WM_VSPLIT;
     303            else if (IS_VALUE("card"))
     304                screen_list->wm_type = WM_CARD;
     305            else if (IS_VALUE("cube"))
     306                screen_list->wm_type = WM_CUBE;
     307            else
     308                fprintf(stderr, "Unknown window manager '%s'\n", option->key);
     309
     310        }
     311        else if (IS_TOKEN("cube_duration"))
     312        {
     313            screen_list->cube.duration = atoi(option->value) * 1000000;
     314        }
     315        else if (IS_TOKEN("thumbnails"))
     316        {
     317            if (IS_VALUE("true") || IS_VALUE("1"))
     318                screen_list->mini = 1;
     319            else
     320                screen_list->mini = 0;
     321
     322        }
     323        else if (IS_TOKEN("status_bar"))
     324        {
     325            if (IS_VALUE("true") || IS_VALUE("1"))
     326                screen_list->status = 1;
     327            else
     328                screen_list->status = 0;
     329
     330        }
     331        else if (IS_TOKEN("screensaver_timeout"))
    310332        {
    311333            screen_list->screensaver_timeout = atoi(option->value) * 1000000;
    312334            /* if timeout is 0, set it to 0xFFFFFFFFFFFFFFFF */
    313             if(!screen_list->screensaver_timeout) screen_list->screensaver_timeout-=1;
    314         }  else if(IS_TOKEN("autolock_timeout"))
     335            if (!screen_list->screensaver_timeout)
     336                screen_list->screensaver_timeout -= 1;
     337        }
     338        else if (IS_TOKEN("autolock_timeout"))
    315339        {
    316340            debug("Autolock is %d\n", screen_list->autolock_timeout);
    317             if(screen_list->autolock_timeout == 0 ||
    318                screen_list->autolock_timeout == ((long long unsigned int)0) - 1)
    319             {
    320                 screen_list->autolock_timeout = atoi(option->value) * 1000000;
    321                 /* if timeout is 0, set it to 0xFFFFFFFFFFFFFFFF */
    322                 if(!screen_list->autolock_timeout) screen_list->autolock_timeout-=1;
    323             }
    324         }  else if(IS_TOKEN("lock_on_detach"))
    325         {
    326             if     (IS_VALUE("true") || IS_VALUE("1")) screen_list->lock_on_detach = 1;
    327             else                                       screen_list->lock_on_detach = 0;
    328         } else if(IS_TOKEN("socket_dir"))
     341            if (screen_list->autolock_timeout == 0 ||
     342                screen_list->autolock_timeout ==
     343                ((long long unsigned int)0) - 1)
     344            {
     345                screen_list->autolock_timeout = atoi(option->value) * 1000000;
     346                /* if timeout is 0, set it to 0xFFFFFFFFFFFFFFFF */
     347                if (!screen_list->autolock_timeout)
     348                    screen_list->autolock_timeout -= 1;
     349            }
     350        }
     351        else if (IS_TOKEN("lock_on_detach"))
     352        {
     353            if (IS_VALUE("true") || IS_VALUE("1"))
     354                screen_list->lock_on_detach = 1;
     355            else
     356                screen_list->lock_on_detach = 0;
     357        }
     358        else if (IS_TOKEN("socket_dir"))
    329359        {
    330360            screen_list->socket_dir = option->value;
    331         } else if(IS_TOKEN("delay"))
     361        }
     362        else if (IS_TOKEN("delay"))
    332363        {
    333364            screen_list->requested_delay = atoi(option->value);
    334365            screen_list->delay = atoi(option->value);
    335         } else
     366        }
     367        else
    336368        {
    337369            fprintf(stderr, "Unknown option '%s'\n", option->key);
  • neercs/trunk/src/effects.c

    r3950 r3969  
    1 /*
     1/* 
    22 *  neercs        console-based window manager
    33 *  Copyright (c) 2006 Sam Hocevar <sam@zoy.org>
     
    2929void draw_thumbnails(struct screen_list *screen_list)
    3030{
    31     char const * const *fonts;
     31    char const *const *fonts;
    3232    caca_dither_t *d;
    3333    caca_font_t *f;
    3434    uint8_t *buf;
    35     int i, y = caca_get_canvas_height(screen_list->cv) - 6 - screen_list->status;
     35    int i, y =
     36        caca_get_canvas_height(screen_list->cv) - 6 - screen_list->status;
    3637    int miniw, minih;
    3738
    38     if(screen_list->count)
     39    if (screen_list->count)
    3940    {
    4041        fonts = caca_get_font_list();
     
    4849
    4950#if defined(HAVE_ENDIAN_H)
    50         if(__BYTE_ORDER == __BIG_ENDIAN)
     51        if (__BYTE_ORDER == __BIG_ENDIAN)
    5152#else
    52             /* This is compile-time optimised with at least -O1 or -Os */
    53             uint32_t const tmp = 0x12345678;
    54         if(*(uint8_t const *)&tmp == 0x12)
     53        /* This is compile-time optimised with at least -O1 or -Os */
     54        uint32_t const tmp = 0x12345678;
     55        if (*(uint8_t const *)&tmp == 0x12)
    5556#endif
    5657            d = caca_create_dither(32, miniw, minih, 4 * miniw,
    57                                     0xff0000, 0xff00, 0xff, 0x0);
     58                                   0xff0000, 0xff00, 0xff, 0x0);
    5859        else
    5960            d = caca_create_dither(32, miniw, minih, 4 * miniw,
    60                                     0xff00, 0xff0000, 0xff000000, 0x0);
    61 
    62         for(i = 0; i < screen_list->count; i++)
     61                                   0xff00, 0xff0000, 0xff000000, 0x0);
     62
     63        for (i = 0; i < screen_list->count; i++)
    6364        {
    64             if(!screen_list->screen[i]->changed && !screen_list->changed)
     65            if (!screen_list->screen[i]->changed && !screen_list->changed)
    6566                continue;
    6667            caca_render_canvas(screen_list->screen[i]->cv, f, buf,
    67                                 miniw, minih, miniw * 4);
     68                               miniw, minih, miniw * 4);
    6869            caca_dither_bitmap(screen_list->cv, 20 * i, y, 19, 6, d, buf);
    6970            caca_set_color_ansi(screen_list->cv, CACA_WHITE, CACA_BLUE);
    7071
    71             if(screen_list->pty == i)
    72                 caca_draw_cp437_box(screen_list->cv,20 * i, y, 19, 6);
    73             caca_printf(screen_list->cv, 20 * i, y, "(%i)", i+1);
     72            if (screen_list->pty == i)
     73                caca_draw_cp437_box(screen_list->cv, 20 * i, y, 19, 6);
     74            caca_printf(screen_list->cv, 20 * i, y, "(%i)", i + 1);
    7475        }
    7576
     
    8889
    8990
    90     /*    caca_fill_box(screen_list->cv,
    91                    x, y,
    92                    caca_get_canvas_width(screen_list->cv), 1, '#');*/
    93 
    94 /* Hour */
    95     {
    96         time_t now = time ((time_t *) 0);
     91    /* caca_fill_box(screen_list->cv, x, y,
     92       caca_get_canvas_width(screen_list->cv), 1, '#'); */
     93
     94    /* Hour */
     95    {
     96        time_t now = time((time_t *) 0);
    9797        struct tm *t = localtime(&now);
    9898        char hour[256];
     
    100100
    101101        caca_set_color_ansi(screen_list->cv, CACA_LIGHTBLUE, CACA_BLUE);
    102         caca_printf(screen_list->cv, x, y,
    103                      "[");
     102        caca_printf(screen_list->cv, x, y, "[");
    104103
    105104        caca_set_color_ansi(screen_list->cv, CACA_DEFAULT, CACA_BLUE);
    106         caca_printf(screen_list->cv, x+1, y,
    107                      hour);
     105        caca_printf(screen_list->cv, x + 1, y, hour);
    108106        caca_set_color_ansi(screen_list->cv, CACA_LIGHTBLUE, CACA_BLUE);
    109         caca_printf(screen_list->cv, x + strlen(hour) + 1, y,
    110                      "]");
     107        caca_printf(screen_list->cv, x + strlen(hour) + 1, y, "]");
    111108        x += 7;
    112109
    113110    }
    114111
    115 /* Window */
     112    /* Window */
    116113    {
    117114        char text[256];
    118         sprintf(text, "%d/%d", screen_list->pty+1, screen_list->count);
     115        sprintf(text, "%d/%d", screen_list->pty + 1, screen_list->count);
    119116        caca_set_color_ansi(screen_list->cv, CACA_BLUE, CACA_BLUE);
    120117        caca_put_char(screen_list->cv, x, y, '#');
     
    123120        caca_printf(screen_list->cv, x, y, "Window:");
    124121        caca_set_color_ansi(screen_list->cv, CACA_BLUE, CACA_BLUE);
    125         caca_put_char(screen_list->cv, x+7, y, '#');
     122        caca_put_char(screen_list->cv, x + 7, y, '#');
    126123        caca_set_color_ansi(screen_list->cv, CACA_DEFAULT, CACA_BLUE);
    127         caca_printf(screen_list->cv, x+8, y, text);
    128         x+= 8+strlen(text);
    129     }
    130 
    131 /* Window Manager */
     124        caca_printf(screen_list->cv, x + 8, y, text);
     125        x += 8 + strlen(text);
     126    }
     127
     128    /* Window Manager */
    132129    {
    133130        char text[256];
    134131
    135         switch(screen_list->wm_type)
     132        switch (screen_list->wm_type)
    136133        {
    137134        case WM_CARD:
     
    160157        caca_printf(screen_list->cv, x, y, "WM:");
    161158        caca_set_color_ansi(screen_list->cv, CACA_BLUE, CACA_BLUE);
    162         caca_put_char(screen_list->cv, x+3, y, '#');
     159        caca_put_char(screen_list->cv, x + 3, y, '#');
    163160        caca_set_color_ansi(screen_list->cv, CACA_DEFAULT, CACA_BLUE);
    164         caca_printf(screen_list->cv, x+4, y, text);
    165         x+= 4+strlen(text);
    166     }
    167 
    168 /* Help (must be the last one )*/
     161        caca_printf(screen_list->cv, x + 4, y, text);
     162        x += 4 + strlen(text);
     163    }
     164
     165    /* Help (must be the last one ) */
    169166    {
    170167        char text[256];
    171168        sprintf(text, "Help: ctrl-a-h");
    172169        caca_set_color_ansi(screen_list->cv, CACA_BLUE, CACA_BLUE);
    173         while(x < (int)(caca_get_canvas_width(screen_list->cv) - strlen(text)))
     170        while (x <
     171               (int)(caca_get_canvas_width(screen_list->cv) - strlen(text)))
    174172        {
    175173            caca_put_char(screen_list->cv, x, y, '#');
     
    192190
    193191    caca_set_color_ansi(screen_list->cv, CACA_BLUE, CACA_BLUE);
    194     caca_fill_box(screen_list->cv,
    195                    x, y,
    196                    w, h, '#');
     192    caca_fill_box(screen_list->cv, x, y, w, h, '#');
    197193    caca_set_color_ansi(screen_list->cv, CACA_DEFAULT, CACA_BLUE);
    198     caca_draw_cp437_box(screen_list->cv,
    199                          x, y,
    200                          w, h);
    201 
    202     x+=2;
     194    caca_draw_cp437_box(screen_list->cv, x, y, w, h);
     195
     196    x += 2;
    203197    y++;
    204198    caca_printf(screen_list->cv,
    205                  (caca_get_canvas_width(screen_list->cv) - strlen(PACKAGE_STRING)) / 2,
    206                  y-1,
    207                  PACKAGE_STRING);
     199                (caca_get_canvas_width(screen_list->cv) -
     200                 strlen(PACKAGE_STRING)) / 2, y - 1, PACKAGE_STRING);
    208201    caca_printf(screen_list->cv, x, y++, "Copyright (c) 2006-2009");
    209     caca_printf(screen_list->cv, x, y++, "              Sam Hocevar <sam@zoy.org>");
    210     caca_printf(screen_list->cv, x, y++, "              Jean-Yves Lamoureux <jylam@lnxscene.org>");
    211     caca_printf(screen_list->cv, x, y++, "              Pascal Terjan <pterjan@linuxfr.org>");
     202    caca_printf(screen_list->cv, x, y++,
     203                "              Sam Hocevar <sam@zoy.org>");
     204    caca_printf(screen_list->cv, x, y++,
     205                "              Jean-Yves Lamoureux <jylam@lnxscene.org>");
     206    caca_printf(screen_list->cv, x, y++,
     207                "              Pascal Terjan <pterjan@linuxfr.org>");
    212208    caca_printf(screen_list->cv, x, y++, "");
    213209    caca_printf(screen_list->cv, x, y++, "");
    214     caca_printf(screen_list->cv, x, y++, "All shortcuts are in format 'ctrl-a-X' where X is :");
     210    caca_printf(screen_list->cv, x, y++,
     211                "All shortcuts are in format 'ctrl-a-X' where X is :");
    215212    caca_printf(screen_list->cv, x, y++, "n:\t Next window");
    216213    caca_printf(screen_list->cv, x, y++, "p:\t Previous window");
     
    219216    caca_printf(screen_list->cv, x, y++, "m:\t Thumbnails");
    220217    caca_printf(screen_list->cv, x, y++, "d:\t Detach");
    221     caca_printf(screen_list->cv, x, y++, "k:\t Close window and kill associated process");
     218    caca_printf(screen_list->cv, x, y++,
     219                "k:\t Close window and kill associated process");
    222220    caca_printf(screen_list->cv, x, y++, "h:\t This help");
    223221    caca_printf(screen_list->cv, x, y++, "");
    224222    caca_printf(screen_list->cv, x, y++, "");
    225     caca_printf(screen_list->cv, x, y++, "See http://caca.zoy.org/wiki/neercs for more informations");
     223    caca_printf(screen_list->cv, x, y++,
     224                "See http://caca.zoy.org/wiki/neercs for more informations");
    226225}
    227226
     
    230229    debug("Got %x\n", c);
    231230
    232     switch(c)
     231    switch (c)
    233232    {
    234233    case 0x111:
    235         if(screen_list->cur_in_list>0)
     234        if (screen_list->cur_in_list > 0)
    236235            screen_list->cur_in_list--;
    237236        break;
    238237    case 0x112:
    239         if(screen_list->cur_in_list<screen_list->count-1)
     238        if (screen_list->cur_in_list < screen_list->count - 1)
    240239            screen_list->cur_in_list++;
    241240        break;
     
    243242        screen_list->window_list = 0;
    244243        screen_list->prevpty = screen_list->pty;
    245         screen_list->pty     = screen_list->cur_in_list;
     244        screen_list->pty = screen_list->cur_in_list;
    246245        break;
    247246    case 0x22:
     
    263262    debug("Drawing list\n");
    264263    caca_set_color_ansi(screen_list->cv, CACA_BLACK, CACA_BLACK);
    265     caca_fill_box(screen_list->cv,
    266                    0, 0,
    267                    w, h, '#');
     264    caca_fill_box(screen_list->cv, 0, 0, w, h, '#');
    268265    caca_set_color_ansi(screen_list->cv, CACA_DEFAULT, CACA_DEFAULT);
    269     caca_draw_cp437_box(screen_list->cv,
    270                          0, 0,
    271                          w, h);
     266    caca_draw_cp437_box(screen_list->cv, 0, 0, w, h);
    272267
    273268    caca_printf(screen_list->cv, 2, 1, "Num \tName");
    274     for(i = 0; i < screen_list->count; i++)
     269    for (i = 0; i < screen_list->count; i++)
    275270    {
    276271        char line[1024];
    277         if(screen_list->cur_in_list == i)
     272        if (screen_list->cur_in_list == i)
    278273            caca_set_color_ansi(screen_list->cv, CACA_BLACK, CACA_WHITE);
    279274        else
    280275            caca_set_color_ansi(screen_list->cv, CACA_DEFAULT, CACA_DEFAULT);
    281         sprintf(line, "%d \t%s", i+1, screen_list->screen[i]->title);
    282 
    283         caca_printf(screen_list->cv, 2, i+3, line);
     276        sprintf(line, "%d \t%s", i + 1, screen_list->screen[i]->title);
     277
     278        caca_printf(screen_list->cv, 2, i + 3, line);
    284279    }
    285280}
     
    288283/* Total close time */
    289284#define DELAY 500000.0f
    290 int close_screen_recurrent(struct screen_list* screen_list, struct recurrent* rec, void *user, long long unsigned int t)
     285int close_screen_recurrent(struct screen_list *screen_list,
     286                           struct recurrent *rec, void *user,
     287                           long long unsigned int t)
    291288{
    292289    long long unsigned int delta = t - rec->start_time;
     
    295292    screen_list->delay = 0;
    296293    rec->kill_me = 0;
    297     if(delta>=DELAY)
     294    if (delta >= DELAY)
    298295    {
    299296        rec->kill_me = 1;
     
    311308        int h = s->orig_h * r;
    312309
    313         /* libcaca canvas resize function is bugged, do it by hand  */
     310        /* libcaca canvas resize function is bugged, do it by hand */
    314311        old = s->cv;
    315312        new = caca_create_canvas(w, h);
     
    322319        s->h = h;
    323320
    324         s->x =
    325             (s->orig_x * r) +
    326             ((s->orig_w/2) - s->w/2);
    327         s->y =
    328             (s->orig_y * r) +
    329             ((s->orig_h/2) - s->h/2);
     321        s->x = (s->orig_x * r) + ((s->orig_w / 2) - s->w / 2);
     322        s->y = (s->orig_y * r) + ((s->orig_h / 2) - s->h / 2);
    330323    }
    331324    screen_list->changed = 1;
  • neercs/trunk/src/lock.c

    r3551 r3969  
    1 /*
     1/* 
    22 *  neercs        console-based window manager
    33 *  Copyright (c) 2006 Sam Hocevar <sam@zoy.org>
     
    4848
    4949#if defined USE_LOCK
    50     if(!screen_list->locked) return 0;
    51 
    52     if(c==0x08)      // BACKSPACE
    53     {
    54         if(screen_list->lock_offset)
    55         {
    56             screen_list->lockpass[screen_list->lock_offset-1] = 0;
     50    if (!screen_list->locked)
     51        return 0;
     52
     53    if (c == 0x08)              // BACKSPACE
     54    {
     55        if (screen_list->lock_offset)
     56        {
     57            screen_list->lockpass[screen_list->lock_offset - 1] = 0;
    5758            screen_list->lock_offset--;
    5859        }
    5960    }
    60     else if(c==0x0d) // RETURN
     61    else if (c == 0x0d)        // RETURN
    6162    {
    6263        memset(screen_list->lockmsg, 0, 1024);
    63         if(validate_lock(screen_list, getenv("USER"), screen_list->lockpass))
     64        if (validate_lock(screen_list, getenv("USER"), screen_list->lockpass))
    6465        {
    6566            memset(screen_list->lockpass, 0, 1024);
     
    7778    else
    7879    {
    79         if(screen_list->lock_offset < 1023)
     80        if (screen_list->lock_offset < 1023)
    8081        {
    8182            screen_list->lockpass[screen_list->lock_offset++] = c;
    82             screen_list->lockpass[screen_list->lock_offset]   = 0;
     83            screen_list->lockpass[screen_list->lock_offset] = 0;
    8384        }
    8485    }
     
    9596    caca_canvas_t *cv = screen_list->cv;
    9697
    97     gethostname(buffer, sizeof(buffer)-1);
     98    gethostname(buffer, sizeof(buffer) - 1);
    9899
    99100    int w = 65, h = 20;
     
    103104
    104105    caca_set_color_ansi(cv, CACA_BLUE, CACA_BLUE);
    105     caca_fill_box(cv,
    106                    x, y,
    107                    w, h, '#');
     106    caca_fill_box(cv, x, y, w, h, '#');
    108107    caca_set_color_ansi(cv, CACA_DEFAULT, CACA_BLUE);
    109     caca_draw_cp437_box(cv,
    110                          x, y,
    111                          w, h);
    112 
    113     x+=2;
     108    caca_draw_cp437_box(cv, x, y, w, h);
     109
     110    x += 2;
    114111    y++;
    115112    caca_printf(cv,
    116                  (caca_get_canvas_width(cv) - strlen(PACKAGE_STRING " locked")) / 2,
    117                  y-1,
    118                  PACKAGE_STRING " locked");
    119 
    120     caca_printf(cv, x, y++, "Please type in your password for %s@%s :", getenv("USER"), buffer);
    121     y+=2;
    122 
    123     x = (caca_get_canvas_width(cv)/2) - ((strlen(screen_list->lockpass) / 2) + strlen("Password : "));
     113                (caca_get_canvas_width(cv) -
     114                 strlen(PACKAGE_STRING " locked")) / 2, y - 1,
     115                PACKAGE_STRING " locked");
     116
     117    caca_printf(cv, x, y++, "Please type in your password for %s@%s :",
     118                getenv("USER"), buffer);
     119    y += 2;
     120
     121    x = (caca_get_canvas_width(cv) / 2) -
     122        ((strlen(screen_list->lockpass) / 2) + strlen("Password : "));
    124123    caca_printf(cv, x, y, "Password : ");
    125     x+=strlen("Password : ");
    126     for(i=0; i<strlen(screen_list->lockpass); i++)
     124    x += strlen("Password : ");
     125    for (i = 0; i < strlen(screen_list->lockpass); i++)
    127126    {
    128127        caca_put_str(cv, x, y, "*");
     
    131130
    132131
    133     if(strlen(screen_list->lockmsg))
    134     {
    135         x = ((caca_get_canvas_width(cv) - w) / 2) + (strlen(screen_list->lockmsg));
    136         y+=2;
     132    if (strlen(screen_list->lockmsg))
     133    {
     134        x = ((caca_get_canvas_width(cv) - w) / 2) +
     135            (strlen(screen_list->lockmsg));
     136        y += 2;
    137137        caca_set_color_ansi(cv, CACA_RED, CACA_BLUE);
    138138        caca_printf(cv, x, y, "Error : %s", screen_list->lockmsg);
     
    155155    for (i = 0; i < num_msg; ++i)
    156156    {
    157         switch(msg[i]->msg_style)
     157        switch (msg[i]->msg_style)
    158158        {
    159159        case PAM_PROMPT_ECHO_ON:
     
    164164        case PAM_ERROR_MSG:
    165165            break;
    166         default :
     166        default:
    167167            printf("Unknow message type from PAM\n");
    168168            break;
     
    179179#if USE_LOCK
    180180    int ret;
    181     pam_handle_t *pamh=NULL;
     181    pam_handle_t *pamh = NULL;
    182182    char buffer[100];
    183     const char *service="neercs";
     183    const char *service = "neercs";
    184184    struct pam_conv conv = {
    185185        convpam,
     
    188188
    189189    ret = pam_start(service, user, &conv, &pamh);
    190     if(ret!=PAM_SUCCESS)
     190    if (ret != PAM_SUCCESS)
    191191        return 0;
    192192    pam_set_item(pamh, PAM_RUSER, user);
    193193
    194     ret = gethostname(buffer, sizeof(buffer)-1);
     194    ret = gethostname(buffer, sizeof(buffer) - 1);
    195195    if (ret)
    196196    {
     
    203203
    204204    ret = pam_set_item(pamh, PAM_RHOST, buffer);
    205     if(ret!=PAM_SUCCESS)
     205    if (ret != PAM_SUCCESS)
    206206    {
    207207        sprintf(screen_list->lockmsg, "Can't set hostname");
     
    211211
    212212    ret = pam_authenticate(pamh, 0);
    213     if(ret!=PAM_SUCCESS)
     213    if (ret != PAM_SUCCESS)
    214214    {
    215215        sprintf(screen_list->lockmsg, "Can't authenticate");
     
    223223    return 1;
    224224}
    225 
  • neercs/trunk/src/main.c

    r3961 r3969  
    1 /*
     1/* 
    22 *  neercs        console-based window manager
    33 *  Copyright (c) 2006 Sam Hocevar <sam@zoy.org>
     
    5353    printf("%s\n", PACKAGE_STRING);
    5454    printf("Copyright (C) 2006, 2008 Sam Hocevar <sam@zoy.org>\n");
    55     printf("                         Jean-Yves Lamoureux <jylam@lnxscene.org>\n\n");
    56     printf("This is free software.  You may redistribute copies of it under the\n");
    57     printf("terms of the Do What The Fuck You Want To Public License, Version 2\n");
     55    printf
     56        ("                         Jean-Yves Lamoureux <jylam@lnxscene.org>\n\n");
     57    printf
     58        ("This is free software.  You may redistribute copies of it under the\n");
     59    printf
     60        ("terms of the Do What The Fuck You Want To Public License, Version 2\n");
    5861    printf("<http://sam.zoy.org/wtfpl/>.\n");
    5962    printf("There is NO WARRANTY, to the extent permitted by law.\n");
    6063    printf("\n");
    61     printf("For more informations, visit http://libcaca.zoy.org/wiki/neercs\n");
     64    printf
     65        ("For more informations, visit http://libcaca.zoy.org/wiki/neercs\n");
    6266}
    6367
     
    7175    printf("\t--pid\t\t-P [pid]\t\tgrab process\n");
    7276    printf("\t\t\t-r [session]\t\treattach to a detached neercs\n");
    73     printf("\t\t\t-R [session]\t\treattach if possible, otherwise start a new session\n");
     77    printf
     78        ("\t\t\t-R [session]\t\treattach if possible, otherwise start a new session\n");
    7479    printf("\t\t\t-S <name>\t\tname this session <name> instead of <pid>\n");
    7580    printf("\t--lock-after\t-l [n]\t\t\tlock screen after n seconds\n");
     
    8893    screen_list->default_shell = getenv("SHELL");
    8994
    90     args = argc -1;
    91     if(screen_list->default_shell == NULL  && args <= 0)
    92     {
    93         fprintf(stderr, "Environment variable SHELL not set and no arguments given. kthxbye.\n");
     95    args = argc - 1;
     96    if (screen_list->default_shell == NULL && args <= 0)
     97    {
     98        fprintf(stderr,
     99                "Environment variable SHELL not set and no arguments given. kthxbye.\n");
    94100        goto end;
    95101    }
    96102
    97     if(handle_command_line(argc, argv, screen_list) < 0)
     103    if (handle_command_line(argc, argv, screen_list) < 0)
    98104        goto end;
    99105
     
    101107    read_configuration_file("/etc/neercsrc", screen_list);
    102108
    103     /* Then local one  */
    104     if(screen_list->user_path)
     109    /* Then local one */
     110    if (screen_list->user_path)
    105111    {
    106112        read_configuration_file(screen_list->user_path, screen_list);
     
    108114    }
    109115
    110     if(screen_list->attach)
    111     {
    112         if(screen_list->nb_to_grab || screen_list->to_start)
    113         {
    114             fprintf(stderr, "-R can not be associated with commands or pids!\n");
     116    if (screen_list->attach)
     117    {
     118        if (screen_list->nb_to_grab || screen_list->to_start)
     119        {
     120            fprintf(stderr,
     121                    "-R can not be associated with commands or pids!\n");
    115122            goto end;
    116123        }
     
    118125        attach(screen_list);
    119126
    120         if(screen_list->forceattach && !screen_list->attach)
     127        if (screen_list->forceattach && !screen_list->attach)
    121128            goto end;
    122129    }
    123130
    124131    /* Build default session name */
    125     if(!screen_list->session_name)
    126     {
    127         char mypid[32]; /* FIXME Compute the length of PID_MAX ? */
     132    if (!screen_list->session_name)
     133    {
     134        char mypid[32];         /* FIXME Compute the length of PID_MAX ? */
    128135        snprintf(mypid, 31, "%d", getpid());
    129         mypid[31]= '\0';
     136        mypid[31] = '\0';
    130137        screen_list->session_name = strdup(mypid);
    131         if(!screen_list->session_name)
    132         {
    133             fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__, __LINE__);
     138        if (!screen_list->session_name)
     139        {
     140            fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__,
     141                    __LINE__);
    134142            goto end;
    135143        }
    136144    }
    137     if(!screen_list->socket_path[SOCK_CLIENT])
     145    if (!screen_list->socket_path[SOCK_CLIENT])
    138146        screen_list->socket_path[SOCK_CLIENT] =
    139             build_socket_path(screen_list->socket_dir, screen_list->session_name, SOCK_CLIENT);
    140 
    141     if(!screen_list->socket_path[SOCK_SERVER])
     147            build_socket_path(screen_list->socket_dir,
     148                              screen_list->session_name, SOCK_CLIENT);
     149
     150    if (!screen_list->socket_path[SOCK_SERVER])
    142151        screen_list->socket_path[SOCK_SERVER] =
    143             build_socket_path(screen_list->socket_dir, screen_list->session_name, SOCK_SERVER);
     152            build_socket_path(screen_list->socket_dir,
     153                              screen_list->session_name, SOCK_SERVER);
    144154
    145155    /* Fork the server if needed */
    146     if(!screen_list->attach)
     156    if (!screen_list->attach)
    147157    {
    148158        debug("Spawning a new server");
    149         if(start_server(screen_list))
     159        if (start_server(screen_list))
    150160            goto end;
    151161    }
     
    156166    /* Clean up */
    157167    mainret = 0;
    158 end:
    159 
    160     if(screen_list)
     168  end:
     169
     170    if (screen_list)
    161171    {
    162172        free_screen_list(screen_list);
     
    171181    struct option *option;
    172182
    173     if(screen_list->dp)
     183    if (screen_list->dp)
    174184        caca_free_display(screen_list->dp);
    175185
    176     if(screen_list->cv)
     186    if (screen_list->cv)
    177187        caca_free_canvas(screen_list->cv);
    178188
    179     for(i = 0; i < screen_list->count; i++)
     189    for (i = 0; i < screen_list->count; i++)
    180190    {
    181191        destroy_screen(screen_list->screen[i]);
    182192    }
    183193
    184     if(screen_list->socket_path[SOCK_SERVER])
     194    if (screen_list->socket_path[SOCK_SERVER])
    185195        free(screen_list->socket_path[SOCK_SERVER]);
    186196
    187     if(screen_list->socket_path[SOCK_CLIENT])
     197    if (screen_list->socket_path[SOCK_CLIENT])
    188198    {
    189199        unlink(screen_list->socket_path[SOCK_CLIENT]);
     
    191201    }
    192202
    193     if(screen_list->socket[SOCK_CLIENT])
     203    if (screen_list->socket[SOCK_CLIENT])
    194204        close(screen_list->socket[SOCK_CLIENT]);
    195205
    196     if(screen_list->socket[SOCK_SERVER])
     206    if (screen_list->socket[SOCK_SERVER])
    197207        close(screen_list->socket[SOCK_SERVER]);
    198208
    199     if(screen_list->screen)
     209    if (screen_list->screen)
    200210        free(screen_list->screen);
    201211
    202212    option = screen_list->config;
    203213
    204     while(option)
     214    while (option)
    205215    {
    206216        struct option *kromeugnon = option;
    207217        option = option->next;
    208         if(kromeugnon->key)   free(kromeugnon->key);
    209         if(kromeugnon->value) free(kromeugnon->value);
     218        if (kromeugnon->key)
     219            free(kromeugnon->key);
     220        if (kromeugnon->value)
     221            free(kromeugnon->value);
    210222        free(kromeugnon);
    211223    }
    212224
    213     for(i=0; i<screen_list->recurrent_list->count; i++)
     225    for (i = 0; i < screen_list->recurrent_list->count; i++)
    214226    {
    215227        remove_recurrent(screen_list->recurrent_list, i);
     
    217229    }
    218230
    219     if(screen_list->recurrent_list->recurrent)
     231    if (screen_list->recurrent_list->recurrent)
    220232        free(screen_list->recurrent_list->recurrent);
    221     if(screen_list->recurrent_list)
     233    if (screen_list->recurrent_list)
    222234        free(screen_list->recurrent_list);
    223235
    224     if(screen_list->session_name)
     236    if (screen_list->session_name)
    225237        free(screen_list->session_name);
    226238
    227     if(screen_list->title)
     239    if (screen_list->title)
    228240        free(screen_list->title);
    229241
     
    239251
    240252    /* Create screen list */
    241     screen_list = (struct screen_list*)     malloc(sizeof(struct screen_list));
    242     if(!screen_list)
    243     {
    244         fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__, __LINE__);
     253    screen_list = (struct screen_list *)malloc(sizeof(struct screen_list));
     254    if (!screen_list)
     255    {
     256        fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__,
     257                __LINE__);
    245258        return NULL;
    246259    }
    247     screen_list->screen = (struct screen**) malloc(sizeof(sizeof(struct screen*)));
    248     if(!screen_list->screen)
    249     {
    250         fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__, __LINE__);
     260    screen_list->screen =
     261        (struct screen **)malloc(sizeof(sizeof(struct screen *)));
     262    if (!screen_list->screen)
     263    {
     264        fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__,
     265                __LINE__);
    251266        free(screen_list);
    252267        return NULL;
     
    263278    screen_list->changed = 0;
    264279    screen_list->requested_delay = 0;
    265     screen_list->delay = 1000/60; /* Don't refresh more than 60 times per second */
     280    screen_list->delay = 1000 / 60;     /* Don't refresh more than 60 times
     281                                           per second */
    266282    screen_list->pty = screen_list->prevpty = 0;
    267283    screen_list->dont_update_coords = 0;
     
    275291    screen_list->socket[SOCK_SERVER] = 0;
    276292    screen_list->socket[SOCK_CLIENT] = 0;
    277     screen_list->socket_dir    = NULL;
     293    screen_list->socket_dir = NULL;
    278294    screen_list->socket_path[SOCK_SERVER] = NULL;
    279295    screen_list->socket_path[SOCK_CLIENT] = NULL;
    280     screen_list->session_name  = NULL;
     296    screen_list->session_name = NULL;
    281297    screen_list->default_shell = NULL;
    282     screen_list->user_path     = NULL;
     298    screen_list->user_path = NULL;
    283299    screen_list->autolock_timeout = -1;
    284300    screen_list->to_grab = NULL;
     
    304320    /* Build local config file path */
    305321    user_dir = getenv("HOME");
    306     if(!user_dir)
     322    if (!user_dir)
    307323    {
    308324        user_info = getpwuid(getuid());
    309         if(user_info)
     325        if (user_info)
    310326        {
    311327            user_dir = user_info->pw_dir;
    312328        }
    313329    }
    314     if(user_dir)
    315     {
    316         screen_list->user_path = malloc(strlen(user_dir) + strlen("/.neercsrc") + 1);
     330    if (user_dir)
     331    {
     332        screen_list->user_path =
     333            malloc(strlen(user_dir) + strlen("/.neercsrc") + 1);
    317334        sprintf(screen_list->user_path, "%s/%s", user_dir, ".neercsrc");
    318335    }
    319336
    320337
    321     screen_list->recurrent_list = (struct recurrent_list*) malloc(sizeof(struct recurrent_list));
    322     screen_list->recurrent_list->recurrent = (struct recurrent**) malloc(sizeof(struct recurrent*));
    323     if(!screen_list->recurrent_list->recurrent)
    324     {
    325         fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__, __LINE__);
     338    screen_list->recurrent_list =
     339        (struct recurrent_list *)malloc(sizeof(struct recurrent_list));
     340    screen_list->recurrent_list->recurrent =
     341        (struct recurrent **)malloc(sizeof(struct recurrent *));
     342    if (!screen_list->recurrent_list->recurrent)
     343    {
     344        fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__,
     345                __LINE__);
    326346        free(screen_list);
    327347        free(screen_list->screen);
     
    337357
    338358
    339 int handle_command_line(int argc, char *argv[], struct screen_list *screen_list)
     359int handle_command_line(int argc, char *argv[],
     360                        struct screen_list *screen_list)
    340361{
    341362    int s = 0, i;
    342     for(;;)
     363    for (;;)
    343364    {
    344365        int option_index = 0;
    345366        int pidopt;
    346         static struct myoption long_options[] =
    347             {
    348                 { "config",      1, NULL, 'c' },
     367        static struct myoption long_options[] = {
     368            {"config", 1, NULL, 'c'},
    349369#if defined USE_GRAB
    350                 { "pid",         0, NULL, 'P' },
     370            {"pid", 0, NULL, 'P'},
    351371#endif
    352                 { "lock-after",  1, NULL, 'l' },
    353                 { "help",        0, NULL, 'h' },
    354                 { "version",     0, NULL, 'v' },
    355                 { NULL, 0, NULL, 0 },
    356             };
     372            {"lock-after", 1, NULL, 'l'},
     373            {"help", 0, NULL, 'h'},
     374            {"version", 0, NULL, 'v'},
     375            {NULL, 0, NULL, 0},
     376        };
    357377#if defined USE_GRAB
    358         int c = mygetopt(argc, argv, "c:S:R::l::r::P::hv", long_options, &option_index);
     378        int c =
     379            mygetopt(argc, argv, "c:S:R::l::r::P::hv", long_options,
     380                     &option_index);
    359381#else
    360         int c = mygetopt(argc, argv, "c:S:R::l::r::hv", long_options, &option_index);
     382        int c =
     383            mygetopt(argc, argv, "c:S:R::l::r::hv", long_options,
     384                     &option_index);
    361385#endif
    362         if(c == -1)
    363             break;
    364 
    365         switch(c)
    366         {
    367         case 'c': /* --config */
    368             if(screen_list->user_path)
     386        if (c == -1)
     387            break;
     388
     389        switch (c)
     390        {
     391        case 'c':              /* --config */
     392            if (screen_list->user_path)
    369393                free(screen_list->user_path);
    370394            screen_list->user_path = strdup(myoptarg);
    371             s+=2;
     395            s += 2;
    372396            break;
    373397        case 'S':
    374             if(!screen_list->session_name)
     398            if (!screen_list->session_name)
    375399                screen_list->session_name = strdup(myoptarg);
    376             s+=2;
    377             break;
    378         case 'P': /* --pid */
    379             if(myoptarg)
     400            s += 2;
     401            break;
     402        case 'P':              /* --pid */
     403            if (myoptarg)
    380404            {
    381405                pidopt = atoi(myoptarg);
    382                 if(pidopt <= 0)
     406                if (pidopt <= 0)
    383407                {
    384408                    fprintf(stderr, "Invalid pid %d\n", pidopt);
    385                     if(screen_list->to_grab)
     409                    if (screen_list->to_grab)
    386410                        free(screen_list->to_grab);
    387411                    return -1;
     
    390414            else
    391415                pidopt = select_process(screen_list);
    392             if(pidopt <= 0)
     416            if (pidopt <= 0)
    393417            {
    394                 s+=1;
     418                s += 1;
    395419                break;
    396420            }
    397             if(!screen_list->to_grab)
     421            if (!screen_list->to_grab)
    398422            {
    399423                /* At most argc-1-s times -P <pid> + final 0 */
    400                 screen_list->to_grab = (int *)malloc(((argc-1-s)/2+1)*sizeof(int));
    401                 if(!screen_list->to_grab)
     424                screen_list->to_grab =
     425                    (int *)malloc(((argc - 1 - s) / 2 + 1) * sizeof(int));
     426                if (!screen_list->to_grab)
    402427                {
    403                     fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__, __LINE__);
     428                    fprintf(stderr, "Can't allocate memory at %s:%d\n",
     429                            __FUNCTION__, __LINE__);
    404430                    return -1;
    405431                }
     
    407433            screen_list->to_grab[screen_list->nb_to_grab++] = pidopt;
    408434            screen_list->to_grab[screen_list->nb_to_grab] = 0;
    409             s+=2;
     435            s += 2;
    410436            break;
    411437        case 'l':
    412438            screen_list->autolock_timeout = atoi(myoptarg) * 1000000;
    413                 if(screen_list->autolock_timeout == 0)
    414                 screen_list->autolock_timeout-=1;
     439            if (screen_list->autolock_timeout == 0)
     440                screen_list->autolock_timeout -= 1;
    415441            break;
    416442        case 'r':
    417443            screen_list->forceattach = 1;
    418444        case 'R':
    419             if(screen_list->attach)
     445            if (screen_list->attach)
    420446            {
    421447                fprintf(stderr, "Attaching can only be requested once\n");
    422448                return -1;
    423449            }
    424             if(myoptarg)
     450            if (myoptarg)
    425451            {
    426                 if(screen_list->session_name)
     452                if (screen_list->session_name)
    427453                    free(screen_list->session_name);
    428454                screen_list->session_name = strdup(myoptarg);
    429                 s+=1;
     455                s += 1;
    430456            }
    431457            screen_list->attach = 1;
    432             s+=1;
    433             break;
    434         case 'h': /* --help */
     458            s += 1;
     459            break;
     460        case 'h':              /* --help */
    435461            usage(argc, argv);
    436462            return -1;
    437463            break;
    438         case 'v': /* --version */
     464        case 'v':              /* --version */
    439465            version();
    440466            return -1;
     
    448474        }
    449475    }
    450     if(s >= 0 && s < argc - 1)
    451     {
    452         screen_list->to_start = (char**)malloc((argc-s)*sizeof(char*));
    453         if(!screen_list->to_start)
    454         {
    455             fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__, __LINE__);
     476    if (s >= 0 && s < argc - 1)
     477    {
     478        screen_list->to_start = (char **)malloc((argc - s) * sizeof(char *));
     479        if (!screen_list->to_start)
     480        {
     481            fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__,
     482                    __LINE__);
    456483            return -1;
    457484        }
    458         for(i=0; i<(argc-1) - s; i++)
    459         {
    460             screen_list->to_start[i] = strdup(argv[i+s+1]);
    461         }
    462         screen_list->to_start[argc-1-s] = NULL;
     485        for (i = 0; i < (argc - 1) - s; i++)
     486        {
     487            screen_list->to_start[i] = strdup(argv[i + s + 1]);
     488        }
     489        screen_list->to_start[argc - 1 - s] = NULL;
    463490    }
    464491    return s;
  • neercs/trunk/src/mygetopt.c

    r3551 r3969  
    1 /*
     1/* 
    22 *  neercs        console-based window manager
    33 *  Copyright (c) 2006 Sam Hocevar <sam@zoy.org>
     
    1515 */
    1616
    17 /*
     17/* 
    1818 *  mygetopt.c: getopt_long reimplementation
    1919 */
     
    2828#include "mygetopt.h"
    2929
    30 int   myoptind = 1;
     30int myoptind = 1;
    3131char *myoptarg = NULL;
    3232
    3333/* XXX: this getopt_long implementation should not be trusted for other
    34  * applications without any serious peer reviewing. It “just works” with
    35  * zzuf but may fail miserably in other programs. */
    36 int mygetopt(int argc, char * const _argv[], const char *optstring,
     34   applications without any serious peer reviewing. It “just works” with
     35   zzuf but may fail miserably in other programs. */
     36int mygetopt(int argc, char *const _argv[], const char *optstring,
    3737             const struct myoption *longopts, int *longindex)
    3838{
    39     char **argv = (char **)(uintptr_t)_argv;
     39    char **argv = (char **)(uintptr_t) _argv;
    4040    char *flag;
    4141    int i;
    4242
    43     if(myoptind >= argc)
     43    if (myoptind >= argc)
    4444        return -1;
    4545
    4646    flag = argv[myoptind];
    4747
    48     if(flag[0] == '-' && flag[1] != '-')
     48    if (flag[0] == '-' && flag[1] != '-')
    4949    {
    5050        char *tmp;
    5151        int ret = flag[1];
    5252
    53         if(ret == '\0')
     53        if (ret == '\0')
    5454            return -1;
    5555
    5656        tmp = strchr(optstring, ret);
    57         if(!tmp || ret == ':')
     57        if (!tmp || ret == ':')
    5858            return '?';
    5959
    6060        myoptind++;
    61         if(tmp[1] == ':')
     61        if (tmp[1] == ':')
    6262        {
    63             if(flag[2] != '\0')
     63            if (flag[2] != '\0')
    6464                myoptarg = flag + 2;
     65            else if (myoptind >= argc)
     66            {
     67                if (tmp[2] != ':')
     68                {
     69                    fprintf(stderr, "%s: `%s' needs an argument\n", argv[0],
     70                            flag);
     71                    return -2;
     72                }
     73            }
    6574            else
    66                 if(myoptind >= argc)
    67                 {
    68                     if(tmp[2] != ':')
    69                     {
    70                         fprintf(stderr, "%s: `%s' needs an argument\n", argv[0], flag);
    71                         return -2;
    72                     }
    73                 }
    74                 else
    75                     myoptarg = argv[myoptind++];
     75                myoptarg = argv[myoptind++];
    7676            return ret;
    7777        }
    7878
    79         if(flag[2] != '\0')
     79        if (flag[2] != '\0')
    8080        {
    8181            flag[1] = '-';
     
    8787    }
    8888
    89     if(flag[0] == '-' && flag[1] == '-')
     89    if (flag[0] == '-' && flag[1] == '-')
    9090    {
    91         if(flag[2] == '\0')
     91        if (flag[2] == '\0')
    9292            return -1;
    9393
    94         for(i = 0; longopts[i].name; i++)
     94        for (i = 0; longopts[i].name; i++)
    9595        {
    9696            size_t l = strlen(longopts[i].name);
    9797
    98             if(strncmp(flag + 2, longopts[i].name, l))
     98            if (strncmp(flag + 2, longopts[i].name, l))
    9999                continue;
    100100
    101             switch(flag[2 + l])
     101            switch (flag[2 + l])
    102102            {
    103103            case '=':
    104                 if(!longopts[i].has_arg)
     104                if (!longopts[i].has_arg)
    105105                    goto bad_opt;
    106                 if(longindex)
     106                if (longindex)
    107107                    *longindex = i;
    108108                myoptind++;
     
    110110                return longopts[i].val;
    111111            case '\0':
    112                 if(longindex)
     112                if (longindex)
    113113                    *longindex = i;
    114114                myoptind++;
    115                 if(longopts[i].has_arg)
     115                if (longopts[i].has_arg)
    116116                    myoptarg = argv[myoptind++];
    117117                return longopts[i].val;
     
    120120            }
    121121        }
    122     bad_opt:
     122      bad_opt:
    123123        fprintf(stderr, "%s: unrecognized option `%s'\n", argv[0], flag);
    124124        return '?';
     
    127127    return -1;
    128128}
    129 
  • neercs/trunk/src/mytrace.c

    r3942 r3969  
    1 /*
     1/* 
    22 *  neercs        console-based window manager
    33 *  Copyright (c) 2008 Pascal Terjan
     
    3737#if defined USE_GRAB
    3838static int memcpy_from_target(struct mytrace *t,
    39                               char* dest, long src, size_t n);
     39                              char *dest, long src, size_t n);
    4040static int memcpy_into_target(struct mytrace *t,
    4141                              long dest, char const *src, size_t n);
     
    9595/* from unistd_32.h on an amd64 system */
    9696int syscalls32[] = { 5, 6, 4, 63, 57, 66, 37, 2, 1, 11, 54 };
     97
    9798int syscalls64[] =
    9899#else
    99100int syscalls32[] =
    100101#endif
    101     { SYS_open, SYS_close, SYS_write, SYS_dup2, SYS_setpgid, SYS_setsid,
    102       SYS_kill, SYS_fork, SYS_exit, SYS_execve, SYS_ioctl };
     102{ SYS_open, SYS_close, SYS_write, SYS_dup2, SYS_setpgid, SYS_setsid,
     103    SYS_kill, SYS_fork, SYS_exit, SYS_execve, SYS_ioctl
     104};
    103105
    104106char const *syscallnames[] =
    105107    { "open", "close", "write", "dup2", "setpgid", "setsid", "kill", "fork",
    106       "exit", "execve", "ioctl" };
     108    "exit", "execve", "ioctl"
     109};
    107110
    108111#endif /* USE_GRAB */
     
    113116};
    114117
    115 struct mytrace* mytrace_attach(long int pid)
     118struct mytrace *mytrace_attach(long int pid)
    116119{
    117120#if defined USE_GRAB
     
    119122    int status;
    120123
    121     if(ptrace(PTRACE_ATTACH, pid, 0, 0) < 0)
     124    if (ptrace(PTRACE_ATTACH, pid, 0, 0) < 0)
    122125    {
    123126        perror("PTRACE_ATTACH (attach)");
    124127        return NULL;
    125128    }
    126     if(waitpid(pid, &status, 0) < 0)
     129    if (waitpid(pid, &status, 0) < 0)
    127130    {
    128131        perror("waitpid");
    129132        return NULL;
    130133    }
    131     if(!WIFSTOPPED(status))
     134    if (!WIFSTOPPED(status))
    132135    {
    133136        fprintf(stderr, "traced process was not stopped\n");
     
    147150}
    148151
    149 struct mytrace* mytrace_fork(struct mytrace *t)
     152struct mytrace *mytrace_fork(struct mytrace *t)
    150153{
    151154#if defined USE_GRAB
     
    198201    int ret, err;
    199202
    200     if(ptrace(PTRACE_GETREGS, t->pid, NULL, &regs) < 0)
     203    if (ptrace(PTRACE_GETREGS, t->pid, NULL, &regs) < 0)
    201204    {
    202205        perror("PTRACE_GETREGS (open)\n");
     
    205208
    206209    /* Backup the data that we will use */
    207     if(memcpy_from_target(t, backup_data, regs.RSP, size) < 0)
     210    if (memcpy_from_target(t, backup_data, regs.RSP, size) < 0)
    208211        return -1;
    209212
     
    241244    int ret, err;
    242245
    243     if(ptrace(PTRACE_GETREGS, t->pid, NULL, &regs) < 0)
     246    if (ptrace(PTRACE_GETREGS, t->pid, NULL, &regs) < 0)
    244247    {
    245248        perror("PTRACE_GETREGS (write)\n");
     
    250253
    251254    /* Backup the data that we will use */
    252     if(memcpy_from_target(t, backup_data, regs.RSP, len) < 0)
     255    if (memcpy_from_target(t, backup_data, regs.RSP, len) < 0)
    253256        return -1;
    254257
     
    326329    char *env, *p;
    327330    long p2, envaddr, argvaddr, envptraddr;
    328     char envpath[PATH_MAX+1];
    329     ssize_t envsize = 16*1024;
     331    char envpath[PATH_MAX + 1];
     332    ssize_t envsize = 16 * 1024;
    330333    int ret, fd, l, l2;
    331334    char *nullp = NULL;
     
    334337    ptrace(PTRACE_SETOPTIONS, t->pid, NULL, PTRACE_O_TRACEEXEC);
    335338
    336     if(ptrace(PTRACE_GETREGS, t->pid, NULL, &regs) < 0)
     339    if (ptrace(PTRACE_GETREGS, t->pid, NULL, &regs) < 0)
    337340    {
    338341        perror("PTRACE_GETREGS (exec)\n");
     
    367370    }
    368371    envsize = r;
    369     l2 = sizeof(char *); /* Size of a pointer */
     372    l2 = sizeof(char *);        /* Size of a pointer */
    370373    p2 = regs.RSP;
    371374
    372375    /* First argument is the command string */
    373     l = strlen(command)+1;
     376    l = strlen(command) + 1;
    374377    memcpy_into_target(t, p2, command, l);
    375378    p2 += l;
     
    392395    envptraddr = p2;
    393396    p = env;
    394     while (p < env+envsize)
     397    while (p < env + envsize)
    395398    {
    396399        long diffp = p - env + envaddr;
    397400        memcpy_into_target(t, p2, (char *)&diffp, l2);
    398401        p2 += l2;
    399         p += strlen(p)+1;
     402        p += strlen(p) + 1;
    400403    }
    401404    /* And have a NULL pointer at the end of the array */
     
    420423    int ret, err;
    421424
    422     if(ptrace(PTRACE_GETREGS, t->pid, NULL, &regs) < 0)
     425    if (ptrace(PTRACE_GETREGS, t->pid, NULL, &regs) < 0)
    423426    {
    424427        perror("PTRACE_GETREGS (tcgets)\n");
     
    427430
    428431    /* Backup the data that we will use */
    429     if(memcpy_from_target(t, backup_data, regs.RSP, size) < 0)
    430         return -1;
    431 
    432     ret = remote_syscall(t, MYCALL_IOCTL, fd,TCGETS, regs.RSP);
     432    if (memcpy_from_target(t, backup_data, regs.RSP, size) < 0)
     433        return -1;
     434
     435    ret = remote_syscall(t, MYCALL_IOCTL, fd, TCGETS, regs.RSP);
    433436    err = errno;
    434437
     
    454457    int ret, err;
    455458
    456     if(ptrace(PTRACE_GETREGS, t->pid, NULL, &regs) < 0)
     459    if (ptrace(PTRACE_GETREGS, t->pid, NULL, &regs) < 0)
    457460    {
    458461        perror("PTRACE_GETREGS (tcsets)\n");
     
    461464
    462465    /* Backup the data that we will use */
    463     if(memcpy_from_target(t, backup_data, regs.RSP, size) < 0)
     466    if (memcpy_from_target(t, backup_data, regs.RSP, size) < 0)
    464467        return -1;
    465468
     
    491494}
    492495
    493 /*
     496/* 
    494497 * XXX: the following functions are local
    495498 */
     
    497500#if defined USE_GRAB
    498501static int memcpy_from_target(struct mytrace *t,
    499                               char* dest, long src, size_t n)
     502                              char *dest, long src, size_t n)
    500503{
    501504    static int const align = sizeof(long) - 1;
    502505
    503     while(n)
     506    while (n)
    504507    {
    505508        long data;
    506509        size_t todo = sizeof(long) - (src & align);
    507510
    508         if(n < todo)
     511        if (n < todo)
    509512            todo = n;
    510513
    511514        data = ptrace(PTRACE_PEEKTEXT, t->pid, src - (src & align), 0);
    512         if(errno)
     515        if (errno)
    513516        {
    514517            perror("ptrace_peektext (memcpy_from_target)");
     
    530533    static int const align = sizeof(long) - 1;
    531534
    532     while(n)
     535    while (n)
    533536    {
    534537        long data;
    535538        size_t todo = sizeof(long) - (dest & align);
    536539
    537         if(n < todo)
     540        if (n < todo)
    538541            todo = n;
    539         if(todo != sizeof(long))
     542        if (todo != sizeof(long))
    540543        {
    541544            data = ptrace(PTRACE_PEEKTEXT, t->pid, dest - (dest & align), 0);
    542             if(errno)
     545            if (errno)
    543546            {
    544547                perror("ptrace_peektext (memcpy_into_target)");
     
    548551
    549552        memcpy((char *)&data + (dest & align), src, todo);
    550         if(ptrace(PTRACE_POKETEXT, t->pid, dest - (dest & align), data) < 0)
     553        if (ptrace(PTRACE_POKETEXT, t->pid, dest - (dest & align), data) < 0)
    551554        {
    552555            perror("ptrace_poketext (memcpy_into_target)");
     
    565568                           long arg1, long arg2, long arg3)
    566569{
    567     /* Method for remote syscall:
    568      *  - wait until the traced application exits from a syscall
    569      *  - save registers
    570      *  - rewind eip/rip to point on the syscall instruction
    571      *  - single step: execute syscall instruction
    572      *  - retrieve resulting registers
    573      *  - restore registers */
     570    /* Method for remote syscall: - wait until the traced application exits
     571       from a syscall - save registers - rewind eip/rip to point on the
     572       syscall instruction - single step: execute syscall instruction -
     573       retrieve resulting registers - restore registers */
    574574    struct user_regs_struct regs, oldregs;
    575575    long oinst;
     
    577577    int offset = 2;
    578578
    579     if(call < 0 || call >= (long)(sizeof(syscallnames)/sizeof(*syscallnames)))
     579    if (call < 0
     580        || call >= (long)(sizeof(syscallnames) / sizeof(*syscallnames)))
    580581    {
    581582        fprintf(stderr, "unknown remote syscall %li\n", call);
     
    592593#endif
    593594
    594     for(;;)
    595     {
    596         if(ptrace(PTRACE_GETREGS, t->pid, NULL, &oldregs) < 0)
     595    for (;;)
     596    {
     597        if (ptrace(PTRACE_GETREGS, t->pid, NULL, &oldregs) < 0)
    597598        {
    598599            perror("PTRACE_GETREGS (syscall 1)\n");
     
    603604
    604605#if defined __x86_64__
    605         if(oinst == SYSCALL_AMD64)
     606        if (oinst == SYSCALL_AMD64)
    606607            break;
    607608#endif
    608         if(oinst == SYSCALL_X86 || oinst == SYSCALL_X86_NEW)
     609        if (oinst == SYSCALL_X86 || oinst == SYSCALL_X86_NEW)
    609610        {
    610611            bits = 32;
     
    612613        }
    613614
    614         if(ptrace(PTRACE_SYSCALL, t->pid, NULL, 0) < 0)
     615        if (ptrace(PTRACE_SYSCALL, t->pid, NULL, 0) < 0)
    615616        {
    616617            perror("ptrace_syscall (1)");
     
    618619        }
    619620        waitpid(t->pid, NULL, 0);
    620         if(ptrace(PTRACE_SYSCALL, t->pid, NULL, 0) < 0)
     621        if (ptrace(PTRACE_SYSCALL, t->pid, NULL, 0) < 0)
    621622        {
    622623            perror("ptrace_syscall (2)");
     
    628629    print_registers(t->pid);
    629630
    630     if(oinst == SYSCALL_X86_NEW)
    631     {
    632         /*  Get back to sysenter */
    633         while((ptrace(PTRACE_PEEKTEXT, t->pid, oldregs.RIP - offset, 0) & 0xffff) != 0x340f)
     631    if (oinst == SYSCALL_X86_NEW)
     632    {
     633        /* Get back to sysenter */
     634        while ((ptrace(PTRACE_PEEKTEXT, t->pid, oldregs.RIP - offset, 0) &
     635                0xffff) != 0x340f)
    634636            offset++;
    635637        oldregs.RBP = oldregs.RSP;
     
    639641    regs.RIP = regs.RIP - offset;
    640642#if defined __x86_64__
    641     if(bits == 64)
     643    if (bits == 64)
    642644    {
    643645        regs.RAX = syscalls64[call];
     
    655657    }
    656658
    657     if(ptrace(PTRACE_SETREGS, t->pid, NULL, &regs) < 0)
     659    if (ptrace(PTRACE_SETREGS, t->pid, NULL, &regs) < 0)
    658660    {
    659661        perror("PTRACE_SETREGS (syscall 1)\n");
     
    661663    }
    662664
    663     for(;;)
     665    for (;;)
    664666    {
    665667        int status;
     
    667669        print_registers(t->pid);
    668670
    669         if(ptrace(PTRACE_SINGLESTEP, t->pid, NULL, NULL) < 0)
     671        if (ptrace(PTRACE_SINGLESTEP, t->pid, NULL, NULL) < 0)
    670672        {
    671673            perror("PTRACE_SINGLESTEP (syscall)\n");
     
    674676        waitpid(t->pid, &status, 0);
    675677
    676         if(WIFEXITED(status))
     678        if (WIFEXITED(status))
    677679            return 0;
    678680
    679         if(!WIFSTOPPED(status) || WSTOPSIG(status) != SIGTRAP)
     681        if (!WIFSTOPPED(status) || WSTOPSIG(status) != SIGTRAP)
    680682            continue;
    681683
    682684        /* Fuck Linux: there is no macro for this */
    683         switch((status >> 16) & 0xffff)
     685        switch ((status >> 16) & 0xffff)
    684686        {
    685687        case PTRACE_EVENT_FORK:
    686             if(ptrace(PTRACE_GETEVENTMSG, t->pid, 0, &t->child) < 0)
     688            if (ptrace(PTRACE_GETEVENTMSG, t->pid, 0, &t->child) < 0)
    687689            {
    688690                perror("PTRACE_GETEVENTMSG (syscall)\n");
     
    705707    print_registers(t->pid);
    706708
    707     if(ptrace(PTRACE_GETREGS, t->pid, NULL, &regs) < 0)
     709    if (ptrace(PTRACE_GETREGS, t->pid, NULL, &regs) < 0)
    708710    {
    709711        perror("PTRACE_GETREGS (syscall 2)\n");
     
    711713    }
    712714
    713     if(ptrace(PTRACE_SETREGS, t->pid, NULL, &oldregs) < 0)
     715    if (ptrace(PTRACE_SETREGS, t->pid, NULL, &oldregs) < 0)
    714716    {
    715717        perror("PTRACE_SETREGS (syscall 2)\n");
     
    720722    debug("syscall %s returned %ld", syscallnames[call], regs.RAX);
    721723
    722     if((long)regs.RAX < 0)
     724    if ((long)regs.RAX < 0)
    723725    {
    724726        errno = -(long)regs.RAX;
     
    734736static void print_registers(pid_t pid)
    735737{
    736     union { long int l; unsigned char data[sizeof(long int)]; } inst;
     738    union
     739    {
     740        long int l;
     741        unsigned char data[sizeof(long int)];
     742    } inst;
    737743    struct user_regs_struct regs;
    738744    int i;
    739745
    740     if(ptrace(PTRACE_GETREGS, pid, NULL, &regs) < 0)
     746    if (ptrace(PTRACE_GETREGS, pid, NULL, &regs) < 0)
    741747    {
    742748        perror("PTRACE_GETREGS (syscall 2)");
     
    744750    }
    745751
    746     fprintf(stderr, "  / %s: "FMT"   ", STRINGIFY(RAX), regs.RAX);
    747     fprintf(stderr, "%s: "FMT"\n", STRINGIFY(RBX), regs.RBX);
    748     fprintf(stderr, "  | %s: "FMT"   ", STRINGIFY(RCX), regs.RCX);
    749     fprintf(stderr, "%s: "FMT"\n", STRINGIFY(RDX), regs.RDX);
    750     fprintf(stderr, "  | %s: "FMT"   ", STRINGIFY(RDI), regs.RDI);
    751     fprintf(stderr, "%s: "FMT"\n", STRINGIFY(RSI), regs.RSI);
    752     fprintf(stderr, "  | %s: "FMT"   ", STRINGIFY(RSP), regs.RSP);
    753     fprintf(stderr, "%s: "FMT"\n", STRINGIFY(RIP), regs.RIP);
     752    fprintf(stderr, "  / %s: " FMT "   ", STRINGIFY(RAX), regs.RAX);
     753    fprintf(stderr, "%s: " FMT "\n", STRINGIFY(RBX), regs.RBX);
     754    fprintf(stderr, "  | %s: " FMT "   ", STRINGIFY(RCX), regs.RCX);
     755    fprintf(stderr, "%s: " FMT "\n", STRINGIFY(RDX), regs.RDX);
     756    fprintf(stderr, "  | %s: " FMT "   ", STRINGIFY(RDI), regs.RDI);
     757    fprintf(stderr, "%s: " FMT "\n", STRINGIFY(RSI), regs.RSI);
     758    fprintf(stderr, "  | %s: " FMT "   ", STRINGIFY(RSP), regs.RSP);
     759    fprintf(stderr, "%s: " FMT "\n", STRINGIFY(RIP), regs.RIP);
    754760
    755761    inst.l = ptrace(PTRACE_PEEKTEXT, pid, regs.RIP - 4, 0);
     
    761767
    762768    fprintf(stderr, "  \\ stack: ... ");
    763     for(i = -16; i < 24; i += sizeof(long))
     769    for (i = -16; i < 24; i += sizeof(long))
    764770    {
    765771        inst.l = ptrace(PTRACE_PEEKDATA, pid, regs.RSP + i, 0);
     
    772778                inst.data[0], inst.data[1], inst.data[2], inst.data[3]);
    773779#endif
    774         if(i == 0)
     780        if (i == 0)
    775781            fprintf(stderr, "[%s] ", STRINGIFY(RSP));
    776782    }
  • neercs/trunk/src/recurrent.c

    r3551 r3969  
    1 /*
     1/* 
    22 *  neercs        console-based window manager
    33 *  Copyright (c) 2006 Sam Hocevar <sam@zoy.org>
     
    3131
    3232
    33 int handle_recurrents(struct screen_list* screen_list)
     33int handle_recurrents(struct screen_list *screen_list)
    3434{
    3535    int refresh = 0, i;
    3636    /* Recurrent functions */
    37     for(i=0; i<screen_list->recurrent_list->count; i++)
     37    for (i = 0; i < screen_list->recurrent_list->count; i++)
    3838    {
    39         if(screen_list->recurrent_list->recurrent[i]->function)
     39        if (screen_list->recurrent_list->recurrent[i]->function)
    4040        {
    41             refresh |= screen_list->recurrent_list->recurrent[i]->function(screen_list,
    42                                                                            screen_list->recurrent_list->recurrent[i],
    43                                                                            screen_list->recurrent_list->recurrent[i]->user,
    44                                                                            get_us());
     41            refresh |=
     42                screen_list->recurrent_list->recurrent[i]->
     43                function(screen_list,
     44                         screen_list->recurrent_list->recurrent[i],
     45                         screen_list->recurrent_list->recurrent[i]->user,
     46                         get_us());
    4547        }
    4648    }
    4749    /* Delete recurrent functions */
    48     for(i=0; i<screen_list->recurrent_list->count; i++)
     50    for (i = 0; i < screen_list->recurrent_list->count; i++)
    4951    {
    50         if(screen_list->recurrent_list->recurrent[i]->kill_me)
     52        if (screen_list->recurrent_list->recurrent[i]->kill_me)
    5153        {
    5254            remove_recurrent(screen_list->recurrent_list, i);
     
    5860
    5961
    60 /* Add recurrent function. It will be called at each main loop iteration, unless it is removed */
     62/* Add recurrent function. It will be called at each main loop iteration,
     63   unless it is removed */
    6164int add_recurrent(struct recurrent_list *list,
    62                   int (*func)(struct screen_list*, struct recurrent* rec, void *user, long long unsigned int t),
     65                  int (*func) (struct screen_list *, struct recurrent * rec,
     66                               void *user, long long unsigned int t),
    6367                  void *user)
    6468{
    65     if(list == NULL || func == NULL) return -1;
     69    if (list == NULL || func == NULL)
     70        return -1;
    6671
    67     list->recurrent = (struct recurrent**) realloc(list->recurrent,
    68                                                    sizeof(struct recurrent*)
    69                                                    * (list->count+1));
     72    list->recurrent = (struct recurrent **)realloc(list->recurrent,
     73                                                   sizeof(struct recurrent *)
     74                                                   * (list->count + 1));
    7075
    71     if(!list->recurrent)
    72         fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__, __LINE__);
     76    if (!list->recurrent)
     77        fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__,
     78                __LINE__);
    7379
    7480    list->recurrent[list->count] = malloc(sizeof(struct recurrent));
    7581
    76     list->recurrent[list->count]->kill_me    = 0;
    77     list->recurrent[list->count]->function   = func;
    78     list->recurrent[list->count]->user       = user;
     82    list->recurrent[list->count]->kill_me = 0;
     83    list->recurrent[list->count]->function = func;
     84    list->recurrent[list->count]->user = user;
    7985    list->recurrent[list->count]->start_time = get_us();
    8086    list->count++;
    8187
    82     return list->count-1;
     88    return list->count - 1;
    8389}
    8490
     
    8894{
    8995
    90     if(n>=list->count) return -1;
     96    if (n >= list->count)
     97        return -1;
    9198
    9299    memmove(&list->recurrent[n],
    93             &list->recurrent[n+1],
    94             sizeof(struct recurrent*)*(list->count-(n+1)));
     100            &list->recurrent[n + 1],
     101            sizeof(struct recurrent *) * (list->count - (n + 1)));
    95102
    96103    free(list->recurrent[n]);
    97     list->recurrent = (struct recurrent**) realloc(list->recurrent,
    98                                              sizeof(sizeof(struct recurrent*))
    99                                              * (list->count));
    100     if(!list->recurrent)
    101         fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__, __LINE__);
     104    list->recurrent = (struct recurrent **)realloc(list->recurrent,
     105                                                   sizeof(sizeof
     106                                                          (struct recurrent *))
     107                                                   * (list->count));
     108    if (!list->recurrent)
     109        fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__,
     110                __LINE__);
    102111
    103112
  • neercs/trunk/src/screens.c

    r3967 r3969  
    1 /*
     1/* 
    22 *  neercs        console-based window manager
    33 *  Copyright (c) 2006 Sam Hocevar <sam@zoy.org>
     
    3030#include "neercs.h"
    3131
    32 struct screen* create_screen_grab(int w, int h, int pid)
    33 {
    34     struct screen *s = (struct screen*) malloc(sizeof(struct screen));
     32struct screen *create_screen_grab(int w, int h, int pid)
     33{
     34    struct screen *s = (struct screen *)malloc(sizeof(struct screen));
    3535
    3636    s->cv = caca_create_canvas(w, h);
     
    4848    s->fd = create_pty_grab(pid, w, h, &s->pid);
    4949
    50     if(s->fd < 0)
     50    if (s->fd < 0)
    5151    {
    5252        caca_free_canvas(s->cv);
     
    5757}
    5858
    59 struct screen* create_screen(int w, int h, char *command)
    60 {
    61     struct screen *s = (struct screen*) malloc(sizeof(struct screen));
     59struct screen *create_screen(int w, int h, char *command)
     60{
     61    struct screen *s = (struct screen *)malloc(sizeof(struct screen));
    6262
    6363    s->cv = caca_create_canvas(w, h);
     
    8282
    8383
    84     if(s->fd < 0)
     84    if (s->fd < 0)
    8585    {
    8686        caca_free_canvas(s->cv);
     
    9393int destroy_screen(struct screen *s)
    9494{
    95     if(s->fd>=0)
     95    if (s->fd >= 0)
    9696        close(s->fd);
    97     if(s->buf)
     97    if (s->buf)
    9898        free(s->buf);
    99     if(s->title)
     99    if (s->title)
    100100        free(s->title);
    101101    s->buf = NULL;
    102     if(s->cv)
     102    if (s->cv)
    103103        caca_free_canvas(s->cv);
    104104    s->cv = NULL;
     
    109109int add_screen(struct screen_list *list, struct screen *s)
    110110{
    111     if(list == NULL || s == NULL) return -1;
     111    if (list == NULL || s == NULL)
     112        return -1;
    112113
    113114    else
    114115    {
    115         list->screen = (struct screen**) realloc(list->screen,
    116                                                  sizeof(sizeof(struct screen*))
    117                                                  * (list->count+1));
    118         if(!list->screen)
    119             fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__, __LINE__);
     116        list->screen = (struct screen **)realloc(list->screen,
     117                                                 sizeof(sizeof
     118                                                        (struct screen *)) *
     119                                                 (list->count + 1));
     120        if (!list->screen)
     121            fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__,
     122                    __LINE__);
    120123        list->screen[list->count] = s;
    121124        list->count++;
     
    124127    list->changed = 1;
    125128
    126     return list->count-1;
     129    return list->count - 1;
    127130}
    128131
     
    130133{
    131134
    132     if(n>=list->count) return -1;
    133 
    134     if(please_kill)
     135    if (n >= list->count)
     136        return -1;
     137
     138    if (please_kill)
    135139    {
    136140        int status = 0;
     
    141145        kill(list->screen[n]->pid, SIGINT);
    142146        ret = waitpid(list->screen[n]->pid, &status,
    143                       WNOHANG|WUNTRACED|WCONTINUED);
    144         if(!ret)
     147                      WNOHANG | WUNTRACED | WCONTINUED);
     148        if (!ret)
    145149            kill(list->screen[n]->pid, SIGQUIT);
    146150        ret = waitpid(list->screen[n]->pid, &status,
    147                       WNOHANG|WUNTRACED|WCONTINUED);
    148         if(!ret)
     151                      WNOHANG | WUNTRACED | WCONTINUED);
     152        if (!ret)
    149153            kill(list->screen[n]->pid, SIGABRT);
    150154        ret = waitpid(list->screen[n]->pid, &status,
    151                       WNOHANG|WUNTRACED|WCONTINUED);
    152         if(!ret)
     155                      WNOHANG | WUNTRACED | WCONTINUED);
     156        if (!ret)
    153157            kill(list->screen[n]->pid, SIGKILL);
    154158
     
    157161
    158162    memmove(&list->screen[n],
    159             &list->screen[n+1],
    160             sizeof(struct screen*)*(list->count-(n+1)));
    161 
    162     list->screen = (struct screen**) realloc(list->screen,
    163                                              sizeof(sizeof(struct screen*))
     163            &list->screen[n + 1],
     164            sizeof(struct screen *) * (list->count - (n + 1)));
     165
     166    list->screen = (struct screen **)realloc(list->screen,
     167                                             sizeof(sizeof(struct screen *))
    164168                                             * (list->count));
    165     if(!list->screen)
    166         fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__, __LINE__);
     169    if (!list->screen)
     170        fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__,
     171                __LINE__);
    167172
    168173
     
    179184    int i;
    180185
    181     if(!screen_list->count) return;
     186    if (!screen_list->count)
     187        return;
    182188
    183189
    184190    debug("Current pty is %d\n", screen_list->pty);
    185191
    186     screen_list->width  = caca_get_canvas_width(screen_list->cv);
    187     screen_list->height = caca_get_canvas_height(screen_list->cv) - (screen_list->mini*6) - screen_list->status;
    188 
    189     if(!screen_list->dont_update_coords)
     192    screen_list->width = caca_get_canvas_width(screen_list->cv);
     193    screen_list->height =
     194        caca_get_canvas_height(screen_list->cv) - (screen_list->mini * 6) -
     195        screen_list->status;
     196
     197    if (!screen_list->dont_update_coords)
    190198    {
    191199        update_windows_props(screen_list);
    192200    }
    193201
    194     if(screen_list->changed)
     202    if (screen_list->changed)
    195203    {
    196204        caca_set_color_ansi(screen_list->cv, CACA_DEFAULT, CACA_DEFAULT);
     
    208216
    209217
    210     if(screen_list->mini)
     218    if (screen_list->mini)
    211219    {
    212220        draw_thumbnails(screen_list);
    213221    }
    214     if(screen_list->status)
     222    if (screen_list->status)
    215223    {
    216224        draw_status(screen_list);
    217225    }
    218     if(screen_list->help)
     226    if (screen_list->help)
    219227    {
    220228        draw_help(screen_list);
    221229    }
    222     if(screen_list->window_list)
     230    if (screen_list->window_list)
    223231    {
    224232        draw_list(screen_list);
    225233    }
    226234    screen_list->changed = 0;
    227     for(i = screen_list->count - 1; i >=0; i--)
     235    for (i = screen_list->count - 1; i >= 0; i--)
    228236        screen_list->screen[i]->changed = 0;
    229237}
    230238
    231239
    232 int update_screens_contents(struct screen_list* screen_list)
     240int update_screens_contents(struct screen_list *screen_list)
    233241{
    234242    int i, refresh = 0;
     
    240248    /* Read data, if any */
    241249    FD_ZERO(&fdset);
    242     for(i = 0; i < screen_list->count; i++)
    243     {
    244         if(screen_list->screen[i]->fd >= 0)
     250    for (i = 0; i < screen_list->count; i++)
     251    {
     252        if (screen_list->screen[i]->fd >= 0)
    245253            FD_SET(screen_list->screen[i]->fd, &fdset);
    246         if(screen_list->screen[i]->fd > maxfd)
     254        if (screen_list->screen[i]->fd > maxfd)
    247255            maxfd = screen_list->screen[i]->fd;
    248256    }
     
    251259    ret = select(maxfd + 1, &fdset, NULL, NULL, &tv);
    252260
    253     if(ret < 0)
    254     {
    255         if(errno == EINTR)
    256             ; /* We probably got a SIGWINCH, ignore it */
     261    if (ret < 0)
     262    {
     263        if (errno == EINTR)
     264            ;                   /* We probably got a SIGWINCH, ignore it */
    257265        else
    258266        {
    259             /* FIXME: Useless since break will mean that we return 0
    260              * But I don't know what was the purpose of this code */
    261             for(i = 0; i < screen_list->count; i++)
    262                 if(screen_list->screen[i]->total)
     267            /* FIXME: Useless since break will mean that we return 0 But I
     268               don't know what was the purpose of this code */
     269            for (i = 0; i < screen_list->count; i++)
     270                if (screen_list->screen[i]->total)
    263271                    break;
    264             if(i == screen_list->count)
     272            if (i == screen_list->count)
    265273                return 0;
    266274        }
    267275    }
    268     else if(ret)
    269     {
    270 
    271     for(i = 0; i < screen_list->count; i++)
    272     {
    273         /* FIXME: try a new strategy: read all filedescriptors until
    274          * each of them starved at least once. */
    275 
    276         if(screen_list->screen[i]->fd < 0 ||
    277            !FD_ISSET(screen_list->screen[i]->fd, &fdset))
    278             continue;
    279 
    280         for(;;)
     276    else if (ret)
     277    {
     278
     279        for (i = 0; i < screen_list->count; i++)
    281280        {
    282             ssize_t nr;
    283 
    284             screen_list->screen[i]->buf =
    285                 realloc(screen_list->screen[i]->buf,
    286                         screen_list->screen[i]->total + 1024);
    287             if(!screen_list->screen[i]->buf)
    288                 fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__, __LINE__);
    289 
    290             nr = read(screen_list->screen[i]->fd,
    291                       screen_list->screen[i]->buf +
    292                       screen_list->screen[i]->total, 1024);
    293 
    294             if(nr > 0)
     281            /* FIXME: try a new strategy: read all filedescriptors until each
     282               of them starved at least once. */
     283
     284            if (screen_list->screen[i]->fd < 0 ||
     285                !FD_ISSET(screen_list->screen[i]->fd, &fdset))
     286                continue;
     287
     288            for (;;)
    295289            {
    296                 screen_list->screen[i]->total += nr;
    297                 continue;
     290                ssize_t nr;
     291
     292                screen_list->screen[i]->buf =
     293                    realloc(screen_list->screen[i]->buf,
     294                            screen_list->screen[i]->total + 1024);
     295                if (!screen_list->screen[i]->buf)
     296                    fprintf(stderr, "Can't allocate memory at %s:%d\n",
     297                            __FUNCTION__, __LINE__);
     298
     299                nr = read(screen_list->screen[i]->fd,
     300                          screen_list->screen[i]->buf +
     301                          screen_list->screen[i]->total, 1024);
     302
     303                if (nr > 0)
     304                {
     305                    screen_list->screen[i]->total += nr;
     306                    continue;
     307                }
     308
     309                if (nr == 0 || errno != EWOULDBLOCK)
     310                {
     311                    remove_screen(screen_list, i, 0);
     312                    if (i < screen_list->prevpty)
     313                        screen_list->prevpty--;
     314                    if (i == screen_list->pty)
     315                    {
     316                        screen_list->pty = screen_list->prevpty;
     317                        screen_list->prevpty = 0;
     318                    }
     319                    if (i < (screen_list->pty))
     320                        (screen_list->pty)--;
     321                    /* Don't skip the element which is now at position i */
     322                    i--;
     323                    refresh = 1;
     324                }
     325
     326                break;
    298327            }
    299 
    300             if(nr == 0 || errno != EWOULDBLOCK)
    301             {
    302                 remove_screen(screen_list, i, 0);
    303                 if(i < screen_list->prevpty) screen_list->prevpty--;
    304                 if(i == screen_list->pty)
    305                 {
    306                     screen_list->pty = screen_list->prevpty;
    307                     screen_list->prevpty = 0;
    308                 }
    309                 if(i < (screen_list->pty)) (screen_list->pty)--;
    310                 /* Don't skip the element which is now at position i */
    311                 i--;
    312                 refresh = 1;
    313             }
    314 
    315             break;
    316328        }
    317329    }
    318     }
    319330    return refresh;
    320331}
    321 
    322 
  • neercs/trunk/src/screensaver.c

    r3954 r3969  
    1 /*
     1/* 
    22 *  neercs        console-based window manager
    33 *  Copyright (c) 2006 Sam Hocevar <sam@zoy.org>
     
    5757
    5858char toaster_text[3][99] = { {
    59 "      __._ \n"
    60 "   .-'== _',\n"
    61 "  <|_= .-'  |\n"
    62 "   | --|   \\'.-_ \n"
    63 "   |   | \\  \" _.\n"
    64 "    `-_|.-\\_.-\n"
    65 }, {
    66 "      __._ \n"
    67 "   .-'== _',\n"
    68 "  \\|_= .-'  |\n"
    69 "   | --|  __'-.\n"
    70 "   |   | ___.-\n"
    71 "    `-_|.-\n"
    72 }, {
    73 "   _- __._\n"
    74 "  /.-'== _',_.-.\n"
    75 "  \\|_= .-'/  _.'\n"
    76 "   | --| / .-\n"
    77 "   |   |  _.|\n"
    78 "    `-_|.-\n"} };
     59                              "      __._ \n"
     60                              "   .-'== _',\n"
     61                              "  <|_= .-'  |\n"
     62                              "   | --|   \\'.-_ \n"
     63                              "   |   | \\  \" _.\n" "    `-_|.-\\_.-\n"}, {
     64                                                                            "      __._ \n"
     65                                                                            "   .-'== _',\n"
     66                                                                            "  \\|_= .-'  |\n"
     67                                                                            "   | --|  __'-.\n"
     68                                                                            "   |   | ___.-\n"
     69                                                                            "    `-_|.-\n"},
     70{
     71 "   _- __._\n" "  /.-'== _',_.-.\n" "  \\|_= .-'/  _.'\n" "   | --| / .-\n"
     72 "   |   |  _.|\n" "    `-_|.-\n"}
     73};
    7974
    8075char toaster_mask[3][99] = { {
    81 "      __._ \n"
    82 "   .-'== _',\n"
    83 "  <|_=X.-'XX|\n"
    84 "   |X--|XXX\\'.-_ \n"
    85 "   |XXX|X\\XX\"X_.\n"
    86 "    `-_|.-\\_.-\n"
    87 }, {
     76                              "      __._ \n"
     77                              "   .-'== _',\n"
     78                              "  <|_=X.-'XX|\n"
     79                              "   |X--|XXX\\'.-_ \n"
     80                              "   |XXX|X\\XX\"X_.\n" "    `-_|.-\\_.-\n"}, {
    8881
    89 "      __._ \n"
    90 "   .-'== _',\n"
    91 "  \\|_= .-'XX|\n"
    92 "   |X--|XX__'-.\n"
    93 "   |XXX|X___.-\n"
    94 "    `-_|.-\n"
    95 }, {
    96 "   _- __._\n"
    97 "  /.-'== _',_.-.\n"
    98 "  \\|_= .-'/XX_.'\n"
    99 "   |X--|X/X.-\n"
    100 "   |XXX|XX_.|\n"
    101 "    `-_|.-\n"} };
     82                                                                            "      __._ \n"
     83                                                                            "   .-'== _',\n"
     84                                                                            "  \\|_= .-'XX|\n"
     85                                                                            "   |X--|XX__'-.\n"
     86                                                                            "   |XXX|X___.-\n"
     87                                                                            "    `-_|.-\n"},
     88{
     89 "   _- __._\n" "  /.-'== _',_.-.\n" "  \\|_= .-'/XX_.'\n" "   |X--|X/X.-\n"
     90 "   |XXX|XX_.|\n" "    `-_|.-\n"}
     91};
    10292
    10393struct flying_toaster
     
    116106
    117107    flying_toaster = malloc(sizeof(struct flying_toaster));
    118     flying_toaster->toaster = (caca_canvas_t **)malloc(sizeof(caca_canvas_t*)*3);
    119     flying_toaster->mask = (caca_canvas_t **)malloc(sizeof(caca_canvas_t*)*3);
     108    flying_toaster->toaster =
     109        (caca_canvas_t **) malloc(sizeof(caca_canvas_t *) * 3);
     110    flying_toaster->mask =
     111        (caca_canvas_t **) malloc(sizeof(caca_canvas_t *) * 3);
    120112
    121     for(i = 0; i < 3; i++)
     113    for (i = 0; i < 3; i++)
    122114    {
    123115        flying_toaster->toaster[i] = caca_create_canvas(0, 0);
    124116        flying_toaster->mask[i] = caca_create_canvas(0, 0);
    125117        caca_import_canvas_from_memory(flying_toaster->toaster[i],
    126                            toaster_text[i],
    127                            strlen(toaster_text[i]), "utf8");
     118                                       toaster_text[i],
     119                                       strlen(toaster_text[i]), "utf8");
    128120        caca_import_canvas_from_memory(flying_toaster->mask[i],
    129                            toaster_mask[i],
    130                            strlen(toaster_mask[i]), "utf8");
     121                                       toaster_mask[i],
     122                                       strlen(toaster_mask[i]), "utf8");
    131123    }
    132124
    133     for(i = 0; i < COUNT; i++)
     125    for (i = 0; i < COUNT; i++)
    134126    {
    135         flying_toaster->x[i] = (rand()%w) * PRECISION;
    136         flying_toaster->y[i] = (rand()%h) * PRECISION;
    137         flying_toaster->s[i] = (rand()%3) * PRECISION;
     127        flying_toaster->x[i] = (rand() % w) * PRECISION;
     128        flying_toaster->y[i] = (rand() % h) * PRECISION;
     129        flying_toaster->s[i] = (rand() % 3) * PRECISION;
    138130    }
    139131
     
    158150    struct flying_toaster *d = screen_list->screensaver_data;
    159151    int i, w, h, x, y, s;
    160     if(!d) return;
     152    if (!d)
     153        return;
    161154
    162155    w = caca_get_canvas_width(screen_list->cv);
     
    166159    caca_clear_canvas(screen_list->cv);
    167160
    168     for(i = 0; i < COUNT; i++)
     161    for (i = 0; i < COUNT; i++)
    169162    {
    170         x = d->x[i]/PRECISION;
    171         y = d->y[i]/PRECISION;
    172         s = d->s[i]/PRECISION;
     163        x = d->x[i] / PRECISION;
     164        y = d->y[i] / PRECISION;
     165        s = d->s[i] / PRECISION;
    173166
    174167        caca_blit(screen_list->cv, x, y, d->toaster[s], d->mask[s]);
    175168
    176         d->x[i]-=40;
    177         d->y[i]+=10;
     169        d->x[i] -= 40;
     170        d->y[i] += 10;
    178171
    179         if(d->x[i]/PRECISION + caca_get_canvas_width(d->toaster[s])<=0)
    180             d->x[i] = ((rand()%w)/3+w) * PRECISION;
    181         if(d->y[i]/PRECISION>=h)
    182             d->y[i] = ((rand()%h)/2-h) * PRECISION;
     172        if (d->x[i] / PRECISION + caca_get_canvas_width(d->toaster[s]) <= 0)
     173            d->x[i] = ((rand() % w) / 3 + w) * PRECISION;
     174        if (d->y[i] / PRECISION >= h)
     175            d->y[i] = ((rand() % h) / 2 - h) * PRECISION;
    183176
    184         d->s[i] = ((d->s[i]+24)%(3*PRECISION));
     177        d->s[i] = ((d->s[i] + 24) % (3 * PRECISION));
    185178    }
    186179}
  • neercs/trunk/src/server.c

    r3964 r3969  
    455455    if (screen_list->help)
    456456    {
    457         if (c == CACA_KEY_ESCAPE ||
    458             c == 'h')
     457        if (c == CACA_KEY_ESCAPE || c == 'h')
    459458        {
    460459            screen_list->help = 0;
  • neercs/trunk/src/term.c

    r3968 r3969  
    1 /*
     1/* 
    22 *  neercs        console-based window manager
    33 *  Copyright (c) 2006 Sam Hocevar <sam@zoy.org>
     
    2020#include <string.h>
    2121#if defined HAVE_PTY_H
    22 #   include <pty.h>  /* for openpty and forkpty */
     22#   include <pty.h>             /* for openpty and forkpty */
    2323#else
    24 #   include <util.h> /* for OS X */
     24#   include <util.h>            /* for OS X */
    2525#endif
    2626#include <unistd.h>
     
    3737    switch (uc)
    3838    {
    39     case '+': return 0x2192; /* RIGHTWARDS ARROW */
    40     case ',': return 0x2190; /* LEFTWARDS ARROW */
    41     case '-': return 0x2191; /* UPWARDS ARROW */
    42     case '.': return 0x2193; /* DOWNWARDS ARROW */
    43     case '0': return 0x25AE; /* BLACK VERTICAL RECTANGLE */
    44     case '_': return 0x25AE; /* BLACK VERTICAL RECTANGLE */
    45     case '`': return 0x25C6; /* BLACK DIAMOND */
    46     case 'a': return 0x2592; /* MEDIUM SHADE */
    47     case 'b': return 0x2409; /* SYMBOL FOR HORIZONTAL TABULATION */
    48     case 'c': return 0x240C; /* SYMBOL FOR FORM FEED */
    49     case 'd': return 0x240D; /* SYMBOL FOR CARRIAGE RETURN */
    50     case 'e': return 0x240A; /* SYMBOL FOR LINE FEED */
    51     case 'f': return 0x00B0; /* DEGREE SIGN */
    52     case 'g': return 0x00B1; /* PLUS-MINUS SIGN */
    53     case 'h': return 0x2424; /* SYMBOL FOR NEWLINE */
    54     case 'i': return 0x240B; /* SYMBOL FOR VERTICAL TABULATION */
    55     case 'j': return 0x2518; /* BOX DRAWINGS LIGHT UP AND LEFT */
    56     case 'k': return 0x2510; /* BOX DRAWINGS LIGHT DOWN AND LEFT */
    57     case 'l': return 0x250C; /* BOX DRAWINGS LIGHT DOWN AND RIGHT */
    58     case 'm': return 0x2514; /* BOX DRAWINGS LIGHT UP AND RIGHT */
    59     case 'n': return 0x253C; /* BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL */
    60     case 'o': return 0x23BA; /* HORIZONTAL SCAN LINE-1 */
    61     case 'p': return 0x23BB; /* HORIZONTAL SCAN LINE-3 */
    62     case 'q': return 0x2500; /* BOX DRAWINGS LIGHT HORIZONTAL */
    63     case 'r': return 0x23BC; /* HORIZONTAL SCAN LINE-7 */
    64     case 's': return 0x23BD; /* HORIZONTAL SCAN LINE-9 */
    65     case 't': return 0x251C; /* BOX DRAWINGS LIGHT VERTICAL AND RIGHT */
    66     case 'u': return 0x2524; /* BOX DRAWINGS LIGHT VERTICAL AND LEFT */
    67     case 'v': return 0x2534; /* BOX DRAWINGS LIGHT UP AND HORIZONTAL */
    68     case 'w': return 0x252C; /* BOX DRAWINGS LIGHT DOWN AND HORIZONTAL */
    69     case 'x': return 0x2502; /* BOX DRAWINGS LIGHT VERTICAL */
    70     case 'y': return 0x2264; /* LESS-THAN OR EQUAL TO */
    71     case 'z': return 0x2265; /* GREATER-THAN OR EQUAL TO */
    72     case '{': return 0x03C0; /* GREEK SMALL LETTER PI */
    73     case '|': return 0x2260; /* NOT EQUAL TO */
    74     case '}': return 0x00A3; /* POUND SIGN */
    75     case '~': return 0x00B7; /* MIDDLE DOT */
     39    case '+':
     40        return 0x2192;          /* RIGHTWARDS ARROW */
     41    case ',':
     42        return 0x2190;          /* LEFTWARDS ARROW */
     43    case '-':
     44        return 0x2191;          /* UPWARDS ARROW */
     45    case '.':
     46        return 0x2193;          /* DOWNWARDS ARROW */
     47    case '0':
     48        return 0x25AE;          /* BLACK VERTICAL RECTANGLE */
     49    case '_':
     50        return 0x25AE;          /* BLACK VERTICAL RECTANGLE */
     51    case '`':
     52        return 0x25C6;          /* BLACK DIAMOND */
     53    case 'a':
     54        return 0x2592;          /* MEDIUM SHADE */
     55    case 'b':
     56        return 0x2409;          /* SYMBOL FOR HORIZONTAL TABULATION */
     57    case 'c':
     58        return 0x240C;          /* SYMBOL FOR FORM FEED */
     59    case 'd':
     60        return 0x240D;          /* SYMBOL FOR CARRIAGE RETURN */
     61    case 'e':
     62        return 0x240A;          /* SYMBOL FOR LINE FEED */
     63    case 'f':
     64        return 0x00B0;          /* DEGREE SIGN */
     65    case 'g':
     66        return 0x00B1;          /* PLUS-MINUS SIGN */
     67    case 'h':
     68        return 0x2424;          /* SYMBOL FOR NEWLINE */
     69    case 'i':
     70        return 0x240B;          /* SYMBOL FOR VERTICAL TABULATION */
     71    case 'j':
     72        return 0x2518;          /* BOX DRAWINGS LIGHT UP AND LEFT */
     73    case 'k':
     74        return 0x2510;          /* BOX DRAWINGS LIGHT DOWN AND LEFT */
     75    case 'l':
     76        return 0x250C;          /* BOX DRAWINGS LIGHT DOWN AND RIGHT */
     77    case 'm':
     78        return 0x2514;          /* BOX DRAWINGS LIGHT UP AND RIGHT */
     79    case 'n':
     80        return 0x253C;          /* BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL */
     81    case 'o':
     82        return 0x23BA;          /* HORIZONTAL SCAN LINE-1 */
     83    case 'p':
     84        return 0x23BB;          /* HORIZONTAL SCAN LINE-3 */
     85    case 'q':
     86        return 0x2500;          /* BOX DRAWINGS LIGHT HORIZONTAL */
     87    case 'r':
     88        return 0x23BC;          /* HORIZONTAL SCAN LINE-7 */
     89    case 's':
     90        return 0x23BD;          /* HORIZONTAL SCAN LINE-9 */
     91    case 't':
     92        return 0x251C;          /* BOX DRAWINGS LIGHT VERTICAL AND RIGHT */
     93    case 'u':
     94        return 0x2524;          /* BOX DRAWINGS LIGHT VERTICAL AND LEFT */
     95    case 'v':
     96        return 0x2534;          /* BOX DRAWINGS LIGHT UP AND HORIZONTAL */
     97    case 'w':
     98        return 0x252C;          /* BOX DRAWINGS LIGHT DOWN AND HORIZONTAL */
     99    case 'x':
     100        return 0x2502;          /* BOX DRAWINGS LIGHT VERTICAL */
     101    case 'y':
     102        return 0x2264;          /* LESS-THAN OR EQUAL TO */
     103    case 'z':
     104        return 0x2265;          /* GREATER-THAN OR EQUAL TO */
     105    case '{':
     106        return 0x03C0;          /* GREEK SMALL LETTER PI */
     107    case '|':
     108        return 0x2260;          /* NOT EQUAL TO */
     109    case '}':
     110        return 0x00A3;          /* POUND SIGN */
     111    case '~':
     112        return 0x00B7;          /* MIDDLE DOT */
    76113    default:
    77114        return uc;
     
    88125                            unsigned int, unsigned int const *);
    89126
    90 long int import_term(struct screen_list *screen_list, struct screen *sc, void const *data, unsigned int size)
     127long int import_term(struct screen_list *screen_list, struct screen *sc,
     128                     void const *data, unsigned int size)
    91129{
    92     unsigned char const *buffer = (unsigned char const*)data;
    93     unsigned int i, j, k,skip, dummy = 0;
     130    unsigned char const *buffer = (unsigned char const *)data;
     131    unsigned int i, j, k, skip, dummy = 0;
    94132    unsigned int width, height, top, bottom;
    95133    uint32_t savedattr;
     
    102140    top = 1;
    103141    bottom = height;
    104    
    105     if(!sc->init)
     142
     143    if (!sc->init)
    106144    {
    107145        sc->dfg = CACA_LIGHTGRAY;
     
    118156    }
    119157
    120     for(i = 0; i < size; i += skip)
     158    for (i = 0; i < size; i += skip)
    121159    {
    122160        uint32_t ch = 0;
     
    125163        skip = 1;
    126164
    127         if(buffer[i] == '\r')
     165        if (buffer[i] == '\r')
    128166        {
    129167            x = 0;
    130168        }
    131169
    132         else if(buffer[i] == '\n')
     170        else if (buffer[i] == '\n')
    133171        {
    134172            x = 0;
    135173            y++;
    136174        }
    137         else if(buffer[i] == '\a')
    138         {
    139             if(!sc->bell)
     175        else if (buffer[i] == '\a')
     176        {
     177            if (!sc->bell)
    140178                screen_list->in_bell++;
    141179            sc->bell = 1;
    142180        }
    143181
    144         else if(buffer[i] == '\t')
     182        else if (buffer[i] == '\t')
    145183        {
    146184            x = (x + 7) & ~7;
    147185        }
    148186
    149         else if(buffer[i] == '\x08')
    150         {
    151             if(x > 0)
     187        else if (buffer[i] == '\x08')
     188        {
     189            if (x > 0)
    152190                x--;
    153191        }
    154192
    155         else if(buffer[i] == '\x0e')
    156         {
    157             /* Shift Out (Ctrl-N) -> Switch to
    158              * Alternate Character Set: invokes
    159              * the G1 character set. */
     193        else if (buffer[i] == '\x0e')
     194        {
     195            /* Shift Out (Ctrl-N) -> Switch to Alternate Character Set:
     196               invokes the G1 character set. */
    160197            sc->conv_state.glr[0] = 1;
    161198        }
    162199
    163         else if(buffer[i] == '\x0f')
    164         {
    165             /* Shift In (Ctrl-O) -> Switch to
    166              * Standard Character Set: invokes
    167              * the G0 character set. */
     200        else if (buffer[i] == '\x0f')
     201        {
     202            /* Shift In (Ctrl-O) -> Switch to Standard Character Set: invokes
     203               the G0 character set. */
    168204            sc->conv_state.glr[0] = 0;
    169205        }
    170206
    171207        /* If there are not enough characters to parse the escape sequence,
    172          * wait until the next try. We require 3. */
    173         else if(buffer[i] == '\033' && i + 2 >= size)
     208           wait until the next try. We require 3. */
     209        else if (buffer[i] == '\033' && i + 2 >= size)
    174210            break;
    175211
    176         /* Single Shift Select of G2 Character Set (SS2: 0x8e):
    177          * affects next character only */
    178         else if(buffer[i] == '\033' && buffer[i + 1] == 'N')
     212        /* Single Shift Select of G2 Character Set (SS2: 0x8e): affects next
     213           character only */
     214        else if (buffer[i] == '\033' && buffer[i + 1] == 'N')
    179215        {
    180216            sc->conv_state.ss = 2;
     
    182218        }
    183219        /* Reverse Index (RI) go up one line, reverse scroll if necessary */
    184         else if(buffer[i] == '\033' && buffer[i + 1] == 'M')
    185         {
    186             /* FIXME : not sure about the meaning of 'go up one line' and
    187              * 'if necessary' words. Implemented as a scroller only. */
    188             for(j = height; j > 0; j--)
    189             {
    190                 for(k = 0; k < width; k++)
    191                 {
    192                         caca_put_char(sc->cv, k, j, caca_get_char(sc->cv, k, j-1));
    193                         caca_put_attr(sc->cv, k, j, caca_get_attr(sc->cv, k, j-1));
    194                 }
     220        else if (buffer[i] == '\033' && buffer[i + 1] == 'M')
     221        {
     222            /* FIXME : not sure about the meaning of 'go up one line' and 'if
     223               necessary' words. Implemented as a scroller only. */
     224            for (j = height; j > 0; j--)
     225            {
     226                for (k = 0; k < width; k++)
     227                {
     228                    caca_put_char(sc->cv, k, j,
     229                                  caca_get_char(sc->cv, k, j - 1));
     230                    caca_put_attr(sc->cv, k, j,
     231                                  caca_get_attr(sc->cv, k, j - 1));
     232                }
    195233            }
    196234            caca_draw_line(sc->cv, 0, 0, width, 0, ' ');
    197235            skip += 1;
    198236        }
    199        
    200         /* Single Shift Select of G3 Character Set (SS2: 0x8f):
    201          * affects next character only */
    202         else if(buffer[i] == '\033' && buffer[i + 1] == 'O')
     237
     238        /* Single Shift Select of G3 Character Set (SS2: 0x8f): affects next
     239           character only */
     240        else if (buffer[i] == '\033' && buffer[i + 1] == 'O')
    203241        {
    204242            sc->conv_state.ss = 3;
     
    207245
    208246        /* LOCKING-SHIFT TWO (LS2), ISO 2022, ECMA-48 (1986), ISO 6429 : 1988 */
    209         else if(buffer[i] == '\033' && buffer[i + 1] == 'n')
     247        else if (buffer[i] == '\033' && buffer[i + 1] == 'n')
    210248        {
    211249            sc->conv_state.glr[0] = 2;
     
    213251        }
    214252
    215         /* LOCKING-SHIFT THREE (LS3) ISO 2022, ECMA-48 (1986), ISO 6429 : 1988 */
    216         else if(buffer[i] == '\033' && buffer[i + 1] == 'o')
     253        /* LOCKING-SHIFT THREE (LS3) ISO 2022, ECMA-48 (1986), ISO 6429 : 1988
     254         */
     255        else if (buffer[i] == '\033' && buffer[i + 1] == 'o')
    217256        {
    218257            sc->conv_state.glr[0] = 3;
     
    221260
    222261        /* RESET TO INITIAL STATE (RIS), ECMA-48 (1986), ISO 6429 : 1988 */
    223         else if(buffer[i] == '\033' && buffer[i + 1] == 'c')
     262        else if (buffer[i] == '\033' && buffer[i + 1] == 'c')
    224263        {
    225264            sc->dfg = CACA_DEFAULT;
     
    234273        }
    235274
    236         /* Coding Method Delimiter (CMD), ECMA-48 (1991), ISO/IEC 6429:1992 (ISO IR 189) */
    237         else if(buffer[i] == '\033' && buffer[i + 1] == 'd')
     275        /* Coding Method Delimiter (CMD), ECMA-48 (1991), ISO/IEC 6429:1992
     276           (ISO IR 189) */
     277        else if (buffer[i] == '\033' && buffer[i + 1] == 'd')
    238278        {
    239279            reset_conv_state(sc);
     
    241281        }
    242282
    243         /* GZDM4, G0-Designators, multi, 94^n chars [grandfathered short form from ISO 2022:1986] */
    244         else if(buffer[i] == '\033' && buffer[i + 1] == '$' && (buffer[i + 2] >= '@') && (buffer[i + 2] <= 'C'))
     283        /* GZDM4, G0-Designators, multi, 94^n chars [grandfathered short form
     284           from ISO 2022:1986] */
     285        else if (buffer[i] == '\033' && buffer[i + 1] == '$'
     286                 && (buffer[i + 2] >= '@') && (buffer[i + 2] <= 'C'))
    245287        {
    246288            sc->conv_state.gn[0] = LITERAL2CHAR('$', buffer[i + 2]);
     
    248290        }
    249291
    250         /* GnDMx Gn-Designators, 9x^n chars; need one more char to distinguish these */
    251         else if(buffer[i] == '\033' && buffer[i + 1] == '$' && (i + 3 >= size))
     292        /* GnDMx Gn-Designators, 9x^n chars; need one more char to distinguish
     293           these */
     294        else if (buffer[i] == '\033' && buffer[i + 1] == '$'
     295                 && (i + 3 >= size))
    252296            break;
    253297
    254298        /* GZD4 G0-Designator, 94 chars */
    255         else if(buffer[i] == '\033' && buffer[i + 1] == '(')
     299        else if (buffer[i] == '\033' && buffer[i + 1] == '(')
    256300        {
    257301            sc->conv_state.gn[0] = buffer[i + 2];
     
    260304
    261305        /* G1D4 G1-Designator, 94 chars */
    262         else if(buffer[i] == '\033' && buffer[i + 1] == ')')
     306        else if (buffer[i] == '\033' && buffer[i + 1] == ')')
    263307        {
    264308            sc->conv_state.gn[1] = buffer[i + 2];
     
    267311
    268312        /* G2D4 G2-Designator, 94 chars */
    269         else if(buffer[i] == '\033' && buffer[i + 1] == '*')
     313        else if (buffer[i] == '\033' && buffer[i + 1] == '*')
    270314        {
    271315            sc->conv_state.gn[2] = buffer[i + 2];
     
    274318
    275319        /* G3D4 G3-Designator, 94 chars */
    276         else if(buffer[i] == '\033' && buffer[i + 1] == '+')
     320        else if (buffer[i] == '\033' && buffer[i + 1] == '+')
    277321        {
    278322            sc->conv_state.gn[3] = buffer[i + 2];
     
    281325
    282326        /* G2D6 G2-Designator, 96 chars */
    283         else if(buffer[i] == '\033' && buffer[i + 1] == '.')
     327        else if (buffer[i] == '\033' && buffer[i + 1] == '.')
    284328        {
    285329            sc->conv_state.gn[2] = LITERAL2CHAR('.', buffer[i + 2]);
     
    288332
    289333        /* G3D6 G3-Designator, 96 chars */
    290         else if(buffer[i] == '\033' && buffer[i + 1] == '/')
     334        else if (buffer[i] == '\033' && buffer[i + 1] == '/')
    291335        {
    292336            sc->conv_state.gn[3] = LITERAL2CHAR('.', buffer[i + 2]);
     
    295339
    296340        /* GZDM4 G0-Designator, 94^n chars */
    297         else if(buffer[i] == '\033' && buffer[i + 1] == '$' && buffer[i + 2] == '(')
     341        else if (buffer[i] == '\033' && buffer[i + 1] == '$'
     342                 && buffer[i + 2] == '(')
    298343        {
    299344            sc->conv_state.gn[0] = LITERAL2CHAR('$', buffer[i + 3]);
     
    302347
    303348        /* G1DM4 G1-Designator, 94^n chars */
    304         else if(buffer[i] == '\033' && buffer[i + 1] == '$' && buffer[i + 2] == ')')
     349        else if (buffer[i] == '\033' && buffer[i + 1] == '$'
     350                 && buffer[i + 2] == ')')
    305351        {
    306352            sc->conv_state.gn[1] = LITERAL2CHAR('$', buffer[i + 3]);
     
    309355
    310356        /* G2DM4 G2-Designator, 94^n chars */
    311         else if(buffer[i] == '\033' && buffer[i + 1] == '$' && buffer[i + 2] == '*')
     357        else if (buffer[i] == '\033' && buffer[i + 1] == '$'
     358                 && buffer[i + 2] == '*')
    312359        {
    313360            sc->conv_state.gn[2] = LITERAL2CHAR('$', buffer[i + 3]);
     
    316363
    317364        /* G3DM4 G3-Designator, 94^n chars */
    318         else if(buffer[i] == '\033' && buffer[i + 1] == '$' && buffer[i + 2] == '+')
     365        else if (buffer[i] == '\033' && buffer[i + 1] == '$'
     366                 && buffer[i + 2] == '+')
    319367        {
    320368            sc->conv_state.gn[3] = LITERAL2CHAR('$', buffer[i + 3]);
     
    323371
    324372        /* G2DM6 G2-Designator, 96^n chars */
    325         else if(buffer[i] == '\033' && buffer[i + 1] == '$' && buffer[i + 2] == '.')
     373        else if (buffer[i] == '\033' && buffer[i + 1] == '$'
     374                 && buffer[i + 2] == '.')
    326375        {
    327376            sc->conv_state.gn[2] = LITERAL3CHAR('$', '.', buffer[i + 3]);
     
    330379
    331380        /* G3DM6 G3-Designator, 96^n chars */
    332         else if(buffer[i] == '\033' && buffer[i + 1] == '$' && buffer[i + 2] == '/')
     381        else if (buffer[i] == '\033' && buffer[i + 1] == '$'
     382                 && buffer[i + 2] == '/')
    333383        {
    334384            sc->conv_state.gn[3] = LITERAL3CHAR('$', '.', buffer[i + 3]);
     
    337387
    338388        /* Interpret escape commands, as per Standard ECMA-48 "Control
    339          * Functions for Coded Character Sets", 5.4. Control sequences. */
    340         else if(buffer[i] == '\033' && buffer[i + 1] == '[')
     389           Functions for Coded Character Sets", 5.4. Control sequences. */
     390        else if (buffer[i] == '\033' && buffer[i + 1] == '[')
    341391        {
    342392            unsigned int argc = 0, argv[101];
     
    344394
    345395
    346         /* Compute offsets to parameter bytes, intermediate bytes and
    347          * to the final byte. Only the final byte is mandatory, there
    348          * can be zero of the others.
    349          * 0  param=2             inter                 final           final+1
    350          * +-----+------------------+---------------------+-----------------+
    351          * | CSI | parameter bytes  | intermediate bytes  |   final byte    |
    352          * |     |   0x30 - 0x3f    |    0x20 - 0x2f      |   0x40 - 0x7e   |
    353          * | ^[[ | 0123456789:;<=>? | SPC !"#$%&'()*+,-./ | azAZ@[\]^_`{|}~ |
    354          * +-----+------------------+---------------------+-----------------+
    355          */
     396            /* Compute offsets to parameter bytes, intermediate bytes and to
     397               the final byte. Only the final byte is mandatory, there can be
     398               zero of the others. 0 param=2 inter final final+1
     399               +-----+------------------+---------------------+-----------------+
     400               | CSI | parameter bytes | intermediate bytes | final byte | | |
     401               0x30 - 0x3f | 0x20 - 0x2f | 0x40 - 0x7e | | ^[[ | 0123456789:;<=>?
     402               | SPC !"#$%&'()*+,-./ | azAZ@[\]^_`{|}~ |
     403               +-----+------------------+---------------------+-----------------+ */
    356404            param = 2;
    357405
    358             for(inter = param; i + inter < size; inter++)
    359                 if(buffer[i + inter] < 0x30 || buffer[i + inter] > 0x3f)
     406            for (inter = param; i + inter < size; inter++)
     407                if (buffer[i + inter] < 0x30 || buffer[i + inter] > 0x3f)
    360408                    break;
    361409
    362             for(final = inter; i + final < size; final++)
    363                 if(buffer[i + final] < 0x20 || buffer[i + final] > 0x2f)
     410            for (final = inter; i + final < size; final++)
     411                if (buffer[i + final] < 0x20 || buffer[i + final] > 0x2f)
    364412                    break;
    365413
    366             if(i + final >= size
     414            if (i + final >= size
    367415                || buffer[i + final] < 0x40 || buffer[i + final] > 0x7e)
    368                 break; /* Invalid Final Byte */
     416                break;          /* Invalid Final Byte */
    369417
    370418            skip += final;
    371419
    372420            /* Sanity checks */
    373             if(param < inter && buffer[i + param] >= 0x3c)
     421            if (param < inter && buffer[i + param] >= 0x3c)
    374422            {
    375423                /* Private sequence, only parse what we know */
    376424                debug("ansi import: private sequence \"^[[%.*s\"",
    377425                      final - param + 1, buffer + i + param);
    378                 continue; /* Private sequence, skip it entirely */
    379             }
    380 
    381             if(final - param > 100)
    382                 continue; /* Suspiciously long sequence, skip it */
     426                continue;       /* Private sequence, skip it entirely */
     427            }
     428
     429            if (final - param > 100)
     430                continue;       /* Suspiciously long sequence, skip it */
    383431
    384432            /* Parse parameter bytes as per ECMA-48 5.4.2: Parameter string
    385              * format */
    386             if(param < inter)
     433               format */
     434            if (param < inter)
    387435            {
    388436                argv[0] = 0;
    389                 for(j = param; j < inter; j++)
    390                 {
    391                     if(buffer[i + j] == ';')
     437                for (j = param; j < inter; j++)
     438                {
     439                    if (buffer[i + j] == ';')
    392440                        argv[++argc] = 0;
    393                     else if(buffer[i + j] >= '0' && buffer[i + j] <= '9')
     441                    else if (buffer[i + j] >= '0' && buffer[i + j] <= '9')
    394442                        argv[argc] = 10 * argv[argc] + (buffer[i + j] - '0');
    395443                }
     
    398446
    399447            /* Interpret final byte. The code representations are given in
    400              * ECMA-48 5.4: Control sequences, and the code definitions are
    401              * given in ECMA-48 8.3: Definition of control functions. */
     448               ECMA-48 5.4: Control sequences, and the code definitions are
     449               given in ECMA-48 8.3: Definition of control functions. */
    402450            debug("ansi import: command '%c'", buffer[i + final]);
    403             switch(buffer[i + final])
    404             {
    405             case 'A': /* CUU (0x41) - Cursor Up */
     451            switch (buffer[i + final])
     452            {
     453            case 'A':          /* CUU (0x41) - Cursor Up */
    406454                y -= argc ? argv[0] : 1;
    407                 if(y < 0)
     455                if (y < 0)
    408456                    y = 0;
    409457                break;
    410             case 'B': /* CUD (0x42) - Cursor Down */
     458            case 'B':          /* CUD (0x42) - Cursor Down */
    411459                y += argc ? argv[0] : 1;
    412460                break;
    413             case 'C': /* CUF (0x43) - Cursor Right */
     461            case 'C':          /* CUF (0x43) - Cursor Right */
    414462                x += argc ? argv[0] : 1;
    415463                break;
    416             case 'D': /* CUB (0x44) - Cursor Left */
     464            case 'D':          /* CUB (0x44) - Cursor Left */
    417465                x -= argc ? argv[0] : 1;
    418                 if(x < 0)
     466                if (x < 0)
    419467                    x = 0;
    420468                break;
    421             case 'G': /* CHA (0x47) - Cursor Character Absolute */
     469            case 'G':          /* CHA (0x47) - Cursor Character Absolute */
    422470                x = (argc && argv[0] > 0) ? argv[0] - 1 : 0;
    423471                break;
    424             case 'H': /* CUP (0x48) - Cursor Position */
     472            case 'H':          /* CUP (0x48) - Cursor Position */
    425473                x = (argc > 1 && argv[1] > 0) ? argv[1] - 1 : 0;
    426474                y = (argc > 0 && argv[0] > 0) ? argv[0] - 1 : 0;
    427475                break;
    428             case 'J': /* ED (0x4a) - Erase In Page */
     476            case 'J':          /* ED (0x4a) - Erase In Page */
    429477                savedattr = caca_get_attr(sc->cv, -1, -1);
    430478                caca_set_attr(sc->cv, sc->clearattr);
    431                 if(!argc || argv[0] == 0)
     479                if (!argc || argv[0] == 0)
    432480                {
    433481                    caca_draw_line(sc->cv, x, y, width, y, ' ');
    434                     caca_fill_box(sc->cv, 0, y + 1, width - 1, height - 1, ' ');
    435                 }
    436                 else if(argv[0] == 1)
     482                    caca_fill_box(sc->cv, 0, y + 1, width - 1, height - 1,
     483                                  ' ');
     484                }
     485                else if (argv[0] == 1)
    437486                {
    438487                    caca_fill_box(sc->cv, 0, 0, width - 1, y - 1, ' ');
    439488                    caca_draw_line(sc->cv, 0, y, x, y, ' ');
    440489                }
    441                 else if(argv[0] == 2)
    442                 {
    443                     //x = y = 0;
     490                else if (argv[0] == 2)
     491                {
     492                    // x = y = 0;
    444493                    caca_fill_box(sc->cv, 0, 0, width, height, ' ');
    445494                }
    446495                caca_set_attr(sc->cv, savedattr);
    447496                break;
    448             case 'K': /* EL (0x4b) - Erase In Line */
    449                 if(!argc || argv[0] == 0)
     497            case 'K':          /* EL (0x4b) - Erase In Line */
     498                if (!argc || argv[0] == 0)
    450499                {
    451500                    caca_draw_line(sc->cv, x, y, width, y, ' ');
    452501                }
    453                 else if(argv[0] == 1)
     502                else if (argv[0] == 1)
    454503                {
    455504                    caca_draw_line(sc->cv, 0, y, x, y, ' ');
    456505                }
    457                 else if(argv[0] == 2)
    458                 {
    459                     if((unsigned int)x < width)
     506                else if (argv[0] == 2)
     507                {
     508                    if ((unsigned int)x < width)
    460509                        caca_draw_line(sc->cv, x, y, width - 1, y, ' ');
    461510                }
    462                 //x = width;
    463                 break;
    464             case 'L': /* IL - Insert line */
     511                // x = width;
     512                break;
     513            case 'L':          /* IL - Insert line */
    465514                {
    466515                    unsigned int nb_lines = argc ? argv[0] : 1;
    467516                    debug("IL %d %d", argc, nb_lines);
    468                     for(j = bottom - 1; j >= (unsigned int)y + nb_lines; j--)
     517                    for (j = bottom - 1; j >= (unsigned int)y + nb_lines; j--)
    469518                    {
    470                         for(k = 0; k < width; k++)
     519                        for (k = 0; k < width; k++)
    471520                        {
    472                             caca_put_char(sc->cv, k, j, caca_get_char(sc->cv, k, j - nb_lines));
    473                             caca_put_attr(sc->cv, k, j, caca_get_attr(sc->cv, k, j - nb_lines));
    474                          }
    475                         caca_draw_line(sc->cv, 0, j - nb_lines, width, j - nb_lines, ' ');
     521                            caca_put_char(sc->cv, k, j,
     522                                          caca_get_char(sc->cv, k,
     523                                                        j - nb_lines));
     524                            caca_put_attr(sc->cv, k, j,
     525                                          caca_get_attr(sc->cv, k,
     526                                                        j - nb_lines));
     527                        }
     528                        caca_draw_line(sc->cv, 0, j - nb_lines, width,
     529                                       j - nb_lines, ' ');
    476530                    }
    477531                }
    478532                break;
    479             case 'P': /* DCH (0x50) - Delete Character */
    480                 if(!argc || argv[0] == 0)
    481                     argv[0] = 1; /* echo -ne 'foobar\r\e[0P\n' */
     533            case 'P':          /* DCH (0x50) - Delete Character */
     534                if (!argc || argv[0] == 0)
     535                    argv[0] = 1;        /* echo -ne 'foobar\r\e[0P\n' */
    482536                /* Jylam : Start from x, not 0 */
    483                 for(j = x; (unsigned int)(j + argv[0]) < width; j++)
     537                for (j = x; (unsigned int)(j + argv[0]) < width; j++)
    484538                {
    485539                    caca_put_char(sc->cv, j, y,
    486                                    caca_get_char(sc->cv, j + argv[0], y));
     540                                  caca_get_char(sc->cv, j + argv[0], y));
    487541                    caca_put_attr(sc->cv, j, y,
    488                                    caca_get_attr(sc->cv, j + argv[0], y));
    489                 }
    490                 break; /* Jylam: this one was missing I guess */
     542                                  caca_get_attr(sc->cv, j + argv[0], y));
     543                }
     544                break;          /* Jylam: this one was missing I guess */
    491545#if 0
    492546                savedattr = caca_get_attr(sc->cv, -1, -1);
    493547                caca_set_attr(sc->cv, sc->clearattr);
    494                 for( ; (unsigned int)j < width; j++)
     548                for (; (unsigned int)j < width; j++)
    495549                    caca_put_char(sc->cv, j, y, ' ');
    496550                caca_set_attr(sc->cv, savedattr);
    497551#endif
    498             case 'X': /* ECH (0x58) - Erase Character */
    499                 if(argc && argv[0])
     552            case 'X':          /* ECH (0x58) - Erase Character */
     553                if (argc && argv[0])
    500554                {
    501555                    savedattr = caca_get_attr(sc->cv, -1, -1);
     
    504558                    caca_set_attr(sc->cv, savedattr);
    505559                }
    506             case 'd': /* VPA (0x64) - Line Position Absolute */
     560            case 'd':          /* VPA (0x64) - Line Position Absolute */
    507561                y = (argc && argv[0] > 0) ? argv[0] - 1 : 0;
    508562                break;
    509             case 'f': /* HVP (0x66) - Character And Line Position */
     563            case 'f':          /* HVP (0x66) - Character And Line Position */
    510564                x = (argc > 1 && argv[1] > 0) ? argv[1] - 1 : 0;
    511565                y = (argc > 0 && argv[0] > 0) ? argv[0] - 1 : 0;
    512566                break;
    513             case 'r': /* FIXME */
    514                 if(argc == 2) /* DCSTBM - Set top and bottom margin */
     567            case 'r':          /* FIXME */
     568                if (argc == 2) /* DCSTBM - Set top and bottom margin */
    515569                {
    516570                    debug("DCSTBM %d %d", argv[0], argv[1]);
     
    521575                    debug("ansi import: command r with %d params", argc);
    522576                break;
    523             case 'h': /* SM (0x68) - FIXME */
     577            case 'h':          /* SM (0x68) - FIXME */
    524578                debug("ansi import: set mode %i", argc ? (int)argv[0] : -1);
    525579                break;
    526             case 'l': /* RM (0x6c) - FIXME */
     580            case 'l':          /* RM (0x6c) - FIXME */
    527581                debug("ansi import: reset mode %i", argc ? (int)argv[0] : -1);
    528582                break;
    529             case 'm': /* SGR (0x6d) - Select Graphic Rendition */
    530                 if(argc)
     583            case 'm':          /* SGR (0x6d) - Select Graphic Rendition */
     584                if (argc)
    531585                    ansi_parse_grcm(sc, argc, argv);
    532586                else
    533587                    ansi_parse_grcm(sc, 1, &dummy);
    534588                break;
    535             case 's': /* Private (save cursor position) */
     589            case 's':          /* Private (save cursor position) */
    536590                save_x = x;
    537591                save_y = y;
    538592                break;
    539             case 'u': /* Private (reload cursor position) */
     593            case 'u':          /* Private (reload cursor position) */
    540594                x = save_x;
    541595                y = save_y;
     
    549603
    550604        /* Parse OSC stuff. */
    551         else if(buffer[i] == '\033' && buffer[i + 1] == ']')
     605        else if (buffer[i] == '\033' && buffer[i + 1] == ']')
    552606        {
    553607            char *string;
     
    555609            unsigned int mode = 2, semicolon, final;
    556610
    557             for(semicolon = mode; i + semicolon < size; semicolon++)
    558             {
    559                 if(buffer[i + semicolon] < '0' || buffer[i + semicolon] > '9')
     611            for (semicolon = mode; i + semicolon < size; semicolon++)
     612            {
     613                if (buffer[i + semicolon] < '0' || buffer[i + semicolon] > '9')
    560614                    break;
    561615                command = 10 * command + (buffer[i + semicolon] - '0');
    562616            }
    563617
    564             if(i + semicolon >= size || buffer[i + semicolon] != ';')
    565                 break; /* Invalid Mode */
    566 
    567             for(final = semicolon + 1; i + final < size; final++)
    568                 if(buffer[i + final] < 0x20)
     618            if (i + semicolon >= size || buffer[i + semicolon] != ';')
     619                break;          /* Invalid Mode */
     620
     621            for (final = semicolon + 1; i + final < size; final++)
     622                if (buffer[i + final] < 0x20)
    569623                    break;
    570624
    571             if(i + final >= size || buffer[i + final] != '\a')
    572                 break; /* Not enough data or no bell found */
    573                 /* FIXME: XTerm also reacts to <ESC><backslash> and <ST> */
    574                 /* FIXME: differenciate between not enough data (try again)
    575                  *        and invalid data (print shit) */
     625            if (i + final >= size || buffer[i + final] != '\a')
     626                break;          /* Not enough data or no bell found */
     627            /* FIXME: XTerm also reacts to <ESC><backslash> and <ST> */
     628            /* FIXME: differenciate between not enough data (try again) and
     629               invalid data (print shit) */
    576630
    577631            skip += final;
    578632
    579633            string = malloc(final - (semicolon + 1) + 1);
    580             memcpy(string, buffer + i + (semicolon + 1), final - (semicolon + 1));
     634            memcpy(string, buffer + i + (semicolon + 1),
     635                   final - (semicolon + 1));
    581636            string[final - (semicolon + 1)] = '\0';
    582637            debug("ansi import: got OSC command %i string '%s'", command,
    583638                  string);
    584             if(command == 0 || command == 2)
    585             {
    586                 if(sc->title)
     639            if (command == 0 || command == 2)
     640            {
     641                if (sc->title)
    587642                    free(sc->title);
    588643                sc->title = string;
     
    597652            size_t bytes;
    598653
    599             if(i + 6 < size)
     654            if (i + 6 < size)
    600655            {
    601656                ch = caca_utf8_to_utf32((char const *)(buffer + i), &bytes);
    602             } else
     657            }
     658            else
    603659            {
    604660                /* Add a trailing zero to what we're going to read */
     
    609665            }
    610666
    611             if(!bytes)
     667            if (!bytes)
    612668            {
    613669                /* If the Unicode is invalid, assume it was latin1. */
     
    617673
    618674            /* very incomplete ISO-2022 implementation tailored to DEC ACS */
    619             if(sc->conv_state.cs == '@')
     675            if (sc->conv_state.cs == '@')
    620676            {
    621677                if (((ch > ' ') && (ch <= '~'))
    622678                    &&
    623                     (sc->conv_state.gn[sc->conv_state.ss ? sc->conv_state.gn[sc->conv_state.ss] : sc->conv_state.glr[0]] == '0'))
     679                    (sc->conv_state.
     680                     gn[sc->conv_state.ss ? sc->conv_state.
     681                        gn[sc->conv_state.ss] : sc->conv_state.glr[0]] == '0'))
    624682                {
    625683                    ch = dec_acs(ch);
    626684                }
    627685                else if (((ch > 0x80) && (ch < 0xff))
    628                          &&
    629                          (sc->conv_state.gn[sc->conv_state.glr[1]] == '0'))
     686                         && (sc->conv_state.gn[sc->conv_state.glr[1]] == '0'))
    630687                {
    631688                    ch = dec_acs(ch + ' ' - 0x80);
    632689                }
    633690            }
    634             sc->conv_state.ss = 0; /* no single-shift (GL) */
     691            sc->conv_state.ss = 0;      /* no single-shift (GL) */
    635692
    636693            wch = caca_utf32_is_fullwidth(ch) ? 2 : 1;
    637            
     694
    638695            skip += bytes - 1;
    639696        }
    640697
    641698        /* Wrap long lines or grow horizontally */
    642         while((unsigned int)x + wch > width)
     699        while ((unsigned int)x + wch > width)
    643700        {
    644701            x -= width;
     
    647704
    648705        /* Scroll or grow vertically */
    649         if((unsigned int)y >= bottom)
     706        if ((unsigned int)y >= bottom)
    650707        {
    651708            int lines = (y - bottom) + 1;
     
    653710            savedattr = caca_get_attr(sc->cv, -1, -1);
    654711
    655             for(j = top - 1; j + lines < bottom; j++)
    656             {
    657                 for(k = 0; k < width; k++)
    658                 {
    659                     caca_put_char(sc->cv, k, j, caca_get_char(sc->cv, k, j + lines));
    660                     caca_put_attr(sc->cv, k, j, caca_get_attr(sc->cv, k, j + lines));
     712            for (j = top - 1; j + lines < bottom; j++)
     713            {
     714                for (k = 0; k < width; k++)
     715                {
     716                    caca_put_char(sc->cv, k, j,
     717                                  caca_get_char(sc->cv, k, j + lines));
     718                    caca_put_attr(sc->cv, k, j,
     719                                  caca_get_attr(sc->cv, k, j + lines));
    661720                }
    662721            }
    663722            caca_set_attr(sc->cv, sc->clearattr);
    664             caca_fill_box(sc->cv, 0, bottom - lines,
    665                                    width, bottom - 1, ' ');
     723            caca_fill_box(sc->cv, 0, bottom - lines, width, bottom - 1, ' ');
    666724            y -= lines;
    667725            caca_set_attr(sc->cv, savedattr);
     
    669727
    670728        /* Now paste our character, if any */
    671         if(wch)
     729        if (wch)
    672730        {
    673731            caca_put_char(sc->cv, x, y, ch);
     
    678736    caca_gotoxy(sc->cv, x, y);
    679737
    680     if(i)
     738    if (i)
    681739        sc->changed = 1;
    682740    return i;
    683741}
    684742
    685 /* Coding Method Delimiter (CMD), ECMA-48 (1991), ISO/IEC 6429:1992 (ISO IR 189) */
     743/* Coding Method Delimiter (CMD), ECMA-48 (1991), ISO/IEC 6429:1992 (ISO IR
     744   189) */
    686745
    687746static void reset_conv_state(struct screen *sc)
    688747{
    689     sc->conv_state.cs = '@'; /* ISO-2022 coding system */
     748    sc->conv_state.cs = '@';    /* ISO-2022 coding system */
    690749    sc->conv_state.cn[0] = '@'; /* ISO 646 C0 control charset */
    691750    sc->conv_state.cn[1] = 'C'; /* ISO 6429-1983 C1 control charset */
    692     sc->conv_state.glr[0] = 0; /* G0 in GL */
    693     sc->conv_state.glr[1] = 2; /* G2 in GR */
     751    sc->conv_state.glr[0] = 0;  /* G0 in GL */
     752    sc->conv_state.glr[1] = 2;  /* G2 in GR */
    694753    sc->conv_state.gn[0] = 'B'; /* US-ASCII G0 charset */
    695754    sc->conv_state.gn[1] = '0'; /* DEC ACS G1 charset */
    696     sc->conv_state.gn[2] = LITERAL2CHAR('.', 'A'); /* ISO 8859-1 G2 charset */
    697     sc->conv_state.gn[3] = LITERAL2CHAR('.', 'A'); /* ISO 8859-1 G3 charset */
    698     sc->conv_state.ss = 0; /* no single-shift (GL) */
     755    sc->conv_state.gn[2] = LITERAL2CHAR('.', 'A');      /* ISO 8859-1 G2
     756                                                           charset */
     757    sc->conv_state.gn[3] = LITERAL2CHAR('.', 'A');      /* ISO 8859-1 G3
     758                                                           charset */
     759    sc->conv_state.ss = 0;      /* no single-shift (GL) */
    699760    sc->conv_state.ctrl8bit = 1;
    700761}
     
    705766                            unsigned int argc, unsigned int const *argv)
    706767{
    707     static uint8_t const ansi2caca[] =
    708     {
     768    static uint8_t const ansi2caca[] = {
    709769        CACA_BLACK, CACA_RED, CACA_GREEN, CACA_BROWN,
    710770        CACA_BLUE, CACA_MAGENTA, CACA_CYAN, CACA_LIGHTGRAY
     
    712772
    713773    unsigned int j;
    714     uint8_t efg, ebg; /* Effective (libcaca) fg/bg */
    715 
    716     for(j = 0; j < argc; j++)
     774    uint8_t efg, ebg;           /* Effective (libcaca) fg/bg */
     775
     776    for (j = 0; j < argc; j++)
    717777    {
    718778        /* Defined in ECMA-48 8.3.117: SGR - SELECT GRAPHIC RENDITION */
    719         if(argv[j] >= 30 && argv[j] <= 37)
     779        if (argv[j] >= 30 && argv[j] <= 37)
    720780            sc->fg = ansi2caca[argv[j] - 30];
    721         else if(argv[j] >= 40 && argv[j] <= 47)
     781        else if (argv[j] >= 40 && argv[j] <= 47)
    722782            sc->bg = ansi2caca[argv[j] - 40];
    723         else if(argv[j] >= 90 && argv[j] <= 97)
     783        else if (argv[j] >= 90 && argv[j] <= 97)
    724784            sc->fg = ansi2caca[argv[j] - 90] + 8;
    725         else if(argv[j] >= 100 && argv[j] <= 107)
     785        else if (argv[j] >= 100 && argv[j] <= 107)
    726786            sc->bg = ansi2caca[argv[j] - 100] + 8;
    727         else switch(argv[j])
    728         {
    729         case 0: /* default rendition */
    730             sc->fg = sc->dfg;
    731             sc->bg = sc->dbg;
    732             sc->bold = sc->blink = sc->italics = sc->negative
    733              = sc->concealed = sc->underline = sc->faint = sc->strike
    734              = sc->proportional = 0;
    735             break;
    736         case 1: /* bold or increased intensity */
    737             sc->bold = 1;
    738             break;
    739         case 2: /* faint, decreased intensity or second colour */
    740             sc->faint = 1;
    741             break;
    742         case 3: /* italicized */
    743             sc->italics = 1;
    744             break;
    745         case 4: /* singly underlined */
    746             sc->underline = 1;
    747             break;
    748         case 5: /* slowly blinking (less then 150 per minute) */
    749         case 6: /* rapidly blinking (150 per minute or more) */
    750             sc->blink = 1;
    751             break;
    752         case 7: /* negative image */
    753             sc->negative = 1;
    754             break;
    755         case 8: /* concealed characters */
    756             sc->concealed = 1;
    757             break;
    758         case 9: /* crossed-out (characters still legible but marked as to be
    759                  * deleted */
    760             sc->strike = 1;
    761             break;
    762         case 21: /* doubly underlined */
    763             sc->underline = 1;
    764             break;
    765         case 22: /* normal colour or normal intensity (neither bold nor
    766                   * faint) */
    767             sc->bold = sc->faint = 0;
    768             break;
    769         case 23: /* not italicized, not fraktur */
    770             sc->italics = 0;
    771             break;
    772         case 24: /* not underlined (neither singly nor doubly) */
    773             sc->underline = 0;
    774             break;
    775         case 25: /* steady (not blinking) */
    776             sc->blink = 0;
    777             break;
    778         case 26: /* (reserved for proportional spacing as specified in CCITT
    779                   * Recommendation T.61) */
    780             sc->proportional = 1;
    781             break;
    782         case 27: /* positive image */
    783             sc->negative = 0;
    784             break;
    785         case 28: /* revealed characters */
    786             sc->concealed = 0;
    787             break;
    788         case 29: /* not crossed out */
    789             sc->strike = 0;
    790             break;
    791         case 38: /* (reserved for future standardization, intended for setting
    792                   * character foreground colour as specified in ISO 8613-6
    793                   * [CCITT Recommendation T.416]) */
    794             break;
    795         case 39: /* default display colour (implementation-defined) */
    796             sc->fg = sc->dfg;
    797             break;
    798         case 48: /* (reserved for future standardization, intended for setting
    799                   * character background colour as specified in ISO 8613-6
    800                   * [CCITT Recommendation T.416]) */
    801             break;
    802         case 49: /* default background colour (implementation-defined) */
    803             sc->bg = sc->dbg;
    804             break;
    805         case 50: /* (reserved for cancelling the effect of the rendering
    806                   * aspect established by parameter value 26) */
    807             sc->proportional = 0;
    808             break;
    809         default:
    810             debug("ansi import: unknown sgr %i", argv[j]);
    811             break;
    812         }
     787        else
     788            switch (argv[j])
     789            {
     790            case 0:            /* default rendition */
     791                sc->fg = sc->dfg;
     792                sc->bg = sc->dbg;
     793                sc->bold = sc->blink = sc->italics = sc->negative
     794                    = sc->concealed = sc->underline = sc->faint = sc->strike
     795                    = sc->proportional = 0;
     796                break;
     797            case 1:            /* bold or increased intensity */
     798                sc->bold = 1;
     799                break;
     800            case 2:            /* faint, decreased intensity or second colour
     801                                 */
     802                sc->faint = 1;
     803                break;
     804            case 3:            /* italicized */
     805                sc->italics = 1;
     806                break;
     807            case 4:            /* singly underlined */
     808                sc->underline = 1;
     809                break;
     810            case 5:            /* slowly blinking (less then 150 per minute) */
     811            case 6:            /* rapidly blinking (150 per minute or more) */
     812                sc->blink = 1;
     813                break;
     814            case 7:            /* negative image */
     815                sc->negative = 1;
     816                break;
     817            case 8:            /* concealed characters */
     818                sc->concealed = 1;
     819                break;
     820            case 9:            /* crossed-out (characters still legible but
     821                                   marked as to be deleted */
     822                sc->strike = 1;
     823                break;
     824            case 21:           /* doubly underlined */
     825                sc->underline = 1;
     826                break;
     827            case 22:           /* normal colour or normal intensity (neither
     828                                   bold nor faint) */
     829                sc->bold = sc->faint = 0;
     830                break;
     831            case 23:           /* not italicized, not fraktur */
     832                sc->italics = 0;
     833                break;
     834            case 24:           /* not underlined (neither singly nor doubly) */
     835                sc->underline = 0;
     836                break;
     837            case 25:           /* steady (not blinking) */
     838                sc->blink = 0;
     839                break;
     840            case 26:           /* (reserved for proportional spacing as
     841                                   specified in CCITT Recommendation T.61) */
     842                sc->proportional = 1;
     843                break;
     844            case 27:           /* positive image */
     845                sc->negative = 0;
     846                break;
     847            case 28:           /* revealed characters */
     848                sc->concealed = 0;
     849                break;
     850            case 29:           /* not crossed out */
     851                sc->strike = 0;
     852                break;
     853            case 38:           /* (reserved for future standardization,
     854                                   intended for setting character foreground
     855                                   colour as specified in ISO 8613-6 [CCITT
     856                                   Recommendation T.416]) */
     857                break;
     858            case 39:           /* default display colour
     859                                   (implementation-defined) */
     860                sc->fg = sc->dfg;
     861                break;
     862            case 48:           /* (reserved for future standardization,
     863                                   intended for setting character background
     864                                   colour as specified in ISO 8613-6 [CCITT
     865                                   Recommendation T.416]) */
     866                break;
     867            case 49:           /* default background colour
     868                                   (implementation-defined) */
     869                sc->bg = sc->dbg;
     870                break;
     871            case 50:           /* (reserved for cancelling the effect of the
     872                                   rendering aspect established by parameter
     873                                   value 26) */
     874                sc->proportional = 0;
     875                break;
     876            default:
     877                debug("ansi import: unknown sgr %i", argv[j]);
     878                break;
     879            }
    813880    }
    814881
    815     if(sc->concealed)
     882    if (sc->concealed)
    816883    {
    817884        efg = ebg = CACA_TRANSPARENT;
     
    822889        ebg = sc->negative ? sc->fg : sc->bg;
    823890
    824         if(sc->bold)
    825         {
    826             if(efg < 8)
     891        if (sc->bold)
     892        {
     893            if (efg < 8)
    827894                efg += 8;
    828             else if(efg == CACA_DEFAULT)
     895            else if (efg == CACA_DEFAULT)
    829896                efg = CACA_WHITE;
    830897        }
     
    839906    int fd;
    840907    pid_t pid;
    841    
     908
    842909    pid = forkpty(&fd, NULL, NULL, NULL);
    843     if(pid < 0)
     910    if (pid < 0)
    844911    {
    845912        fprintf(stderr, "forkpty() error\n");
    846913        return -1;
    847914    }
    848     else if(pid == 0)
     915    else if (pid == 0)
    849916    {
    850917        set_tty_size(0, w, h);
     
    852919        putenv("TERM=xterm");
    853920        argv = malloc(2 * sizeof(char *));
    854         if(!argv)
    855         {
    856             fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__, __LINE__);
     921        if (!argv)
     922        {
     923            fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__,
     924                    __LINE__);
    857925            return -1;
    858926        }
     
    876944    int ret = openpty(&fdm, &fds, NULL, NULL, NULL);
    877945
    878     if(ret < 0)
     946    if (ret < 0)
    879947    {
    880948        fprintf(stderr, "open() error\n");
     
    903971
    904972
    905 int update_terms(struct screen_list* screen_list)
     973int update_terms(struct screen_list *screen_list)
    906974{
    907975    int i, refresh = 0;
    908     for(i = 0; i < screen_list->count; i++)
     976    for (i = 0; i < screen_list->count; i++)
    909977    {
    910         if(screen_list->screen[i]->total && !screen_list->dont_update_coords)
     978        if (screen_list->screen[i]->total && !screen_list->dont_update_coords)
    911979        {
    912980            unsigned long int bytes;
     
    917985                                screen_list->screen[i]->total);
    918986
    919             if(bytes > 0)
     987            if (bytes > 0)
    920988            {
    921989                screen_list->screen[i]->total -= bytes;
     
    923991                        screen_list->screen[i]->buf + bytes,
    924992                        screen_list->screen[i]->total);
    925                 if(screen_list->screen[i]->visible || screen_list->mini)
     993                if (screen_list->screen[i]->visible || screen_list->mini)
    926994                    refresh = 1;
    927995            }
     
    930998    return refresh;
    931999}
    932 
  • neercs/trunk/src/wm.c

    r3944 r3969  
    1 /*
     1/* 
    22 *  neercs        console-based window manager
    33 *  Copyright (c) 2006 Sam Hocevar <sam@zoy.org>
     
    3939    s->h = h;
    4040
    41     /*
     41    /* 
    4242     * caca_set_canvas_boundaries() is bugged as hell, so let's resize it by
    4343     * hands
     
    419419            float cube_projected[12][2];
    420420            float fov = 0.5f;
    421             float angle = 90.0f * ((float)cur_time / (float)screen_list->cube.duration);
     421            float angle =
     422                90.0f * ((float)cur_time / (float)screen_list->cube.duration);
    422423
    423424            angle *= (M_PI / 180.0f);
Note: See TracChangeset for help on using the changeset viewer.