---

forms.c

Go to the documentation of this file.

/* $Id: forms_8c-source.html,v 1.4 2004/05/09 09:31:55 darryll Exp $
 * GtkSQL -- an interactive graphical query tool for PostgreSQL
 * Copyright (C) 2003 Darryl Luff
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "buf.h"
#include "forms.h"

#define LONGEST_KEY 256

void frm_clear(Form *frm);

void frm_define_field(Form *frm, char *nm, char *val);

void frm_print(Form *frm);

FormField *fld_add(FormField *fld, char *nm) {
    FormField *fnew = NULL;

    if (! fld) {
        fnew = fld_new(nm);
        return fnew;
    }
    else if (fld->next) {
        /* pass it on   */
        fld_add((FormField *)(fld->next), nm);
        return fld;
    }
    else {
        fnew = fld_new(nm);
        fld->next = fnew;
        return fld;
    }
    return NULL;
}

int fld_count(FormField *fld) {
    FormField *f = fld;
    int cnt = 0;

    while (f) {
        cnt++;
        f = f->next;
    }
    return cnt;
}

FormField *fld_free(FormField *fld) {
    if (! fld)
        return NULL;

    if (fld->next)
        fld_free(fld->next);

    fld_set_name(fld, NULL);
    fld_set_value(fld, NULL);
    free(fld);
    return NULL;
}

FormField *fld_get(FormField *fld, int i) {
    if (! fld)
        return NULL;

    if (! i)
        return fld;
    else if (fld->next)
        return fld_get(fld->next, i-1);
    else
        return NULL;
}

char *fld_get_help(FormField *fld) {
    if (! fld)
        return NULL;

    return fld->help;
}

FieldRelevance fld_get_relevance(FormField *fld) {
    if (! fld)
        return FR_OPTIONAL;

    return fld->rel;
}

char *fld_get_tip(FormField *fld) {
    if (! fld)
        return NULL;

    return fld->tip;
}

FieldType fld_get_type(FormField *fld) {
    if (! fld)  /* nothing there    */
        return FT_NONE;

    return fld->type;
}

char *fld_get_name(FormField *fld) {
    if (! fld)  /* nothing there    */
        return NULL;

    return fld->name;
}

char *fld_get_value(FormField *fld) {
    if (! fld)
        return NULL;

    return fld->value;
}

char *fld_get_value_by_name(FormField *fld, char *nm) {
    if (! fld)
        return NULL;

    if ((fld->name) && (!strcmp(nm, fld->name)))
        return fld->value;

    if (fld->next)
        return fld_get_value_by_name(fld->next, nm);

    return NULL;
}

FormField *fld_new(char *nm) {
    FormField *fnew = (FormField *)calloc(1, sizeof(FormField));
    if (fnew) {
        fnew->type = FT_TEXT;
        fnew->rel = FR_OPTIONAL;
        if (nm)
            fnew->name = strdup(nm);
    }
    return fnew;
}

FormField *fld_next(FormField *fld) {
    if (! fld)
        return NULL;
    else
        return fld->next;
}

void fld_set_type(FormField *fld, FieldType typ) {
    if (! fld)
        return;

    fld->type = typ;
}

void fld_set_help(FormField *fld, char *hlp) {
    if (! fld)
        return;

    if (fld->help)
        free(fld->help);

    if (hlp)
        fld->help = strdup(hlp);
}

void fld_set_relevance(FormField *fld, FieldRelevance r) {
    if (! fld)
        return;

    fld->rel = r;
}

void fld_set_tip(FormField *fld, char *txt) {
    if (! fld)
        return;

    if (fld->tip) {
        free(fld->tip);
        fld->tip = NULL;
    }

    if (txt)
        fld->tip = strdup(txt);
}

FormField *fld_set_name(FormField *fld, char *nm) {
    if (! fld)
        return NULL;

    if (fld->name)
        free(fld->name);

    if (nm)
        fld->name = strdup(nm);
    else
        fld->name = NULL;

    return fld;
}

void fld_set_value(FormField *fld, char *val) {
    if (! fld)
        return;

    if (fld->value)
        free(fld->value);

    if (val)
        fld->value = strdup(val);
    else
        fld->value = NULL;
}

char *fld_set_value_by_name(FormField *fld, char *nm, char *val) {
    if (! fld)
        return NULL;

    if ((fld->name) && (!strcmp(nm, fld->name)))
        fld_set_value(fld, val);
    else if (fld->next)
        return fld_set_value_by_name(fld->next, nm, val);

    return NULL;
}

FormField *frm_add_field(Form *frm, char *nm, char *val) {
    FormField *f;
    if (! frm)
        return NULL;

    frm->fld = fld_add(frm->fld, nm);
    f = frm_last_field(frm);
    if (f)
        fld_set_value(f, val);
    return f;
}

Form *frm_clone(Form *frm) {
    Form *f;

    if (! frm)
        return NULL;

    f = frm_new(frm);
    return f;
}


void frm_copy(Form *dst, Form *src) {
    FormField *fld;
    int fields;
    int i;
    char *name;
    char *val;

    if ((! dst) || (! src))
        return;

    frm_clear(dst);
    frm_set_title(dst, frm_get_title(src));

    fields = frm_get_field_count(src);
    for (i=0; i<fields; i++) {
        fld = frm_get_field(src, i);
        if (fld) {
            name = fld_get_name(fld);
            if (name) {
                val = fld_get_value_by_name(fld, name);
                frm_add_field(dst, name, val);
            }
        }
    }
}

ABuf *frm_check_fields(Form * frm)
{
    FormField *fld;

    int i;
    int fieldcount;

    char *value;
    ABuf *errmsg = NULL;
    FieldRelevance rel;

    /* Creates the notebook pane and label */
    /* The connection pane */
    fieldcount = frm_get_field_count(frm);
    for (i = 0; i < fieldcount; i++) {
        fld = frm_get_field(frm, i);
        rel = fld_get_relevance(fld);
        if (rel == FR_REQUIRED) {
            value = fld_get_value(fld);
            if ((value == NULL) || (strlen(value) == 0)) {
                /* No good. */
                errmsg = buf_strcat(errmsg, fld_get_name(fld));
                errmsg = buf_strcat(errmsg, ", ");
            }
        }
    }
    if (errmsg != NULL) {
        /* Remove the trainling ", "    */
        errmsg = buf_str_shrinkbyone(errmsg);
        errmsg = buf_str_shrinkbyone(errmsg);
    }
    return errmsg;
}

void frm_clear(Form *frm) {
    frm_set_title(frm, NULL);
    fld_free(frm->fld);
    return;
}

void frm_clear_fields(Form *frm) {
    FormField *fld;

    if (frm == NULL)
        return;

    fld = frm->fld;
    while (fld != NULL) {
        fld_set_value(fld, NULL);
        fld = fld->next;
    }
}

Form *frm_free(Form *f) {
    frm_set_title(f, NULL);
    fld_free(f->fld);
    free(f);
    return NULL;
}

FormField *frm_get_field(Form *frm, int n) {
    if ((! frm) || (! frm->fld))
        return NULL;

    return fld_get(frm->fld, n);
}

FieldType frm_get_field_type(Form *frm, int n) {
    FormField *fld;

    if ((! frm) || (! frm->fld))
        return FT_NONE;

    fld = frm_get_field(frm, n);
    if (fld != NULL)
        return fld_get_type(fld);

    return FT_NONE;
}

int frm_get_field_count(Form *frm) {
    if ((! frm) || (! frm->fld))
        return 0;
    
    return fld_count(frm->fld);
}

char *frm_get_field_name(Form *frm, int i) {
    FormField *fld;

    if ((! frm) || (! frm->fld))
        return NULL;

    fld = frm_get_field(frm, i);
    return fld_get_name(fld);
}

FormField *fld_get_last(FormField *fld) {
    FormField *f = fld;

    if (! f)
        return NULL;

    while (f->next)
        f = f->next;

    return f;
}

char *frm_get_title(Form *frm) {
    if (! frm)
        return NULL;

    return frm->title;
}

char *frm_get_value(Form *frm, int i) {
    FormField *fld;

    if (! frm)
        return NULL;

    if (! frm->fld)
        return NULL;

    fld = frm_get_field(frm, i);
    if (fld == NULL)
        return NULL;
    else
        return fld_get_value(fld);
}

char *frm_get_value_by_name(Form *frm, char *nm) {
    return fld_get_value_by_name(frm->fld, nm);
}

FormField *frm_last_field(Form *frm) {
    if ((! frm) || (! frm->fld))
        return NULL;

    return fld_get_last(frm->fld);
}

int frm_load_file(Form *frm, char *fn)
{
    FILE *ff;
    char buf[1024];
    char key[LONGEST_KEY + 1];
    char *val;

    if ((frm == NULL) || (fn == NULL))
        return 1;

    frm_clear(frm);

    ff = fopen(fn, "r");
    if (!ff) {
        perror("opening form file for reading");
        frm_set_value_by_name(frm, FRM_ERROR, "Could not open form file");
        return 1;
    }

    while (fgets(buf, sizeof(buf), ff)) {
        char *colon = strchr(buf, ':');
        if (colon) {
            *colon = '\0';
            strcpy(key, buf);
            val = colon;
            val++;

            /* Skip leading white space */
            while ((*val) && (isspace(*val)))
                val++;

            if (strlen(val) > 0) {
                frm_define_field(frm, key, val);
            }
        }
    }
    frm_print(frm);
    return 0;
}

int frm_match(Form *frm1, Form *frm2) {
    char *name;
    char *val1;
    char *val2;
    int i;
    int fields1 = frm_get_field_count(frm1);
    int fields2 = frm_get_field_count(frm2);

    if (fields1 != fields2)
        return 0;

    for (i=0; i<fields1; i++) {
        name = frm_get_field_name(frm1, i);
        val1 = frm_get_value(frm1, i);
        val2 = frm_get_value_by_name(frm2, name);
        if (val1 == NULL) {
            if (val2 != NULL)
                return 0;
        }
        else {
            if (val2 == NULL)
                return 0;
            if (! strcmp(val1, val2))
                return 0;
        }
    }
    return 1;
}

Form *frm_new(Form *frm) {
    Form *f = calloc(1, sizeof(Form));
    if (frm)
        frm_copy(f, frm);

    return f;
}

void frm_print(Form *frm) {
    FormField *fld;
    if (frm == NULL)
        return;

    printf("Title: %s\n", frm_get_title(frm));
    printf("=Fields=\n");
    fld = frm->fld;
    while (fld != NULL) {
        printf(" %s: %s|%s|%s\n", fld_get_name(fld), fld_get_value(fld), fld_get_tip(fld), fld_get_help(fld));
    }
}

int frm_save_file(Form *frm, char *fn)
{
    FILE *ff;
    FormField *fld;
    char *s;
    ABuf *buf = buf_new(256);

    if ((frm == NULL) || (fn == NULL))
        return 1;

    ff = fopen(fn, "w");
    if (!ff) {
        perror("opening workspace file for writing");
        frm_set_value_by_name(frm, FRM_ERROR, "Can't open form file for writing.");
        return -1;
    }

    s = frm_get_title(frm);
    if (s != NULL)
        fprintf(ff, "Title: %s\n", s);

    fld = frm->fld;
    while (fld != NULL) {
        s = fld_get_name(fld);
        if (s) {
            buf = buf_strcpy(buf, s);
            buf = buf_strcat(buf, ": ");
            s = fld_get_value(fld);
            if (s == NULL)
                s = "";
            buf = buf_strcat(buf, s);
            s = fld_get_tip(fld);
            if ((s != NULL) && (strlen(s) > 0)) {
                buf = buf_strcat(buf, "|");
                buf = buf_strcat(buf, s);
                s = fld_get_help(fld);
                if ((s != NULL) && (strlen(s) > 0)) {
                    buf = buf_strcat(buf, "|");
                    buf = buf_strcat(buf, s);
                }
            }
            fprintf(ff, "%s\n", buf->b_dat);
        }
        fld = fld_next(fld);
    }
    buf_free(buf);
    return 0;
}

void frm_set_field_type(Form *frm, int id, int typ) {
    FormField *fld;

    if ((! frm) || (! frm->fld))
        return;

    fld = frm_get_field(frm, id);
    if (fld != NULL)
        fld_set_type(fld, typ);
}

Form *frm_set_title(Form *f, char *ttl) {
    if (! f)
        return NULL;

    if (f->title) {
        free(f->title);
        f->title = NULL;
    }

    f->title = strdup(ttl);
    return f;   
}

void frm_set_value_by_name(Form *frm, char *nm, char *val) {
    fld_set_value_by_name(frm->fld, nm, val);
}

void frm_define_field(Form *frm, char *nm, char *val) {
    FormField *fld;
    char *value = NULL;
    char *tip = NULL;
    char *help = NULL;
    char *pipe = NULL;
    char *start = val;

    /* Find value.  */
    pipe = strchr(start, '|');
    value = val;
    if (pipe == NULL) {
        /* Whole string must be value.  */
        goto done;
    }

    /* terminate value string.  */
    *pipe = '\0';

    /* Look for tip.    */
    start = pipe;
    start++;

    if (strlen(start) == 0)
        /* No tip text. */
        goto done;

    tip = start;

    /* Look for help    */
    pipe = strchr(start, '|');
    if (pipe == NULL) {
        /* Rest of string Whole string must be tip. */
        goto done;  
    }

    /* terminate tip    */
    *pipe = '\0';
    
    start = pipe;
    start++;

    if (strlen(start) == 0)
        goto done;

    help = start;

done:
    fld = frm_add_field(frm, nm, val);
    if (tip != NULL)
        fld_set_tip(fld, tip);

    if (help != NULL)
        fld_set_help(fld, help);
}

---