sic_xgag.c

Go to the documentation of this file.

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <fcntl.h>
#include <signal.h>
#include <errno.h>
#include <string.h>
#ifndef WIN32
#include <unistd.h>
#include <sys/file.h>
#include <sys/wait.h>
#endif
#include <sys/types.h>
#include <sys/stat.h>

#include "getcar.h"
#include "sic_comm.h"
#include "sic_launch.h"
#ifdef WIN32
#include "win-dialogs.h"
#endif

#include "sic_xgag.h"

#ifndef SIGCLD
#define SIGCLD SIGCHLD
#endif /* SIGCLD */

static char window_title[TITLELENGTH], helpfilename[HLPFILELNGTH];

static global_struct widgets[NSTRUCT], *last_widget = widgets;  /* Number of all user inputs */
#ifdef WIN32
extern char *dialoghelpname[MAX_NB_DIALOG];
#endif

static void my_f2c_strncpy( char *dest, CFC_FString txt, size_t fsize, size_t max)
{
    /* this routine should read a FORTRAN character array, i.e, not necessary
       null-terminated, of size 'fsize', and strncpy it null-terminated to
       the dest C string (of size 'max' ), BUT with all the trailing blanks
       removed (i.e., the \0 is writ before the trailing blanks). 'fsize'
       must be either the real length of the fortran char array, in that case
       it is defined in sic_structures.h and must be set accordingly in
       xgag.inc on the fortran side, or a smaller length, LENC(), passed by
       the fortran */
    size_t n = (fsize < max) ? fsize : max - 1;

    CFC_f2c_strcpy( dest, txt, (int)n);
}

/*
 * Same as my_f2c_strncpy, but with fortran string passed as C pointer
 */
static void my_fp2c_strncpy( char *dest, char *txt, size_t fsize, size_t max)
{
    CFC_FString tmp;

    tmp.value = txt;
    my_f2c_strncpy( dest, tmp, fsize, max);
}

void CFC_API xgag_separator( int *win_id)
{
    generic_struct *generic = &(last_widget++)->generic;

    generic->window_id = *win_id;
    generic->type = SEPARATOR;
}

global_struct *set_generic( int type, int win_id, CFC_FString variable, CFC_FString label)
{
    global_struct *widget;
    generic_struct *gene;
    char variable_name[SICVLN];

    my_f2c_strncpy( variable_name, variable, SICVLN, SICVLN);
    for (widget = widgets; widget < last_widget; widget++) {
        gene = &widget->generic;
        if (gene->type == type && !strcmp( gene->variable, variable_name) && gene->window_id == win_id)
            return widget;
    }                                  /* do not replicate widget */
    gene = &last_widget->generic;
    gene->window_id = win_id;
    gene->type = type;
    strcpy( gene->variable, variable_name);
    my_f2c_strncpy( gene->label, label, LABELLENGTH, LABELLENGTH);
    return last_widget++;
}

void CFC_API xgag_logic( CFC_FString variable, CFC_FString txt, int *flag, int *win_id)
{
    logic_struct *logic = &set_generic( LOGIC, *win_id, variable, txt)->logic;

    logic->logic = flag;
    logic->userlogic = (*flag == 1);
}

void CFC_API xgag_file( CFC_FString variable, CFC_FString txt, char *c, int *length, CFC_FString filter, int *win_id)
{
    file_struct *file = &set_generic( BROWSER, *win_id, variable, txt)->file;

    my_f2c_strncpy( file->filter, filter, FILTERLENGTH, FILTERLENGTH);
    file->chain = c;
    my_fp2c_strncpy( file->userchain, c, *length, CHAINLENGTH);
    file->length = strlen( file->userchain);
}


void CFC_API xgag_choice( CFC_FString variable, CFC_FString txt, char *ch, int *length, xgag_choicelst * liste, int *nch, int *ind, int *win_id)
{
    int i;
    choice_struct *choice = &set_generic( CHOICE, *win_id, variable, txt)->choice;

    choice->choice = ch;
    my_fp2c_strncpy( choice->userchoice, ch, *length, CHAINLENGTH);
    choice->length = strlen( choice->userchoice);
    choice->nchoices = *nch;
    for (i = 0; i < choice->nchoices; i++) {
        my_fp2c_strncpy( choice->choices[i], liste[i].chs, X_CHOLEN, X_CHOLEN);
    }
    choice->mode = *ind;
}

void CFC_API xgag_slider( CFC_FString variable, CFC_FString txt, float *f, float *min, float *max, int *win_id)
{
    slider_struct *slider = &set_generic( SLIDER, *win_id, variable, txt)->slider;

    slider->value = f;
    slider->uservalue = *f;
    slider->width = *max - *min;
    slider->min = *min;
}

void CFC_API xgag_ch( CFC_FString variable, CFC_FString txt, char *c, int *length, int *win_id, int *editable)
{
    chain_struct *chain = &set_generic( CHAIN, *win_id, variable, txt)->chain;

    chain->chain = c;
    my_fp2c_strncpy( chain->userchain, c, *length, CHAINLENGTH);
    chain->length = strlen( chain->userchain);
    chain->editable = *editable;
}

void CFC_API xgag_show( char *c, int *length, int *win_id)
{
    show_struct *show = &(last_widget++)->show;

    show->window_id = *win_id;
    show->type = SHOW;
    my_fp2c_strncpy( show->text, c, *length, TEXTLENGTH);
}

void CFC_API xgag_button( CFC_FString title, CFC_FString command, CFC_FString label, int *length, CFC_FString helptxt, CFC_FString moretxt)
{
    button_struct *button = &(last_widget++)->button;

    button->window_id = 0;
    button->type = BUTTON;
    my_f2c_strncpy( button->title, title, TITLELENGTH, TITLELENGTH);
    my_f2c_strncpy( button->command, command, COMMANDLENGTH, COMMANDLENGTH);
    my_f2c_strncpy( button->label, label, LABELLENGTH, LABELLENGTH);
    /*   button->showlength= strlen( button->label); */
    /* above is invalid because a blank character chain may be used
       even for a submenu button */
    button->showlength = *length;
    my_f2c_strncpy( button->helptxt, helptxt, HLPFILELNGTH, HLPFILELNGTH);
    my_f2c_strncpy( button->moretxt, moretxt, TITLELENGTH, TITLELENGTH);
}

static task_t xinput_task = SIC_TASK_NULL;

static void kill_xwindow( )
{
    if (xinput_task != SIC_TASK_NULL) {
        sic_terminate( xinput_task);
        xinput_task = SIC_TASK_NULL;
    }
}

void CFC_API end_dialog( void)
{
    int i;

    kill_xwindow( );

    last_widget = widgets;
    for (i = 0; i < NSTRUCT; i++) {
        widgets[i].generic.type = 0;
        strcpy( widgets[i].generic.variable, "\0");
    }
#ifdef WIN32
    on_end_dialog( );
#endif
}

void CFC_API xgag_open( CFC_FString txt, CFC_FString name, int *code)
{
    end_dialog( );

    my_f2c_strncpy( window_title, txt, TITLELENGTH, TITLELENGTH);
    my_f2c_strncpy( helpfilename, name, HLPFILELNGTH, HLPFILELNGTH);
#ifdef WIN32
    sprintf(dialoghelpname[0], "%s", helpfilename);
#endif
}

void CFC_API xgag_update( CFC_FString variable, CFC_FzString update)
{
    int i;
    char variable_name[SICVLN];

    if (xinput_task == SIC_TASK_NULL)
        return;

    my_f2c_strncpy( variable_name, variable, SICVLN, SICVLN);

    /* check if update is necessary */
    /* every instance of widget pointing on a variable will be updated by
       the widget sic_xinput (care has been taken for that in the widget 
       itself). It is only necessary to signal the FIRST widget (containing
       the associated variable name) to sic_xinput */
    for (i = 0; i < NSTRUCT; i++) {

        if (widgets[i].generic.type == 0)
            break;

        if (strcmp( variable_name, widgets[i].generic.variable) == 0) {
            switch (widgets[i].generic.type) {
            case SLIDER:
                widgets[i].slider.uservalue = (float)atof( CFC_fz2c_string( update));
                break;
            case LOGIC:
                widgets[i].logic.userlogic = strcmp( CFC_fz2c_string( update), "YES") ? 0 : 1;
                break;
            case CHAIN:
                strncpy( widgets[i].chain.userchain, CFC_fz2c_string( update), CHAINLENGTH);
                break;
            case CHOICE:
                strncpy( widgets[i].choice.userchoice, CFC_fz2c_string( update), CHAINLENGTH);
                break;
            case BROWSER:
                strncpy( widgets[i].file.userchain, CFC_fz2c_string( update), CHAINLENGTH);
                break;
            }

            sic_fire_modified_variable_event( &widgets[i]);

            return;                    /* exit from loop at first instance */
        }
    }
}

/* Get parameter function called by main task when it receives GUI\END */

void CFC_API get_user_input( CFC_FzString return_command, int *err_code)
{
    int i;
    int nb_widgets;

    nb_widgets = sic_open_widget_board( );

    for (i = 0; i < nb_widgets; i++) {
        sic_get_widget_def( i, &widgets[i]);
    }

    sic_get_widget_returned_command( CFC_fz2c_string( return_command));
    *err_code = sic_get_widget_returned_code( );

    sic_close_widget_board( );

    if (*err_code != -3) {
        for (i = 0; i < NSTRUCT; i++) {
            if (widgets[i].generic.type == 0)
                break;

            switch (widgets[i].generic.type) {
            case CHAIN:
                strcpy( widgets[i].chain.chain, widgets[i].chain.userchain);
                break;
            case BROWSER:
                strcpy( widgets[i].file.chain, widgets[i].file.userchain);
                break;
            case LOGIC:
                *widgets[i].logic.logic = widgets[i].logic.userlogic;
                break;
            case SLIDER:
                *widgets[i].slider.value = widgets[i].slider.uservalue;
                break;
            case CHOICE:
                strcpy( widgets[i].choice.choice, widgets[i].choice.userchoice);
                break;
            }
        }
    } else {
        kill_xwindow( );

        /* Reset structure members to initial values */
        for (i = 0; i < NSTRUCT; i++) {
            if (widgets[i].generic.type == 0)
                break;
            switch (widgets[i].generic.type) {
            case LOGIC:
                widgets[i].logic.userlogic = *widgets[i].logic.logic;
                break;

            case BROWSER:
                my_fp2c_strncpy( widgets[i].file.userchain, widgets[i].file.chain, widgets[i].file.length, CHAINLENGTH);
                break;
            case CHOICE:
                my_fp2c_strncpy( widgets[i].choice.userchoice, widgets[i].choice.choice, widgets[i].choice.length, CHAINLENGTH);
                break;
            }
        }
    }
}

void CFC_API xgag_dialog( CFC_FzString return_command, int *err_code)
{
    int i;

    sic_create_widget_board( );

    sic_set_widget_global_infos( window_title, helpfilename, CFC_fz2c_string( return_command));

    /* write data in shared memory */
    for (i = 0; widgets[i].generic.type != 0; i++) {
        sic_add_widget_def( &widgets[i]);
    }

    sic_close_widget_board( );

    xinput_task = launch_xinput( );

    sic_wait_widget_created( );
}

---