Esempio n. 1
0
/* 
 * Coalesce two SSDs. fromq will be deleted, preceded by transferring of all
 * its children to toq
 */
int ssd_coalesce(Quark *toq, Quark *fromq)
{
    unsigned int nrows, ncols, i, j;
    ss_data *ssd;
    AMem *amem  = toq->amem;
    coalesce_hook_t p;
       
    nrows = ssd_get_nrows(fromq);
    if (nrows > ssd_get_nrows(toq)) {
        if (ssd_set_nrows(toq, nrows) != RETURN_SUCCESS) {
            return RETURN_FAILURE;
        }
    }

    /* original number of columns */
    ncols = ssd_get_ncols(toq);
    
    ssd = ssd_get_data(fromq);
    for (i = 0; i < ssd->ncols; i++) {
        ss_column *col = &ssd->cols[i];
        
        ss_column *col_new = ssd_add_col(toq, col->format);
        if (!col_new) {
            return RETURN_FAILURE;
        }
        
        col_new->label = amem_strdup(amem, col->label);
        
        if (col->format == FFORMAT_STRING) {
            for (j = 0; j < nrows; j++) {
                ((char **) col_new->data)[j] =
                    amem_strdup(amem, ((char **) col->data)[j]);
            }
        } else {
            memcpy(col_new->data, col->data, nrows*SIZEOF_DOUBLE);
        }
    }
    
    p.toq = toq;
    p.nshift = ncols;
    quark_traverse(fromq, coalesce_hook, &p);
    
    quark_free(fromq);
    
    return RETURN_SUCCESS;
}
Esempio n. 2
0
static int leaveCB(TableEvent *event)
{
    SSDataUI *ui = (SSDataUI *) event->anydata;

    int nrows = ssd_get_nrows(ui->q);
    int ncols = ssd_get_ncols(ui->q);
    int format;
    double value;
    
    int changed = FALSE;
    
    GraceApp *gapp = gapp_from_quark(ui->q);
    
    if (event->row < 0 || event->col < 0 || event->col > ncols) {
        return TRUE;
    }
    
    if (event->row >= nrows && !string_is_empty(event->value)) {
        if (ssd_set_nrows(ui->q, event->row + 1) == RETURN_SUCCESS) {
            changed = TRUE;
        }
    }
    
    if (event->col == ncols && !string_is_empty(event->value)) {
        if (parse_date_or_number(get_parent_project(ui->q),
            event->value, FALSE, get_date_hint(gapp), &value) == RETURN_SUCCESS) {
            format = FFORMAT_NUMBER;
        } else {
            format = FFORMAT_STRING;
        }
        if (ssd_add_col(ui->q, format)) {
            ncols++;
            changed = TRUE;
        }
    }
    
    if (event->col < ncols) {
        char *old_value = get_cell_content(ui, event->row, event->col, &format);
        if (!strings_are_equal(old_value, event->value)) {
            switch (format) {
            case FFORMAT_STRING:
                if (ssd_set_string(ui->q, event->row, event->col, event->value) ==
                    RETURN_SUCCESS) {
                    quark_dirtystate_set(ui->q, TRUE);
                    changed = TRUE;
                }
                break;    
            default:
                if (graal_eval_expr(grace_get_graal(gapp->grace),
                    event->value, &value, gproject_get_top(gapp->gp)) == RETURN_SUCCESS) {

                    unsigned int prec;
                    char buf[32];
                    double val;

                    prec = project_get_prec(get_parent_project(ui->q));
                    sprintf(buf, "%.*g", prec, value);

                    if (parse_date_or_number(get_parent_project(ui->q),
                        buf, FALSE, get_date_hint(gapp), &val) == RETURN_SUCCESS) {

                        if (ssd_set_value(ui->q, event->row, event->col, val) == RETURN_SUCCESS) {
                            quark_dirtystate_set(ui->q, TRUE);
                            changed = TRUE;
                        }
                    }
                } else {
                    errmsg("Can't parse input value");
                    return FALSE;
                }
                break;
            }
        }
    }
    
    if (changed) {
        snapshot_and_update(gapp->gp, FALSE);
    }

    return TRUE;
}