Changeset 4768


Ignore:
Timestamp:
Feb 13, 2011, 4:41:48 PM (10 years ago)
Author:
Jean-Yves Lamoureux
Message:
  • Reworked table handling
Location:
gaycko/trunk
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • gaycko/trunk/src/dom/dom.c

    r4759 r4768  
    8787        e->specific.table->border   = 0;
    8888        e->specific.table->tr_count = 0;
     89        e->specific.table->tr       = NULL;
    8990        }else if(!strncmp(e->name, "tr", 3)) {
    9091                e->type = ELEM_TR;
     
    9293        e->specific.tr->border   = 0;
    9394        e->specific.tr->td_count = 0;
     95        e->specific.tr->td       = NULL;
    9496        }else if(!strncmp(e->name, "td", 3)) {
    9597                e->type = ELEM_TD;
  • gaycko/trunk/src/dom/dom.h

    r4759 r4768  
    4040}nodeType;
    4141
     42typedef struct gNode_ gNode;
    4243
    4344struct gProperty_ {
     
    5556typedef struct gAttribute_ gAttribute;
    5657
     58
     59
    5760struct gTable_ {
    5861    unsigned int border;
    59         unsigned int tr_count; 
     62        unsigned int tr_count;
     63    gNode  **tr;
     64   
    6065};
    6166typedef struct gTable_ gTable;
    6267
     68
    6369struct gTr_ {
    6470    unsigned int border;
    65         unsigned int td_count; 
     71        unsigned int td_count;
     72    gNode **td;
    6673};
    6774typedef struct gTr_ gTr;
    6875
    69 typedef struct gNode_ gNode;
     76
    7077struct gNode_ {
    7178   
  • gaycko/trunk/src/gaycko.cpp

    r4758 r4768  
    2929                printf("V8 doesn't seem to work : returned '%s', should return 'Hello, World!'\n", tstr);
    3030        } else {
    31                 printf("V8 Javascript engine seems to work ok\n");
     31                printf("V8 Javascript engine seems to work ok ('%s')\n", tstr);
    3232        }       
    3333
     
    5858   
    5959    dp = caca_create_display(window->cv);
    60        
     60    if(!dp) {
     61        printf("Can't open window. CACA_DRIVER problem ?\n");
     62        return -1;
     63    }
    6164    caca_refresh_display(dp);
    6265    caca_get_event(dp, CACA_EVENT_KEY_PRESS, &ev, -1);
  • gaycko/trunk/src/js/glue.cpp

    r4748 r4768  
    1616using namespace v8;
    1717
     18int x = 42;
     19
     20
     21Handle<Value> XGetter(Local<String> property,
     22                      const AccessorInfo& info) {
     23    return Integer::New(x);
     24}
     25
     26void XSetter(Local<String> property, Local<Value> value,
     27             const AccessorInfo& info) {
     28    x = value->Int32Value();
     29}
     30
    1831char* testV8(void) {
    1932        // Create a stack-allocated handle scope.
    2033        HandleScope handle_scope;
     34   
     35        // Create a new context.
    2136
    22         // Create a new context.
    23         Persistent<Context> context = Context::New();
    24 
     37    Handle<ObjectTemplate> global_templ = ObjectTemplate::New();
     38    global_templ->SetAccessor(String::New("x"), XGetter, XSetter);
     39    Persistent<Context> context = Context::New(NULL, global_templ);
     40   
     41   
     42   
    2543        // Enter the created context for compiling and
    2644        // running the hello world script.
    2745        Context::Scope context_scope(context);
    28 
     46   
    2947        // Create a string containing the JavaScript source code.
    30         Handle<String> source = String::New("'Hello' + ', World!'");
    31 
     48        Handle<String> source = String::New("'Hello' + ', World!' + x");
     49   
    3250        // Compile the source code.
    3351        Handle<Script> script = Script::Compile(source);
    34 
     52   
    3553        // Run the script to get the result.
    3654        Handle<Value> result = script->Run();
    37 
     55   
    3856        // Dispose the persistent context.
    3957        context.Dispose();
    40 
     58   
    4159        // Convert the result to an ASCII string and print it.
    4260        String::AsciiValue ascii(result);
     61   
     62       
    4363        return strdup(*ascii);
    4464}
    45 
  • gaycko/trunk/src/render/position.c

    r4764 r4768  
    6969                                break;
    7070
    71 
    7271                        case ELEM_TEXT:
    7372                                if(parent &&
     
    8786                                }
    8887                                break;
    89 
    9088
    9189                        default:
  • gaycko/trunk/src/render/renderer.c

    r4764 r4768  
    3131        switch(node->type) {
    3232                case ELEM_TEXT:
    33                         caca_set_color_argb(window->cv, 0, 0xFFFF);
     33            if(!strcmp(node->text, " ")) break;
    3434                        caca_put_str(window->cv, node->properties->x, node->properties->y, node->text);
    3535                        break;
     
    3939                                        node->properties->x+node->parent->properties->width, node->properties->y,
    4040                                        '-');
    41                         printf("Line parent is '%s', width %d\n", node->parent->name, node->parent->properties->width);
    4241                        break;
    4342                default:
  • gaycko/trunk/src/render/renderer.h

    r4762 r4768  
    2323
    2424
    25 void gaycko_render(gWindow *window);
    26 void gaycko_get_position      (gNode *node, gNode *parent);
     25void         gaycko_render(gWindow *window);
     26void         gaycko_get_position      (gNode *node, gNode *parent);
    2727
    28 void gaycko_fix_table(gNode *table);
    29 void gaycko_fix_tr(gNode *tr);
    30 unsigned int gaycko_get_trtd_width(gNode *tr, unsigned int td_index);
    31 unsigned int gaycko_get_node_width(gNode *td);
    32 void gaycko_set_trtd_width(gNode *tr, unsigned td_index, unsigned int width);
    33 unsigned int gaycko_get_tr_width(gNode *tr);
    34 void gaycko_add_node_x(gNode *node, unsigned int add);
     28void         gaycko_fix_table(gNode *table);
     29void         gaycko_fix_tr(gNode *tr);
     30unsigned int gaycko_get_td_width(gNode *td);
     31unsigned int gaycko_get_td_width_at(gNode *tr, unsigned int td);
     32void         gaycko_set_td_width_at(gNode *tr, unsigned int td, unsigned int width);
     33void         gaycko_move_td_contents(gNode *td, unsigned int add_x);
    3534
    36 void gaycko_print_dom(gWindow *window);
    37 void gaycko_print_node(gNode *node,gWindow *window);
     35void         gaycko_print_dom(gWindow *window);
     36void         gaycko_print_node(gNode *node,gWindow *window);
    3837
    3938
  • gaycko/trunk/src/render/table.c

    r4764 r4768  
    1414void gaycko_fix_table(gNode *table) {
    1515        unsigned int tr = 0;
    16         unsigned int e  = 0;
    17         gNode *last_tr = NULL;
     16    unsigned int td = 0;
    1817        table->specific.table->tr_count = 0;
    19 
    20         /* Count TD by TR, and TR by TABLE */
     18   
     19        /* Count TR by TABLE, and TD by TR */
    2120        for(tr = 0 ; tr < table->children_count; tr++) {
    2221                if(table->children[tr]->type == ELEM_TR) {
    23                         gaycko_fix_tr(table->children[tr]);
     22            table->specific.table->tr = realloc(table->specific.table->tr,
     23                                                sizeof(gNode*)*(table->specific.table->tr_count+1));
     24            table->specific.table->tr[table->specific.table->tr_count] = table->children[tr];
    2425                        table->specific.table->tr_count++;
    25                         last_tr = table->children[tr];
     26            gaycko_fix_tr(table->children[tr]);
    2627                }
    2728        }
    28 
    29         /* Scan TD's and set each correspondants to the max width */
    30         unsigned int td = 0;
    31 
    32         for(td = 0; td < last_tr->specific.tr->td_count; td++) {
    33                 unsigned int biggest_td = 0;
    34 
    35                 /* Find widest at a given X offset */
    36                 for(e = 0 ; e < table->children_count; e++) {
    37                         if(table->children[e]->type == ELEM_TR) {
    38                                 unsigned int td_width = gaycko_get_trtd_width(table->children[e], td);
    39                                 if(biggest_td < td_width) {
    40                                         biggest_td = td_width;
    41                                 }
    42                         }
    43                 }
    44                 /* Set the others's width to the widest one */
    45                 for(e = 0 ; e < table->children_count; e++) {
    46                         if(table->children[e]->type == ELEM_TR) {
    47                                 gaycko_set_trtd_width(table->children[e], td, biggest_td);
    48                         }
    49                 }
    50         }
    51 
    52         table->properties->width = gaycko_get_tr_width(last_tr);
    53         printf("Table %d wide\n", table->properties->width);
    54 
     29   
     30    /* Get largest TD by TR, and resize same column accordingly */
     31    for(td = 0; td < table->specific.table->tr[0]->specific.tr->td_count; td++) {
     32        unsigned int widest_td = 0;
     33       
     34        /* Get largest TD on this column */
     35        for(tr = 0; tr < table->specific.table->tr_count; tr++) {
     36            unsigned int w = gaycko_get_td_width_at(table->specific.table->tr[tr], td);
     37            if(w>widest_td) widest_td=w;
     38        }
     39        /* Resize the others to this width */
     40        for(tr = 0; tr < table->specific.table->tr_count; tr++) {
     41            gaycko_set_td_width_at(table->specific.table->tr[tr], td, widest_td);
     42        }
     43    }
    5544}
    56 
    57 
    58 
    59 unsigned int gaycko_get_tr_width(gNode *tr) {
    60         unsigned int w = 0, td = 0;
    61 
    62         for(td = 0 ; td < tr->children_count; td++) {
    63                 if(tr->children[td]->type == ELEM_TD) {
    64                         unsigned int tw = gaycko_get_node_width(tr->children[td]);
    65                         w +=  tw;
    66                         printf("TD width %d\n", tw);
    67                 }
    68         }
    69         printf("So TR width %d\n", w);
    70         return w;
    71 }
    72 
    73 unsigned int gaycko_get_node_width(gNode *td) {
    74         unsigned int e = 0;
    75         unsigned int w = 0;
    76         for(e = 0 ; e < td->children_count; e++) {
    77                 w+=td->properties->width;
    78         }
    79         return w;
    80 }
    81 
    8245
    8346void gaycko_fix_tr(gNode *tr) {
    8447        unsigned int td = 0;
    8548        tr->specific.tr->td_count = 0;
    86 
     49   
    8750        for(td = 0 ; td < tr->children_count; td++) {
    8851                if(tr->children[td]->type == ELEM_TD) {
     52            tr->specific.tr->td = realloc(tr->specific.tr->td,
     53                                                sizeof(gNode*)*(tr->specific.tr->td_count+1));
     54            tr->specific.tr->td[tr->specific.tr->td_count] = tr->children[td];
    8955                        tr->specific.tr->td_count++;
    9056                }
    9157        }
    92 }   
    93 
    94 unsigned int gaycko_get_trtd_width(gNode *tr, unsigned int td_index) {
    95         unsigned int e = 0;
    96         unsigned int td = 0;
    97         for(e = 0 ; e < tr->children_count; e++) {
    98                 if(tr->children[e]->type == ELEM_TD) {
    99                         if(td == td_index) return tr->children[e]->properties->width;
    100                         td++;
    101                 }
    102         }
    103         return 0;
    10458}
    10559
    106 void gaycko_set_trtd_width(gNode *tr, unsigned td_index, unsigned int width) {
    107         unsigned int e = 0;
    108         unsigned int td = 0;
    109         unsigned int add_width = 0;
     60/* Set TD width and offset following TD's accordingly */
     61void gaycko_set_td_width_at(gNode *tr, unsigned int td, unsigned int width) {
     62   
     63   
     64   
     65    unsigned int add_x = width-tr->specific.tr->td[td]->properties->width;
     66    unsigned int tdn   = 0;
     67   
     68   
     69    tr->specific.tr->td[td]->properties->width = width;
     70   
     71    for(tdn = td+1; tdn < tr->specific.tr->td_count; tdn++) {
     72        unsigned int oldw = tr->specific.tr->td[tdn]->properties->width;
     73        gaycko_move_td_contents(tr->specific.tr->td[tdn], add_x);
     74        add_x+=(width-oldw);
     75    }
     76}
    11077
    111         for(e = 0 ; e < tr->children_count; e++) {
    112                 if(tr->children[e]->type == ELEM_TD) {
    113                         if(td == td_index) {
    114                                 add_width = width - tr->children[e]->properties->width;
    115                         }
    116                         td++;
    117                 }
    118         }
    119         td = 0;
    120         for(e = 0 ; e < tr->children_count; e++) {
    121                 if(tr->children[e]->type == ELEM_TD) {
    122                         if(td == td_index) {
    123 
    124                         } else if(td > td_index){
    125                                 tr->children[e]->properties->width = width;
    126                                 gaycko_add_node_x(tr->children[e], add_width);
    127                         }
    128                         td++;
    129                 }
    130         }
     78/* Move TD to the right (add_x) and do the same for its children */
     79void gaycko_move_td_contents(gNode *td, unsigned int add_x) {
     80    unsigned int c = 0;
     81       
     82    td->properties->x+=add_x;
     83   
     84    for(c = 0; c < td->children_count; td++) {
     85        gaycko_move_td_contents(td->children[c], add_x);
     86    }
     87}
    13188
    13289
     90/* Get TD width at specified offset of a TR */
     91unsigned int gaycko_get_td_width_at(gNode *tr, unsigned int td) {
     92    return gaycko_get_td_width(tr->specific.tr->td[td]);
    13393}
    13494
     95
     96/* Get TD width */
     97unsigned int gaycko_get_td_width(gNode *td) {
     98    return td->properties->width;
     99}
     100
  • gaycko/trunk/src/window/window.c

    r4755 r4768  
    2121    window->dom = NULL;
    2222    window->cv = caca_create_canvas(width, height);
     23    caca_set_color_ansi(window->cv, CACA_DEFAULT, CACA_BLACK);
    2324    window->width = width;
    2425        return window;
  • gaycko/trunk/tests/table.html

    r4763 r4768  
    33
    44Du texte<br/>
     5
    56<table width=50%>
    6 <tr><td> Cell1 </td><td> Cell2</td><td>Cell3 large</td></tr>
    7 <tr><td> Cell4 wide too</td><td> Cell5</td><td>Cell6</td></tr>
    8 <tr><td> Cell7 </td><td> Cell8</td><td>Cell9</td></tr>
    9 <tr><td> Cell10</td><td> Cell11</td><td>Cell12</td></tr>
     7<tr><td>petit</td><td>graaaaaand</td></tr>
     8<tr><td>graaaaand</td><td>petit</td></tr>
     9<tr><td>TRES TRES GRAND</td><td>jy</td></tr>
     10<tr><td>Et un truc sur plusieurs lignes</td><td>rien</td></tr>
    1011</table>
     12
    1113</body>
    1214</html>
Note: See TracChangeset for help on using the changeset viewer.