Changeset 3944 for neercs/trunk


Ignore:
Timestamp:
Nov 18, 2009, 5:34:45 PM (10 years ago)
Author:
Jean-Yves Lamoureux
Message:
  • Explode server_main()
Location:
neercs/trunk/src
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • neercs/trunk/src/neercs.h

    r3940 r3944  
    162162    int delay;                   /* Minimal time between two refresh (ms) */
    163163    int force_refresh;
     164    long long unsigned int last_key_time;
     165    int command;
    164166
    165167    /* Detaching */
  • neercs/trunk/src/server.c

    r3942 r3944  
    1 /*
     1/* 
    22 *  neercs        console-based window manager
    33 *  Copyright (c) 2006 Sam Hocevar <sam@zoy.org>
     
    3636#include "neercs.h"
    3737
    38 static int send_to_client(const char * msg, struct screen_list* screen_list)
     38static void server_init(struct screen_list *screen_list);
     39static int handle_key(struct screen_list *screen_list, unsigned int c);
     40static int handle_attach(struct screen_list *screen_list, char *buf);
     41
     42static int send_to_client(const char *msg, struct screen_list *screen_list)
    3943{
    4044    int ret;
    41     if(!screen_list->socket[SOCK_CLIENT])
     45    if (!screen_list->socket[SOCK_CLIENT])
    4246        connect_socket(screen_list, SOCK_CLIENT);
    43     debug("Sending message (%.8s,%d) to client on socket %d", msg, strlen(msg), screen_list->socket[SOCK_CLIENT]);
    44     if(!screen_list->socket[SOCK_CLIENT])
     47    debug("Sending message (%.8s,%d) to client on socket %d", msg, strlen(msg),
     48          screen_list->socket[SOCK_CLIENT]);
     49    if (!screen_list->socket[SOCK_CLIENT])
    4550        ret = -1;
    4651    else
    4752        ret = write(screen_list->socket[SOCK_CLIENT], msg, strlen(msg));
    48     if(ret < 0 && errno != EAGAIN)
    49     {
    50         fprintf(stderr, "Failed to send message to client: %s\n", strerror(errno));
    51         if(screen_list->attached)
     53    if (ret < 0 && errno != EAGAIN)
     54    {
     55        fprintf(stderr, "Failed to send message to client: %s\n",
     56                strerror(errno));
     57        if (screen_list->attached)
    5258            detach(screen_list);
    5359    }
     
    5561}
    5662
    57 static int set_title(struct screen_list* screen_list)
     63static int set_title(struct screen_list *screen_list)
    5864{
    5965    char buf[1024];
     
    6167    char *title;
    6268
    63     if(screen_list->attached)
    64     {
    65         if(screen_list->pty < screen_list->count &&
    66            screen_list->screen[screen_list->pty]->title)
     69    if (screen_list->attached)
     70    {
     71        if (screen_list->pty < screen_list->count &&
     72            screen_list->screen[screen_list->pty]->title)
    6773            title = screen_list->screen[screen_list->pty]->title;
    6874        else
     
    7076    }
    7177
    72     if(screen_list->title)
    73     {
    74         if(!strcmp(screen_list->title, title))
     78    if (screen_list->title)
     79    {
     80        if (!strcmp(screen_list->title, title))
    7581            return 0;
    7682        free(screen_list->title);
     
    7985    screen_list->title = strdup(title);
    8086
    81     bytes = snprintf(buf, sizeof(buf)-1, "TITLE %s", title);
     87    bytes = snprintf(buf, sizeof(buf) - 1, "TITLE %s", title);
    8288    buf[bytes] = '\0';
    8389    return send_to_client(buf, screen_list);
    8490}
    8591
    86 static int set_cursor(int state, struct screen_list* screen_list)
     92static int set_cursor(int state, struct screen_list *screen_list)
    8793{
    8894    char buf[16];
    8995    int bytes;
    9096
    91     bytes = snprintf(buf, sizeof(buf)-1, "CURSOR %d", state);
     97    bytes = snprintf(buf, sizeof(buf) - 1, "CURSOR %d", state);
    9298    buf[bytes] = '\0';
    9399
     
    95101}
    96102
    97 static int request_refresh(struct screen_list* screen_list)
     103static int request_refresh(struct screen_list *screen_list)
    98104{
    99105#if defined HAVE_CACA_DIRTY_RECTANGLES
    100106    int ndirty = caca_get_dirty_rect_count(screen_list->cv);
    101     if(!ndirty)
     107    if (!ndirty)
    102108        return 0;
    103109#endif
    104     if(!screen_list->socket[SOCK_CLIENT])
     110    if (!screen_list->socket[SOCK_CLIENT])
    105111        connect_socket(screen_list, SOCK_CLIENT);
    106     if(screen_list->socket[SOCK_CLIENT])
     112    if (screen_list->socket[SOCK_CLIENT])
    107113    {
    108114        size_t bufsize, towrite;
     
    120126
    121127#if defined HAVE_CACA_DIRTY_RECTANGLES
    122         for (i=0; i<ndirty; i++)
     128        for (i = 0; i < ndirty; i++)
    123129        {
    124130            int w, h;
    125131            caca_get_dirty_rect(screen_list->cv, i, &x, &y, &w, &h);
    126             debug("dirty @%d,%d %dx%d [%dx%d]", x, y, w, h, caca_get_canvas_width(screen_list->cv), caca_get_canvas_height(screen_list->cv));
    127             buf = caca_export_area_to_memory (screen_list->cv,
    128                                               x, y, w, h,
    129                                               "caca",
    130                                               &bytes);
     132            debug("dirty @%d,%d %dx%d [%dx%d]", x, y, w, h,
     133                  caca_get_canvas_width(screen_list->cv),
     134                  caca_get_canvas_height(screen_list->cv));
     135            buf =
     136                caca_export_area_to_memory(screen_list->cv, x, y, w, h, "caca",
     137                                           &bytes);
    131138#else
    132139        {
     
    134141            x = 0;
    135142            y = 0;
    136             buf = caca_export_memory (screen_list->cv,
    137                                       "caca",
    138                                       &bytes);
     143            buf = caca_export_memory(screen_list->cv, "caca", &bytes);
    139144#endif
    140145            debug("Requesting refresh for %d", bytes);
     
    142147            written = 0;
    143148            sprintf(buf2, "UPDATE %10d %10d", x, y);
    144             ret = write(screen_list->socket[SOCK_CLIENT], buf2, strlen(buf2)+1);
    145             if(ret < 29 && errno != EAGAIN)
     149            ret =
     150                write(screen_list->socket[SOCK_CLIENT], buf2,
     151                      strlen(buf2) + 1);
     152            if (ret < 29 && errno != EAGAIN)
    146153            {
    147154                free(buf);
    148155                return -1;
    149156            }
    150             while(towrite > 0)
     157            while (towrite > 0)
    151158            {
    152159                ssize_t n;
     
    157164                          (char *)buf + written,
    158165                          towrite > bufsize ? bufsize : towrite);
    159                 if(n < 0)
     166                if (n < 0)
    160167                {
    161                     debug("Can't refresh (%s), with %d bytes (out of %d)", strerror(errno), towrite > bufsize ? bufsize : towrite, towrite);
     168                    debug("Can't refresh (%s), with %d bytes (out of %d)",
     169                          strerror(errno),
     170                          towrite > bufsize ? bufsize : towrite, towrite);
    162171                    return -1;
    163172                }
     
    168177            free(buf);
    169178        }
    170         sprintf(buf2, "REFRESH %10d %10d", caca_get_cursor_x(screen_list->cv), caca_get_cursor_y(screen_list->cv));
    171         write(screen_list->socket[SOCK_CLIENT], buf2, strlen(buf2)+1);
     179        sprintf(buf2, "REFRESH %10d %10d", caca_get_cursor_x(screen_list->cv),
     180                caca_get_cursor_y(screen_list->cv));
     181        write(screen_list->socket[SOCK_CLIENT], buf2, strlen(buf2) + 1);
    172182#if defined HAVE_CACA_DIRTY_RECTANGLES
    173183        caca_clear_dirty_rect_list(screen_list->cv);
     
    177187}
    178188
    179 int detach(struct screen_list* screen_list)
     189int detach(struct screen_list *screen_list)
    180190{
    181191    screen_list->attached = 0;
    182     if(screen_list->lock_on_detach)
     192    if (screen_list->lock_on_detach)
    183193        screen_list->locked = 1;
    184     if(screen_list->socket[SOCK_CLIENT])
     194    if (screen_list->socket[SOCK_CLIENT])
    185195    {
    186196        send_to_client("DETACH", screen_list);
     
    194204{
    195205    int i;
    196     int eof = 0, refresh = 1, command = 0, was_in_bell = 0;
    197     long long unsigned int last_key_time = 0;
     206    int eof = 0, refresh = 1, was_in_bell = 0;
    198207    long long unsigned int last_refresh_time = 0;
    199208
     209    screen_list->last_key_time = 0;
    200210    screen_list->attached = 0;
    201 
    202     /* Create socket and bind it */
    203     create_socket(screen_list, SOCK_SERVER);
    204 
    205     /* Connect to the client */
    206     connect_socket(screen_list, SOCK_CLIENT);
    207 
    208     screen_list->width = screen_list->height = 80;
    209 
    210     /* Create main canvas */
    211     screen_list->cv = caca_create_canvas(screen_list->width,
    212                                           screen_list->height
    213                                           + screen_list->mini*6
    214                                           + screen_list->status);
    215 
    216     if(!screen_list->to_grab && !screen_list->to_start)
    217     {
    218         add_screen(screen_list,
    219                    create_screen(screen_list->width,
    220                                  screen_list->height,
    221                                  screen_list->default_shell));
    222     }
    223 
    224     /* Attach processes */
    225     if(screen_list->to_grab)
    226     {
    227         for(i=0; screen_list->to_grab[i]; i++)
    228         {
    229             add_screen(screen_list,
    230                        create_screen_grab(screen_list->width,
    231                                           screen_list->height,
    232                                           screen_list->to_grab[i]));
    233         }
    234         free(screen_list->to_grab);
    235         screen_list->to_grab = NULL;
    236     }
    237 
    238     /* Launch command line processes */
    239     if(screen_list->to_start)
    240     {
    241         for(i=0; screen_list->to_start[i]; i++)
    242         {
    243             add_screen(screen_list,
    244                        create_screen(screen_list->width,
    245                                      screen_list->height,
    246                                      screen_list->to_start[i]));
    247             free(screen_list->to_start[i]);
    248         }
    249         free(screen_list->to_start);
    250         screen_list->to_start = NULL;
    251     }
    252 
    253     last_key_time = get_us();
    254 
    255     for(;;)
     211    screen_list->command = 0;
     212
     213    server_init(screen_list);
     214
     215    for (;;)
    256216    {
    257217        int quit = 0;
     
    263223
    264224        /* Check if we got something from the client */
    265         while (screen_list->socket[SOCK_SERVER] && (n = read(screen_list->socket[SOCK_SERVER], buf, sizeof(buf)-1)) > 0)
     225        while (screen_list->socket[SOCK_SERVER]
     226               && (n =
     227                   read(screen_list->socket[SOCK_SERVER], buf,
     228                        sizeof(buf) - 1)) > 0)
    266229        {
    267230            buf[n] = 0;
    268231            debug("Received command %s", buf);
    269             if(!strncmp("ATTACH ", buf, 7))
    270             {
    271                 /* If we were attached to someone else, detach first */
    272                 if(screen_list->attached)
    273                     detach(screen_list);
    274                 screen_list->attached = 1;
     232            if (!strncmp("ATTACH ", buf, 7))
     233            {
     234                refresh |= handle_attach(screen_list, buf);
     235            }
     236            else if (!strncmp("QUIT", buf, 4))
     237            {
     238                quit = 1;
     239            }
     240            else if (!strncmp("DELAY ", buf, 6))
     241            {
     242                /* FIXME check the length before calling atoi */
     243                screen_list->delay = atoi(buf + 6);
     244            }
     245            else if (!strncmp("RESIZE ", buf, 7))
     246            {
    275247                caca_free_canvas(screen_list->cv);
    276                 screen_list->cv = caca_create_canvas(atoi(buf+7), atoi(buf+18));
    277                 screen_list->delay = atoi(buf+29);
     248                /* FIXME check the length before calling atoi */
     249                screen_list->cv =
     250                    caca_create_canvas(atoi(buf + 7), atoi(buf + 18));
    278251                screen_list->changed = 1;
    279252                refresh = 1;
    280253            }
    281             else if(!strncmp("QUIT", buf, 4))
    282             {
    283                 quit = 1;
    284             }
    285             else if(!strncmp("DELAY ", buf, 6))
    286             {
    287                 /* FIXME check the length before calling atoi*/
    288                 screen_list->delay = atoi(buf+6);
    289             }
    290             else if(!strncmp("RESIZE ", buf, 7))
    291             {
    292                 caca_free_canvas(screen_list->cv);
    293                 /* FIXME check the length before calling atoi */
    294                 screen_list->cv = caca_create_canvas(atoi(buf+7), atoi(buf+18));
    295                 screen_list->changed = 1;
    296                 refresh = 1;
    297             }
    298             else if(!strncmp("KEY ", buf, 4))
    299             {
    300                 unsigned int c = atoi(buf+4);
    301                 char *str = NULL;
    302                 int size = 0;
    303                 /* CTRL-A has been pressed before, handle this as a
    304                  * command, except that CTRL-A a sends literal CTRL-A */
    305                 if(command && (c != 'a'))
    306                 {
    307                     command = 0;
    308                     refresh |= handle_command_input(screen_list, c);
    309                 }
    310                 else
    311                 {
    312                     /* Not in command mode */
    313                     last_key_time = get_us();
    314                     set_cursor(1, screen_list);
    315 
    316                     /* Kill screensaver */
    317                     if(screen_list->in_screensaver)
    318                     {
    319                         screensaver_kill(screen_list);
    320                         screen_list->in_screensaver = 0;
    321                         screen_list->changed = 1;
    322                         refresh = 1;
    323                         continue;
    324                     }
    325                     /* Handle lock window */
    326                     if(screen_list->locked)
    327                     {
    328                         refresh |= update_lock(c, screen_list);
    329                         screen_list->changed = 1;
    330                     }
    331                     else if(screen_list->window_list) {
    332                         refresh |= update_window_list(c, screen_list);
    333                         screen_list->changed = 1;
    334                     }
    335                     else
    336                     {
    337                         switch(c)
    338                         {
    339                         case 0x01: //CACA_KEY_CTRL_A:
    340                             command = 1; break;
    341                         case CACA_KEY_ESCAPE:
    342                             if(screen_list->help)
    343                             {
    344                                 screen_list->help = 0;
    345                                 screen_list->changed = 1;
    346                                 refresh = 1;
    347                                 break;
    348                             }
    349                         default:
    350                             /* CTRL-A a sends literal CTRL-A */
    351                             if (command && (c == 'a'))
    352                             {
    353                                 c = 0x01;
    354                             }
    355                             /* Normal key, convert it if needed */
    356                             str = convert_input_ansi(&c, &size);
    357                             write(screen_list->screen[screen_list->pty]->fd, str, size);
    358                             break;
    359                         }
    360                     }
    361                 }
     254            else if (!strncmp("KEY ", buf, 4))
     255            {
     256                unsigned int c = atoi(buf + 4);
     257                refresh |= handle_key(screen_list, c);
    362258            }
    363259            else
     
    368264
    369265        /* No more screens, exit */
    370         if(!screen_list->count) break;
     266        if (!screen_list->count)
     267            break;
    371268
    372269        /* User requested to exit */
    373         if(quit) break;
    374 
    375         /* Update each screen canvas  */
     270        if (quit)
     271            break;
     272
     273        /* Update each screen canvas */
    376274        refresh |= update_terms(screen_list);
    377275
     
    380278
    381279        /* Refresh screen */
    382         if(!screen_list->attached)
    383         {
    384             /* No need to refresh
    385              * Don't use the CPU too much
    386              * Would be better to select on terms + socket
    387              */
     280        if (!screen_list->attached)
     281        {
     282            /* No need to refresh Don't use the CPU too much Would be better
     283               to select on terms + socket */
    388284            sleep(1);
    389285        }
     
    391287        {
    392288            long long unsigned int current_time = get_us();
    393             long long int tdiff = (current_time - last_refresh_time)/1000;
     289            long long int tdiff = (current_time - last_refresh_time) / 1000;
    394290            /* Draw lock window */
    395             if(screen_list->locked)
     291            if (screen_list->locked)
    396292            {
    397293                draw_lock(screen_list);
    398294                refresh = 1;
    399295            }
    400             else if((current_time - last_key_time >= screen_list->autolock_timeout))
     296            else if ((current_time - screen_list->last_key_time >=
     297                      screen_list->autolock_timeout))
    401298            {
    402299                screen_list->locked = 1;
    403300                refresh = 1;
    404301            }
    405             else if((current_time - last_key_time >= screen_list->screensaver_timeout))
    406             {
    407                 if(!screen_list->in_screensaver)
     302            else if ((current_time - screen_list->last_key_time >=
     303                      screen_list->screensaver_timeout))
     304            {
     305                if (!screen_list->in_screensaver)
    408306                {
    409307                    screensaver_init(screen_list);
     
    414312                refresh = 1;
    415313            }
    416             else if(refresh || was_in_bell)
    417             {
    418                 if(tdiff >= screen_list->delay) {
     314            else if (refresh || was_in_bell)
     315            {
     316                if (tdiff >= screen_list->delay)
     317                {
    419318                    was_in_bell = screen_list->in_bell;
    420319                    refresh_screens(screen_list);
     
    423322                }
    424323            }
    425             if(refresh)
    426             {
    427                 if(tdiff >= screen_list->delay) {
     324            if (refresh)
     325            {
     326                if (tdiff >= screen_list->delay)
     327                {
    428328                    request_refresh(screen_list);
    429329                    refresh = 0;
     
    431331                }
    432332                else
    433                     debug("Skipping refresh (%lld < %d)", tdiff, screen_list->delay);
    434             }
    435 
    436         }
    437 
    438         if(screen_list->force_refresh)
     333                    debug("Skipping refresh (%lld < %d)", tdiff,
     334                          screen_list->delay);
     335            }
     336        }
     337
     338        if (screen_list->force_refresh)
    439339        {
    440340            wm_refresh(screen_list);
     
    443343
    444344        eof = 1;
    445         for(i=0; i < screen_list->count; i++)
    446             if(screen_list->screen[i]->fd >= 0)
     345        for (i = 0; i < screen_list->count; i++)
     346            if (screen_list->screen[i]->fd >= 0)
    447347                eof = 0;
    448         if(eof)
     348        if (eof)
    449349            break;
    450350    }
     
    457357}
    458358
     359
     360static void server_init(struct screen_list *screen_list)
     361{
     362    int i;
     363    /* Create socket and bind it */
     364    create_socket(screen_list, SOCK_SERVER);
     365
     366    /* Connect to the client */
     367    connect_socket(screen_list, SOCK_CLIENT);
     368
     369    screen_list->width = screen_list->height = 80;
     370
     371    /* Create main canvas */
     372    screen_list->cv = caca_create_canvas(screen_list->width,
     373                                         screen_list->height
     374                                         + screen_list->mini * 6
     375                                         + screen_list->status);
     376
     377    if (!screen_list->to_grab && !screen_list->to_start)
     378    {
     379        add_screen(screen_list,
     380                   create_screen(screen_list->width,
     381                                 screen_list->height,
     382                                 screen_list->default_shell));
     383    }
     384
     385    /* Attach processes */
     386    if (screen_list->to_grab)
     387    {
     388        for (i = 0; screen_list->to_grab[i]; i++)
     389        {
     390            add_screen(screen_list,
     391                       create_screen_grab(screen_list->width,
     392                                          screen_list->height,
     393                                          screen_list->to_grab[i]));
     394        }
     395        free(screen_list->to_grab);
     396        screen_list->to_grab = NULL;
     397    }
     398
     399    /* Launch command line processes */
     400    if (screen_list->to_start)
     401    {
     402        for (i = 0; screen_list->to_start[i]; i++)
     403        {
     404            add_screen(screen_list,
     405                       create_screen(screen_list->width,
     406                                     screen_list->height,
     407                                     screen_list->to_start[i]));
     408            free(screen_list->to_start[i]);
     409        }
     410        free(screen_list->to_start);
     411        screen_list->to_start = NULL;
     412    }
     413
     414    screen_list->last_key_time = get_us();
     415}
     416
     417static int handle_attach(struct screen_list *screen_list, char *buf)
     418{
     419    /* If we were attached to someone else, detach first */
     420    if (screen_list->attached)
     421        detach(screen_list);
     422    screen_list->attached = 1;
     423    caca_free_canvas(screen_list->cv);
     424    screen_list->cv = caca_create_canvas(atoi(buf + 7), atoi(buf + 18));
     425    screen_list->delay = atoi(buf + 29);
     426    screen_list->changed = 1;
     427    return 1;
     428}
     429
     430static int handle_key(struct screen_list *screen_list, unsigned int c)
     431{
     432    int refresh = 0;
     433    char *str = NULL;
     434    int size = 0;
     435    /* CTRL-A has been pressed before, handle this as a command, except that
     436       CTRL-A a sends literal CTRL-A */
     437    if (screen_list->command && (c != 'a'))
     438    {
     439        screen_list->command = 0;
     440        refresh |= handle_command_input(screen_list, c);
     441    }
     442    else
     443    {
     444        /* Not in command mode */
     445        screen_list->last_key_time = get_us();
     446        set_cursor(1, screen_list);
     447
     448        /* Kill screensaver */
     449        if (screen_list->in_screensaver)
     450        {
     451            screensaver_kill(screen_list);
     452            screen_list->in_screensaver = 0;
     453            screen_list->changed = 1;
     454            refresh = 1;
     455            return refresh;
     456        }
     457        /* Handle lock window */
     458        if (screen_list->locked)
     459        {
     460            refresh |= update_lock(c, screen_list);
     461            screen_list->changed = 1;
     462        }
     463        else if (screen_list->window_list)
     464        {
     465            refresh |= update_window_list(c, screen_list);
     466            screen_list->changed = 1;
     467        }
     468        else
     469        {
     470            switch (c)
     471            {
     472            case 0x01:         // CACA_KEY_CTRL_A:
     473                screen_list->command = 1;
     474                break;
     475            case CACA_KEY_ESCAPE:
     476                if (screen_list->help)
     477                {
     478                    screen_list->help = 0;
     479                    screen_list->changed = 1;
     480                    refresh = 1;
     481                    break;
     482                }
     483            default:
     484                /* CTRL-A a sends literal CTRL-A */
     485                if (screen_list->command && (c == 'a'))
     486                {
     487                    c = 0x01;
     488                }
     489                /* Normal key, convert it if needed */
     490                str = convert_input_ansi(&c, &size);
     491                write(screen_list->screen[screen_list->pty]->fd, str, size);
     492                break;
     493            }
     494        }
     495    }
     496    return refresh;
     497}
     498
     499
    459500int start_server(struct screen_list *screen_list)
    460501{
    461502    pid_t pid;
    462     char * sess;
     503    char *sess;
    463504
    464505    pid = fork();
    465     if(pid < 0)
     506    if (pid < 0)
    466507    {
    467508        perror("Failed to create child process");
    468509        return -1;
    469510    }
    470     if(pid == 0)
     511    if (pid == 0)
    471512    {
    472513        int fd;
     
    475516        close(2);
    476517        fd = open("/dev/null", O_RDWR, 0);
    477         if(fd < 0)
     518        if (fd < 0)
    478519        {
    479520            perror("Failed to open /dev/null");
     
    487528            close(fd);
    488529#else
    489         if(fd != 0)
     530        if (fd != 0)
    490531            close(fd);
    491         fd = open("/tmp/neercs-debug.txt", O_TRUNC|O_RDWR|O_CREAT, S_IRUSR|S_IWUSR);
     532        fd = open("/tmp/neercs-debug.txt", O_TRUNC | O_RDWR | O_CREAT,
     533                  S_IRUSR | S_IWUSR);
    492534        dup2(fd, 1);
    493535        dup2(fd, 2);
     
    497539        setsid();
    498540        server_main(screen_list);
    499         /* Never returns */
     541        /* Never returns */
    500542    }
    501543    create_socket(screen_list, SOCK_CLIENT);
    502     while((sess = connect_socket(screen_list, SOCK_SERVER)) == NULL)
     544    while ((sess = connect_socket(screen_list, SOCK_SERVER)) == NULL)
    503545        usleep(100);
    504546    free(sess);
     
    507549    screen_list->cv = caca_create_canvas(0, 0);
    508550    screen_list->dp = caca_create_display(screen_list->cv);
    509     caca_set_display_time(screen_list->dp, screen_list->delay*1000);
    510 
    511     if(!screen_list->dp)
     551    caca_set_display_time(screen_list->dp, screen_list->delay * 1000);
     552
     553    if (!screen_list->dp)
    512554        return -3;
    513555    caca_set_cursor(screen_list->dp, 1);
     
    522564    struct timeval tv;
    523565    gettimeofday(&tv, NULL);
    524     return (tv.tv_sec*(1000000) + tv.tv_usec);
    525 }
     566    return (tv.tv_sec * (1000000) + tv.tv_usec);
     567}
  • neercs/trunk/src/wm.c

    r3942 r3944  
    489489            screen_list->cube.in_switch = 1;
    490490        }
    491 
    492     }
    493 }
     491    }
     492}
Note: See TracChangeset for help on using the changeset viewer.