win-dialogs.c

Go to the documentation of this file.

#include <windows.h>
#include <commctrl.h>
#include <vfw.h>
#include <math.h>
#include <stdlib.h>
#include <string.h> 
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <malloc.h>
#include "win-dialogs.h"
#include "sic_comm.h"
#include "cfc.h"
#include "getcar.h"
#include "xinput.h"

#define NMENUCOMMAND 50
#define LDIM 25
#define BDIM 22
#define IDIM 18
#define vertpad 0
#define horzpad 5
#define FIRSTCHAINID       100 // debut des indices des chaines
#define FIRSTSLIDERID      200 // debut des indices des sliders
#define FIRSTBUTTONID      300 // debut des indices des boutons 'more', 'logic' et 'file'
#define FIRSTCOMMANDID     400 // debut des indices des boutons de commande dans la fenetre principale
#define FIRSTHELPID        500 // debut des indices des boutons helps
#define FIRSTOPTIONOK      600 // debut des indices des boutons OK dans les fenetres secondaires
#define BUTTONFLAGS WS_CHILD | WS_VISIBLE | WS_BORDER | BS_PUSHLIKE
#define LOGICFLAGS WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX | BS_CENTER
#define LABELFLAGS WS_CHILD | WS_VISIBLE | WS_BORDER | SS_CENTER | SS_NOTIFY
#define CHAINFLAGS WS_CHILD | WS_VISIBLE | WS_BORDER | ES_CENTER
#define SLIDERFLAGS WS_CHILD | WS_VISIBLE | TBS_NOTICKS | TBS_ENABLESELRANGE
#define COMBOBOXFLAGS WS_CHILD | WS_VISIBLE | WS_BORDER | CBS_AUTOHSCROLL | CBS_DROPDOWN | CBS_HASSTRINGS

int fontheight;

int mainwidth, mainheight, viewportheight, commandheight;
int labelwidth=200, textwidth=300, sliderchainwidth=50, sliderwidth=250; 
int filechainwidth=250, buttonwidth=100, morewidth=150, helpwidth=50;
int itemheight=LDIM,buttonheight=BDIM, chainheight=IDIM, labelheight=IDIM;
int choiceheight=LDIM, logicheight=IDIM, sliderheight=IDIM;
HWND labelw, editw, logicw, sliderw, buttonw, okw, cancelw, helpw;
HWND morewindows[MAX_NB_DIALOG], editwin[NSTRUCT], sliderwin[NSTRUCT], logicwin[NSTRUCT];
HFONT dialogfont=NULL;
char *dialoghelpname[MAX_NB_DIALOG];
int nb_widgets, WIN0=0, nmore=0, NEL[MAX_NB_DIALOG];

int index[MAX_NB_DIALOG][NSTRUCT], IDWIN[NSTRUCT], INDEXCOM[MAX_NB_DIALOG];
int screenheight, screenwidth, curheight[MAX_NB_DIALOG];
int num_actions[NSTRUCT];
static char *command[NMENUCOMMAND];
static char *menucommand[NMENUCOMMAND];

static char return_command[COMMANDLENGTH]; /* Passed to get_user_input */

HGDIOBJ DlgFont, VarFont;

char clog[7] = "No\0Yes\0";
int SCB;

int ERR_CODE;

void MyErrorHandler(char *str1, char *str2)
{
   fprintf(stderr, "error %d at %s in %s\n", GetLastError(), str1, str2);
}

HINSTANCE hInst; // current instance
HWND   FrameWnd, hWnd, root_win;
HANDLE hThread=NULL; 
WORD *pdlgtemplate, *save_cur_ptr;


LRESULT APIENTRY MainWndProc(HWND, UINT, UINT, LONG);

static void save_context(HWND hwnd)
{
  int i, j, k, ind;
  int len;
  char buffer[256];

  ind = GetWindowLong(hwnd, GWL_USERDATA);
  
  for (i = 0; i < NEL[ind]; i++) {
        j = index[ind][i];
    switch(widgets[j].generic.type) {
        case CHAIN:
      len = GetDlgItemText(hwnd, FIRSTCHAINID+i, (LPTSTR) buffer, 256);
          // len = GetDlgItemText(hwnd, + FIRSTCHAINID+j, (LPTSTR) buffer, 256);
          strncpy( widgets[j].chain.userchain, buffer, CHAINLENGTH);
          /*printf("%s\n", widgets[j].chain.userchain);
          strncpy(widgets[j].chain.chain,
                widgets[j].chain.userchain,
                widgets[j].chain.length);*/
          break;
        case CHOICE:
      len = GetDlgItemText(hwnd, FIRSTCHAINID+i, (LPTSTR) buffer, 256);
          // len = GetDlgItemText(hwnd, + FIRSTCHAINID+j, (LPTSTR) buffer, 256);
          
          if (widgets[j].choice.mode == 1) {
            for (k = 0; k<widgets[j].choice.nchoices; k++) {
                        if (len == strlen(widgets[j].choice.choices[k]) ) {  // SG compare on full length
                                if (strncmp(buffer,
                                        widgets[j].choice.choices[k],
                                        strlen(widgets[j].choice.choices[k])) == 0)
                                break;
                        }
            }
            sprintf(buffer, "%d", (k+1));
      }
      strncpy(widgets[j].choice.userchoice, buffer, CHAINLENGTH);
/*
          printf("%s\n", widgets[j].choice.userchoice);
          strncpy(widgets[j].choice.choice,
                widgets[j].choice.userchoice,
                widgets[j].choice.length);  */
          break;

        case LOGIC:
      len = GetDlgItemText(hwnd, FIRSTBUTTONID+i, (LPTSTR) buffer, 256);
          
          widgets[j].logic.userlogic = strncmp(buffer, "Yes", 3) ? 0 : 1;
          //printf("logic %s %d\n", buffer, widgets[j].logic.userlogic);
          //*widgets[j].logic.logic = widgets[j].logic.userlogic;

          break;
        case SLIDER:
      len = GetDlgItemText(hwnd, FIRSTCHAINID+i, (LPTSTR) buffer, 256);
      *widgets[j].slider.value = widgets[j].slider.uservalue = (float) atof(buffer);
          //printf("slider %g\n", widgets[j].slider.uservalue);
      //*widgets[j].slider.value = widgets[j].slider.uservalue;
          break;
        case BROWSER:
          len = GetDlgItemText(hwnd, FIRSTCHAINID+i, (LPTSTR) buffer, 256);
      strncpy(widgets[j].file.userchain, buffer, CHAINLENGTH);
          //printf("file %s\n", buffer, widgets[j].file.userchain);
          //strncpy(widgets[j].file.chain, widgets[j].file.userchain, widgets[j].file.length);
          break;
        }
  }
}

static void close_dialog(HWND hwnd, WORD id)
{
    int i;

    save_context(hWnd);
    for (i = 0; i<nmore; i++)
        save_context(morewindows[i]);

    if (on_close_dialog( return_command, ERR_CODE) == -1)
        MessageBeep( MB_ICONHAND);
}

int ncreate=0;
char dumstr[80];

void SetWidgetFont(HWND hwnd, HFONT hfont)
{
  SendMessage(hwnd, WM_SETFONT,
              (WPARAM) hfont,                  
              (LPARAM) MAKELPARAM(TRUE, 0));
}


WNDPROC wpOrigEditProc, wpOrigChoiceProc;  
POINT caretpos;



int yoffset=0;
SCROLLINFO si;

LRESULT APIENTRY ChoiceSubclassProc(hwnd, uMsg, wParam, lParam) 
HWND hwnd; 
UINT uMsg; 
WPARAM wParam; 
LPARAM lParam; 
{ 
  int i, ind;
  LRESULT index;
  
  switch (uMsg) {
  
  case WM_COMMAND:
        //printf("COMMAND\n");
        ind = GetWindowLong(hwnd, GWL_USERDATA);
                
    for (i=0; i<nb_widgets; i++) {
          if ((i != ind) && (strncmp(widgets[i].generic.variable, 
                  widgets[ind].generic.variable, 15) == 0)) {
                index = SendMessage(hwnd, CB_GETCURSEL, (WPARAM)0, (LPARAM) 0);
                SendMessage(editwin[i], CB_SETCURSEL, (WPARAM)index, (LPARAM)0);
          }
        }
        break; 
  }
  return CallWindowProc(wpOrigChoiceProc, hwnd, uMsg, wParam, lParam);
}

LRESULT APIENTRY EditSubclassProc(hwnd, uMsg, wParam, lParam) 
HWND hwnd; 
UINT uMsg; 
WPARAM wParam; 
LPARAM lParam; 
{ 
  HWND parent;
  int i, j, ind, prev, next;
  char buffer[256];
  DWORD dwPos;

 
  switch (uMsg) {
 
  
  case WM_KEYDOWN:
        if ((wParam == VK_UP) || (wParam == VK_DOWN)) {
          parent = GetParent(hwnd);
          GetCaretPos(&caretpos);

          MapWindowPoints(hwnd, parent, &caretpos, 1);
          
          prev = caretpos.y/itemheight;

          ind = GetWindowLong(parent, GWL_USERDATA);
          //printf("%d %d\n", ind, prev);
        
          if (prev < NEL[ind]) {
                next = prev;
                if (wParam == VK_UP) {
                  while (next > 0) {
                        next--;
                        
                        j = index[ind][next];
                        if (((widgets[j].generic.type == CHAIN) && (widgets[j].chain.editable)) ||
                                (widgets[j].generic.type == SLIDER) || 
                                (widgets[j].generic.type == BROWSER)) {
                          SetFocus(editwin[j]);
                          GetCaretPos(&caretpos);
                          MapWindowPoints(editwin[j], parent, &caretpos, 1);
                          if ((!ind) && (caretpos.y < -yoffset)) {
                            //printf("caret %d offset %d\n", caretpos.y, -yoffset);
                                si.nPos-=((-yoffset-caretpos.y+itemheight)/itemheight)*itemheight;
                                yoffset+=((-yoffset-caretpos.y+itemheight)/itemheight)*itemheight;
                        
                                        
                                yoffset=min(0, yoffset);
                                si.nPos = max(0, si.nPos); 
                                
                                MoveWindow(hWnd, 0, yoffset, mainwidth, mainheight, 1);
            
                                si.fMask  = SIF_POS;
                                SetScrollInfo(FrameWnd, SB_VERT, &si, TRUE); 
                          }
                          break;
                        }
                  }
                  
                }
                else if (wParam == VK_DOWN) {
                  while (next < NEL[ind] - 1) {
                        next++;
                        j = index[ind][next];
                        if (((widgets[j].generic.type == CHAIN) && (widgets[j].chain.editable)) ||
                        (widgets[j].generic.type == SLIDER) || 
                        (widgets[j].generic.type == BROWSER)) {
                          SetFocus(editwin[j]);
                          GetCaretPos(&caretpos);
                          MapWindowPoints(editwin[j], parent, &caretpos, 1);
                          
                          if ((!ind) && (caretpos.y + yoffset > viewportheight)) {
                                //printf("caret %d offset %d\n", caretpos.y, yoffset);
                                si.nPos += ((caretpos.y-viewportheight+itemheight)/itemheight)*itemheight;
                                yoffset -= ((caretpos.y-viewportheight+itemheight)/itemheight)*itemheight;
                                //yoffset -= itemheight;
                        //si.nPos += itemheight;
                                yoffset = max(viewportheight - mainheight, yoffset);
                                si.nPos = min(si.nPos, mainheight-viewportheight);
                
                    MoveWindow(hWnd, 0, yoffset, mainwidth, mainheight, 1);     
                                si.fMask  = SIF_POS;
                                SetScrollInfo(FrameWnd, SB_VERT, &si, TRUE);  
                          }
                          break; 
                        }
                  }
                }
        
          }
          return 0;
        }
        break;

  case WM_KEYUP:
        ind = GetWindowLong(hwnd, GWL_USERDATA);
                
    for (i=0; i<nb_widgets; i++) {
        
          if (strncmp(widgets[i].generic.variable, widgets[ind].generic.variable, 15) == 0) {
        if ((i != ind) || (widgets[i].generic.type == SLIDER))
                        SendMessage(hwnd, WM_GETTEXT, 256, (LPARAM) buffer);
                
                if (i != ind) SendMessage(editwin[i], WM_SETTEXT, 0, (LPARAM) buffer);
                
                if (widgets[i].generic.type == SLIDER) {
                  dwPos = (DWORD) (100*(atof(buffer)-widgets[ind].slider.min)/
                          widgets[ind].slider.width);
                  SendMessage(sliderwin[i], TBM_SETPOS, (WPARAM) TRUE, (LPARAM) dwPos);
                }
          }
        }
        break;
  }
  
  return CallWindowProc(wpOrigEditProc, hwnd, uMsg, wParam, lParam);
 
}

HWND dialog_help_win[MAX_NB_DIALOG], dialog_help_edit[MAX_NB_DIALOG]; // Fenetres de help des panneaux de controle
char *dialoghelptext;

void dialog_help(int idfilename, char *varname)
{
        char *text;
        struct _stat statb;
        FILE *fd;
        int j, ind;
        char fname[256];
        char tampon[256];
        char variablename[16], taskname[16];    

        sprintf(fname, "%s", dialoghelpname[idfilename]);
        if (_stat(fname, &statb) == -1) {
                text = (char *) malloc(256*sizeof(char));
    
                if (varname == 0)
                        strcpy(text, "Reference not found ...");
                else {
                        sprintf(tampon, "Variable %s\n", varname);
                        strcpy(text, tampon);
                        strcat(text, "---------------------------------------------\n");
                }
        }
        else {
                //Allocate much more memory to allow chain substitutions and separator lines
                text = (char *) malloc((unsigned)(2*statb.st_size));
                
                
                fd = fopen(fname, "r");
        /*
                  numread = fread(text, sizeof(char), statb.st_size+1, fd);
                printf( "Number of bytes read = %d\n", numread );

        text[statb.st_size] = 0;
        */
                if (varname == 0) {
                // On a clique sur un bouton help
                        strcpy(text, "  ");
                        while (fgets(tampon, 255, fd) != NULL) {
                                if (strncmp(tampon, "1 END", 5) == 0) break;

                                if (tampon[0] == '1') {
                                        sscanf(tampon, "%d%s", &ind, taskname);
                                        strcpy(text, "---------------------------------------------\n");
                                        sprintf(tampon, "%s%s\n", "TASK : ", taskname);
                                        strcat(text, tampon);
                                        strcat(text, "---------------------------------------------\n\n");
                                }       
                                else if (tampon[0] == '2') {
                                        sscanf(tampon, "%d%s", &ind, variablename);
                                        sprintf(tampon, "\n Variable %s\n", variablename);
                                        strcat(text, tampon);
                                        strcat(text, "---------------------------------------------\n\n");
                                }
                                else strcat(text, tampon);
                        }
                
                }
                else {
                        j = 0;
                        while(varname[j] != ' ') j++;
                        while (fgets(tampon, 255, fd) != NULL) {
                                sscanf(tampon, "%d%s", &ind, variablename);
                                if (strncmp(variablename, varname, j) == 0)
                                        break;
                        }
                        if (strncmp(variablename, varname, j) != 0) {
                                sprintf(tampon, "Variable %s\n", varname);
                                strcpy(text, tampon);
                                strcat(text, "---------------------------------------------\n");
                        }
                        else {
                                sscanf(tampon, "%d%s", &ind, variablename);
                                sprintf(tampon, "Variable %s\n", variablename);
                                strcpy(text, tampon);
                                strcat(text, "---------------------------------------------\n");

                                while (fgets(tampon, 255, fd) != NULL) {
                                        if ((tampon[0] == '1') || (tampon[0] == '2')) break;
                                        else strcat(text, tampon);
                                }
                        }
                }
                fclose(fd);
        }
        
        //printf("IDFILENAME %d\n", idfilename);
        if (dialog_help_win[idfilename] == NULL) {
        
                dialog_help_win[idfilename] = CreateWindowEx(WS_EX_TOOLWINDOW, TEXT("helpdialog"),
                                                                        (LPCTSTR) fname,  
                                                            WS_OVERLAPPEDWINDOW,
                                                                        CW_USEDEFAULT, CW_USEDEFAULT,
                                                                        600, 300,
                                                                        (HWND) NULL, (HMENU) NULL, hInst, (LPSTR) NULL);

            ShowWindow(dialog_help_win[idfilename], SW_SHOWNORMAL);
        }
        else ShowWindow(dialog_help_win[idfilename], SW_SHOW);
    
        SetForegroundWindow(dialog_help_win[idfilename]);
//SendMessage(dialog_help_edit, WM_SETTEXT, 0, (LPARAM) dialoghelptext);
//free(dialoghelptext);
        SendMessage(dialog_help_edit[idfilename], WM_SETTEXT, 0, (LPARAM) text);
        free(text);

}

int nhelpwcreate=0;

LRESULT APIENTRY HelpWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
  HWND wnd;
  int i;

  switch (message) {
  case WM_CREATE:
          dialog_help_edit[nhelpwcreate] = CreateWindow("RICHEDIT", NULL,       
                                                           WS_CHILD | WS_VISIBLE | WS_VSCROLL | WS_BORDER |
                                                           ES_LEFT | ES_MULTILINE | ES_AUTOVSCROLL | ES_READONLY, 
                                                           0, 0, 0, 0, /* set size in WM_SIZE message  */ 
                                                       hwnd, (HMENU) NULL, hInst, (LPSTR) NULL);
      nhelpwcreate++;
          /*
          SendMessage(dialog_help_edit, WM_SETTEXT, 0, (LPARAM) dialoghelptext);
          free(dialoghelptext);
   */
          break;
          
  case WM_SIZE:
        for (i = 0; i<nhelpwcreate; i++) {
           //printf("%s %d\n", dialoghelpname[i], i); 
           wnd = FindWindow("helpdialog", dialoghelpname[i]);
           //printf("%d %s %d %d %d\n", nhelpwcreate, dialoghelpname[i], i, hwnd, wnd);
           if (hwnd == wnd) break;
        }

        MoveWindow(dialog_help_edit[i], 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE);
        break;
  case WM_CLOSE:
        ShowWindow(hwnd, SW_HIDE);
        break;
  default:
        return (DefWindowProc(hwnd, message, wParam, lParam));
        break;
  }
  return 0;
}
                        
// Fonction de reception des messages en provenance des Panneaux de controle

int firstpass=1;
int NewPos, PrevPos;

LRESULT APIENTRY MainWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
  int i, j, k, nh, ind, cursel;
  size_t l;
  POINT pt;
  WORD idcom;
  DWORD dwPos;
  float value;
  HWND hwndCtl;
  char buffer[256];
  

  switch (message) {
 
  case WM_CREATE:

    
        if (dialogfont == NULL) {

          dialogfont = CreateFont(14, 0, 0, 0, 800, FALSE, FALSE, FALSE,
                                        ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                        DEFAULT_QUALITY, DEFAULT_PITCH, "Arial");
          
          //printf("CREATE mainheight %d viewportheight %d\n", mainheight, viewportheight);
        }
                
        if (SCB && firstpass) {
                
                si.cbSize = sizeof(si); 
        si.fMask  = SIF_RANGE | SIF_PAGE | SIF_POS; 
        si.nMin   = 0; 
        si.nMax   = mainheight - viewportheight;  // SG: subtract 100
        si.nPage  = 1; 
        si.nPos   = 0; 
        SetScrollInfo(hwnd, SB_VERT, &si, TRUE); 
                firstpass = 0; 
                //printf("Scroll range %d\n", si.nMax);
                return 0;//(DefWindowProc(hwnd, message, wParam, lParam));
        }
          
                
    SetWindowLong(hwnd, GWL_USERDATA, ncreate);
        ind = ncreate;
        ncreate++;

        //printf("Create win %d\n", ind);


     
        for (i = 0; i < NEL[ind]; i++) {
          j = index[ind][i];
          if (j == -1) return 0;

          labelw = CreateWindow("STATIC", widgets[j].generic.label,  LABELFLAGS,
                                           0, curheight[ind], labelwidth, labelheight,
                                       hwnd, (HMENU) NULL, hInst, (LPSTR) NULL);
      SetWidgetFont(labelw, dialogfont);

          switch(widgets[j].generic.type) {
          case SHOW:
                if (strlen(widgets[j].generic.label) != 0)
                        labelw = CreateWindow("STATIC", widgets[j].show.text,  LABELFLAGS,
                                                labelwidth+horzpad, curheight[ind], textwidth, labelheight,
                                                (HWND) hwnd, (HMENU) NULL, hInst, (LPSTR) NULL);
                else
                        labelw = CreateWindow("STATIC", widgets[j].show.text,  LABELFLAGS,
                                                0, curheight[ind], labelwidth+horzpad+textwidth, labelheight,
                                                (HWND) hwnd, (HMENU) NULL, hInst, (LPSTR) NULL);
                
                SetWidgetFont(labelw, dialogfont);
                curheight[ind]+=itemheight;
                break;
          case CHAIN:
                
            /* End user chain with 0  for display */
        for (l = widgets[j].chain.length-1; l >=0; l--)
          if (widgets[j].chain.userchain[l] != ' ')   break;
        widgets[j].chain.userchain[l+1] = 0;

                if (widgets[j].chain.editable) {
                        editw = CreateWindow("EDIT", widgets[j].chain.userchain,  CHAINFLAGS,
                                           labelwidth+horzpad, curheight[ind], textwidth, chainheight,
                                       (HWND) hwnd, (HMENU)(intptr_t)(FIRSTCHAINID+i), hInst, (LPSTR) NULL);
                    
                        
                }
                else
                        editw = CreateWindow("EDIT", widgets[j].chain.userchain,  CHAINFLAGS | ES_READONLY,
                                           labelwidth+horzpad, curheight[ind], textwidth, chainheight,
                                       (HWND) hwnd, (HMENU)(intptr_t)(FIRSTCHAINID+i), hInst, (LPSTR) NULL);
                
                
                
                SetWindowLong(editw, GWL_USERDATA, j);
                SetWidgetFont(editw, dialogfont);
                curheight[ind]+=itemheight;


                editwin[j] = editw;
        wpOrigEditProc = (WNDPROC)(intptr_t) SetWindowLong(editw, GWL_WNDPROC, (LONG)(intptr_t)EditSubclassProc);
                        //printf("PROC %d\n", wpOrigEditProc);
                break;
          case BROWSER:
            
                /* End user chain with 0  for display */
        for (l = widgets[j].file.length-1; l >=0; l--)
          if (widgets[j].file.userchain[l] != ' ')   break;
        widgets[j].file.userchain[l+1] = 0;
                editw = CreateWindow("EDIT", widgets[j].file.userchain,  CHAINFLAGS,
                                           labelwidth+horzpad, curheight[ind], 
                                           filechainwidth-horzpad, chainheight,
                                       (HWND) hwnd, (HMENU)(intptr_t)(FIRSTCHAINID+i), hInst, (LPSTR) NULL);

                SetWidgetFont(editw, dialogfont);
                
                buttonw = CreateWindow("BUTTON", "File", BUTTONFLAGS,
                       labelwidth+filechainwidth+horzpad, curheight[ind]-vertpad, 
                                           helpwidth, buttonheight,
                                       hwnd, (HMENU)(intptr_t)(FIRSTBUTTONID+i), hInst, (LPSTR) NULL);
                SetWindowLong(editw, GWL_USERDATA, j);
                SetWidgetFont(buttonw, dialogfont);
                curheight[ind]+=itemheight;
                editwin[j] = editw;
        wpOrigEditProc = (WNDPROC)(intptr_t)SetWindowLong(editw, GWL_WNDPROC, (LONG)(intptr_t)EditSubclassProc);
                break;
          
          case CHOICE:
            
                if (widgets[j].choice.mode == 0) {
             
                  /* End user chain with 0  for display */
                  for (l = widgets[j].choice.length-1; l >=0; l--)
                if (widgets[j].choice.userchoice[l] != ' ')   break;
          widgets[j].choice.userchoice[l+1] = 0;
                
                  editw = CreateWindow("COMBOBOX", NULL, COMBOBOXFLAGS,
                                                   labelwidth+horzpad, curheight[ind]-vertpad, textwidth,
                                                   widgets[j].choice.nchoices*choiceheight,
                                               (HWND) hwnd, (HMENU)(intptr_t)(FIRSTCHAINID+i), hInst, (LPSTR) NULL);
                }
                else
                  editw = CreateWindow("COMBOBOX", NULL, COMBOBOXFLAGS | CBS_DROPDOWNLIST,
                                                   labelwidth+horzpad, curheight[ind]-vertpad, textwidth,
                                                   widgets[j].choice.nchoices*choiceheight,
                                               (HWND) hwnd, (HMENU)(intptr_t)(FIRSTCHAINID+i), hInst, (LPSTR) NULL);
                        
                
                editwin[j] = editw;
        wpOrigChoiceProc = (WNDPROC)(intptr_t)SetWindowLong(editw, GWL_WNDPROC, (LONG)(intptr_t)ChoiceSubclassProc);
                
                for (k = 0; k <widgets[j].choice.nchoices; k++)
          SendMessage(editw, CB_ADDSTRING,
                      (WPARAM) 0,                  
                      (LPARAM) (LPCTSTR) widgets[j].choice.choices[k]);
                
                cursel = (int)SendMessage(editw, CB_FINDSTRINGEXACT,
                             (WPARAM) -1,                  
                             (LPARAM) (LPCTSTR) widgets[j].choice.userchoice);
        if (cursel != CB_ERR)
                  SendMessage(editw, CB_SETCURSEL,
                      (WPARAM) cursel,                  
                      (LPARAM) 0);
                SetWindowLong(editw, GWL_USERDATA, j);
                SetWidgetFont(editw, dialogfont);
                curheight[ind]+=itemheight;
                break;
          case LOGIC:
                
                  logicw = CreateWindow("BUTTON", (LPCTSTR) &clog[3*widgets[j].logic.userlogic], LOGICFLAGS,
                       labelwidth+horzpad, curheight[ind], textwidth, logicheight,
                                       hwnd, (HMENU)(intptr_t)(FIRSTBUTTONID+i), hInst, (LPSTR) NULL);
                  if (widgets[j].logic.userlogic) CheckDlgButton(hwnd, (FIRSTBUTTONID+i), BST_CHECKED);
                  SetWidgetFont(logicw, dialogfont);
                  curheight[ind]+=itemheight;
                  logicwin[j] = logicw;
                  SetWindowLong(logicw, GWL_USERDATA, j);
                  break;
          case SLIDER:
        
                  sprintf(dumstr, "%g", widgets[j].slider.uservalue);
                  editw = CreateWindow("EDIT", dumstr,  CHAINFLAGS,
                                           labelwidth+horzpad, curheight[ind], sliderchainwidth, chainheight,
                                       (HWND) hwnd, (HMENU)(intptr_t)(FIRSTCHAINID+i), hInst, (LPSTR) NULL);
                  
                  
                  editwin[j] = editw;
                  wpOrigEditProc = (WNDPROC)(intptr_t)SetWindowLong(editw, GWL_WNDPROC, (LONG)(intptr_t)EditSubclassProc);
                  
                  SetWidgetFont(editw, dialogfont);
                  sliderw = CreateWindow(TRACKBAR_CLASS, (LPCTSTR) "Trackbar Control", SLIDERFLAGS,
                       labelwidth+horzpad+sliderchainwidth, curheight[ind], sliderwidth, sliderheight,
                                           hwnd, (HMENU)(intptr_t)(FIRSTSLIDERID+i), hInst, (LPSTR) NULL);
                  sliderwin[j] = sliderw;
                  SendMessage(sliderw, TBM_SETRANGE, 
                      (WPARAM) TRUE,                   // redraw flag 
                      (LPARAM) MAKELONG(0, 100));      // min. & max. positions 
          SendMessage(sliderw, TBM_SETPOS, 
                      (WPARAM) TRUE,                   // redraw flag 
                      (LPARAM) (100*(widgets[j].slider.uservalue-widgets[j].slider.min)/
                                   widgets[j].slider.width));
                  SetWindowLong(editw, GWL_USERDATA, j);
                  SetWindowLong(sliderw, GWL_USERDATA, j);
                  curheight[ind]+=itemheight;
                  break;
          case BUTTON:
                  
                  
                  buttonw = CreateWindow("BUTTON", widgets[j].button.title, BUTTONFLAGS,
                       labelwidth+horzpad, curheight[ind]-vertpad, buttonwidth, buttonheight,
                                       hwnd, (HMENU)(intptr_t)(FIRSTCOMMANDID+i), hInst, (LPSTR) NULL);
                  
                  SetWidgetFont(buttonw, dialogfont);
                  buttonw = CreateWindow("BUTTON", widgets[j].button.moretxt, BUTTONFLAGS,
                       labelwidth+horzpad+buttonwidth, curheight[ind]-vertpad, morewidth, buttonheight,
                                       hwnd, (HMENU)(intptr_t)(FIRSTBUTTONID+i), hInst, (LPSTR) NULL);
                  SetWidgetFont(buttonw, dialogfont);
                  buttonw = CreateWindow("BUTTON", "Help", BUTTONFLAGS,
                       labelwidth+horzpad+buttonwidth+morewidth, curheight[ind]-vertpad, helpwidth, buttonheight,
                                       hwnd, (HMENU)(intptr_t)(FIRSTHELPID+i), hInst, (LPSTR) NULL);
                  SetWidgetFont(buttonw, dialogfont);
                  curheight[ind]+=itemheight;
                  break;
                default:
                  printf("type %d unknown in win %d\n", widgets[j].generic.type, ind);
                  break;        

          }
        }
        
        if (ind) {
          okw = CreateWindow("BUTTON", "Go",  BUTTONFLAGS,
                                         0, curheight[ind], mainwidth/3, itemheight,
                                         (HWND) hwnd, (HMENU)(intptr_t)(FIRSTOPTIONOK+ind-1), hInst, (LPSTR) NULL);
          SetWidgetFont(okw, dialogfont);
          cancelw = CreateWindow("BUTTON", "Dismiss",  BUTTONFLAGS,
                                             mainwidth/3, curheight[ind], mainwidth/3, itemheight,
                                             (HWND) hwnd, (HMENU)(intptr_t)IDCANCEL, hInst, (LPSTR) NULL);
        
          SetWidgetFont(cancelw, dialogfont);
          helpw = CreateWindow("BUTTON", "Help",  BUTTONFLAGS,
                                               2*mainwidth/3, curheight[ind], mainwidth/3+1, itemheight,
                                           (HWND) hwnd, (HMENU)(intptr_t)(FIRSTHELPID+ind), hInst, (LPSTR) NULL);
          SetWidgetFont(helpw, dialogfont);
          // create helpfen
        }
        
        return 0;
        break;
  
  break;
  case WM_HSCROLL:
         hwndCtl = (HWND) lParam;
         idcom = GetDlgCtrlID(hwndCtl);
         ind = GetWindowLong(hwnd, GWL_USERDATA);

     i = idcom - FIRSTSLIDERID;
         if ((i>=0) && (i<NEL[ind])) {
           j = index[ind][i];
           dwPos = (DWORD)SendMessage(hwndCtl, TBM_GETPOS, 0, 0); 

           value = widgets[j].slider.min + (widgets[j].slider.width/100)*dwPos;

       sprintf(dumstr, "%g", value);
           SetDlgItemText(hwnd, i+FIRSTCHAINID, (LPCTSTR) dumstr);

           for (i=0; i<nb_widgets; i++) {
             if ((i != j) && (strncmp(widgets[i].generic.variable, 
                    widgets[j].generic.variable, 15) == 0)) {
                  SendMessage(sliderwin[i], TBM_SETPOS, (WPARAM) TRUE, (LPARAM) dwPos);
                  SendMessage(editwin[i], WM_SETTEXT, 0, (LPARAM) dumstr);
             }
           }
         }
     break;
         // Gestion de la scrollbar dans le cas d'une fenetre plus grande que l'ecran
  case WM_VSCROLL:
        switch(LOWORD(wParam)) {
         case SB_PAGEUP: 
        yoffset+=itemheight;
                si.nPos-=itemheight;
                
                yoffset=min(0, yoffset);
            si.nPos = max(0, si.nPos); 
        //printf("Page Up %d\n", si.nPos);      
                
                MoveWindow(hWnd, 0, yoffset, mainwidth, mainheight, 1);
            
                si.fMask  = SIF_POS;
                SetScrollInfo(hwnd, SB_VERT, &si, TRUE); 
            break;
    case SB_PAGEDOWN: 
                yoffset -= itemheight;
                si.nPos += itemheight;
        
                yoffset = max(viewportheight - mainheight, yoffset);
                
                si.nPos = min(si.nPos, mainheight-viewportheight);
                //printf("Page Down %d\n", si.nPos);
        
                MoveWindow(hWnd, 0, yoffset, mainwidth, mainheight, 1); 
                
                si.fMask  = SIF_POS;
                SetScrollInfo(hwnd, SB_VERT, &si, TRUE);             
                break;
        case SB_LINEUP: 
                yoffset+=itemheight;
                si.nPos-=itemheight;
                
                yoffset=min(0, yoffset);
            si.nPos = max(0, si.nPos); 
        //printf("Line Up %d\n", si.nPos);      
                
                MoveWindow(hWnd, 0, yoffset, mainwidth, mainheight, 1);
            
                si.fMask  = SIF_POS;
                SetScrollInfo(hwnd, SB_VERT, &si, TRUE); 
                break;
        case SB_LINEDOWN: 
                yoffset -= itemheight;
                si.nPos += itemheight;
        
                yoffset = max(viewportheight - mainheight, yoffset);
                
                si.nPos = min(si.nPos, mainheight-viewportheight);
                //printf("Line Down %d\n", si.nPos);
        
                MoveWindow(hWnd, 0, yoffset, mainwidth, mainheight, 1); 
                
                si.fMask  = SIF_POS;
                SetScrollInfo(hwnd, SB_VERT, &si, TRUE);  
                break;
        case SB_THUMBPOSITION: 
        NewPos = HIWORD(wParam);
                yoffset = -(NewPos/itemheight)*itemheight;
                //printf("Thumb %d NewPos %d\n", NewPos, yoffset);
        
                MoveWindow(hWnd, 0, yoffset, mainwidth, mainheight, 1); 
                
                si.nPos = NewPos;
                si.fMask  = SIF_POS;
                SetScrollInfo(hwnd, SB_VERT, &si, TRUE);
                break;
 
    case SB_THUMBTRACK: 
                
                NewPos = HIWORD(wParam);

                
                if ((NewPos/itemheight)*itemheight != (PrevPos/itemheight)*itemheight) {
                  yoffset = -(NewPos/itemheight)*itemheight;
                  PrevPos = NewPos;
              //printf("Default %d\n", yoffset);
                  MoveWindow(hWnd, 0, yoffset, mainwidth, mainheight, 1);       
                
                  si.nPos = NewPos;
                  si.fMask  = SIF_POS;
                  SetScrollInfo(hwnd, SB_VERT, &si, TRUE);  
                }
        
           break;
        default:
                break;
        }
        break;

        
  case WM_HELP:
        GetCursorPos(&pt);
    ScreenToClient(hwnd, &pt);
        i = pt.y/itemheight;
        ind = GetWindowLong(hwnd, GWL_USERDATA);

        //printf("Help ...\n");

    if (i < NEL[ind]) {
          j = index[ind][i];
          if ((widgets[j].generic.type != BUTTON) && (widgets[j].generic.type != SHOW)) {
            //printf("win %d %s\n", ind, widgets[j].generic.variable);
                //dialoghelptext = (char*) malloc(80*sizeof(char));
                //strcpy(dialoghelptext, widgets[j].generic.variable);
                dialog_help(ind, widgets[j].generic.variable);
          }
        }
        break;
  case WM_COMMAND:
          
          idcom = LOWORD(wParam);
          
          if (idcom >= 1000) {
                
                i = idcom - 1000;
                if (i == 0) strcpy( return_command, main_command); // main go
                else if (i == 1) {
                  ERR_CODE = -3;
                }
                else if (i == 2) { 
                        dialog_help(0, 0); 
                        return 0; 
                }
                else {
                  j = i-3;
                  sprintf(return_command, "%s", command[j]);
            }
                close_dialog(hwnd, idcom);
          }       
          else if (idcom == IDCANCEL) {
                ind = GetWindowLong(hwnd, GWL_USERDATA);
                ShowWindow(hwnd, SW_HIDE);
          }
          
          
          // par ordre de plage d'indice decroissants
          else if (idcom >= FIRSTOPTIONOK) { // id du bouton OK d'une fenetre optionnelle
                  i = idcom - FIRSTOPTIONOK; 
                  j = INDEXCOM[i];
              sprintf(return_command, "%s", widgets[j].button.command);
                  close_dialog(hwnd, idcom);
          }
          else if (idcom >= FIRSTHELPID) { // id d'un bouton help d'une fenetre optionnelle ou principale
                  i = idcom - FIRSTHELPID;  // index de l'element dans la fenetre principale
                                                                        // ou indice absolu dans le tableau de chaines dialoghelpname
                  ind = GetWindowLong(hwnd, GWL_USERDATA);

                  if (ind == 0) {// fenetre prinicipale
                        for (nh = 1; nh < MAX_NB_DIALOG; nh++)
                          if (strcmp(widgets[index[0][i]].button.helptxt, dialoghelpname[nh]) == 0) break;
                        dialog_help(nh, 0);
                  }
                  else dialog_help(i, 0);
                  return 0;
          }
          else if (idcom >= FIRSTCOMMANDID) { 
                i = idcom - FIRSTCOMMANDID; // i index de l'element de commande dans la fenetre principale
                if (i<NEL[0]) {
                  j = index[0][i]; // j index dans la liste des widgets
              sprintf(return_command, "%s", widgets[j].button.command);
                  close_dialog(hwnd, idcom);
                }
          }
          else if (idcom >= FIRSTBUTTONID) { // boutons file, logic et more
        i = idcom - FIRSTBUTTONID;  // index de l'element dans la fenetre principale
                ind = GetWindowLong(hwnd, GWL_USERDATA);
                
                //printf("WIN %d\n", ind);

                if (i<NEL[ind]) {
                  j = index[ind][i]; // index de l'element dans la liste des widgets
      
                  if (widgets[j].generic.type == BROWSER) {
                        OPENFILENAME ofn;       // common dialog box structure
            char filter[MAX_PATH];
            char *all_files = "All files";
            size_t l;
                
                        
                        GetDlgItemText(hwnd, FIRSTCHAINID+i, (LPTSTR) buffer, 256);
                        
                        // Initialize OPENFILENAME
                        ZeroMemory(&ofn, sizeof(OPENFILENAME));
                        ofn.lStructSize = sizeof(OPENFILENAME);
                        ofn.hwndOwner = hwnd;
                        ofn.lpstrFile = buffer;
                        ofn.nMaxFile = sizeof(buffer);
            l = strlen( widgets[j].file.filter) + 1;
            strcpy( filter, widgets[j].file.filter);
            strcpy( filter + l, widgets[j].file.filter);
            strcpy( filter + 2 * l, all_files);
            strncpy( filter + 2 * l + strlen(all_files) + 1, "*.*", 5); /* 5 for 2 null terminated character */
                        ofn.lpstrFilter = filter;
                                //"All\0*.*\0Text\0*.TXT\0";
                        ofn.lpstrTitle = widgets[j].file.label;
                        ofn.nFilterIndex = 1;
                        ofn.lpstrFileTitle = NULL;
                        ofn.nMaxFileTitle = 0;
                        ofn.lpstrInitialDir = NULL;
                        ofn.Flags = OFN_PATHMUSTEXIST;
                   
                        // Display the Open dialog box. 

                        if (GetOpenFileNamePreview(&ofn)==TRUE) {
                          if ((strstr(ofn.lpstrFile, ".") == 0) && (strlen(ofn.lpstrFilter) != 0))
                                sprintf(buffer, "%s.%s", ofn.lpstrFile, ofn.lpstrFilter);
                          else sprintf(buffer, ofn.lpstrFile);

                          SetDlgItemText(hwnd, i+FIRSTCHAINID, (LPCTSTR) buffer);

                          for (i=0; i<nb_widgets; i++) {
                    if ((i != j) && (strncmp(widgets[i].generic.variable, 
                                                        widgets[j].generic.variable, 15) == 0))
                                  SendMessage(editwin[i], WM_SETTEXT, (WPARAM) 0, (LPARAM) buffer);

                          }
                        }
                  }
                  if (widgets[j].generic.type == LOGIC) {
                    hwndCtl = (HWND) lParam;
                    GetWindowText(hwndCtl, (LPTSTR) dumstr, 128);
                if (strncmp(dumstr, "Yes", 3) == 0) sprintf(dumstr, "%s", "No"); 
                        else sprintf(dumstr, "%s", "Yes"); 
                    SetWindowText(hwndCtl, (LPCTSTR) dumstr);
                        
                        
                        for (i=0; i<nb_widgets; i++) {
                  if ((i != j) && (strncmp(widgets[i].generic.variable, 
                                                        widgets[j].generic.variable, 15) == 0)) {
                                SetWindowText(logicwin[i], (LPCTSTR) dumstr);
                                if (strncmp(dumstr, "Yes", 3) == 0)
                                  SendMessage(logicwin[i], BM_SETCHECK, (WPARAM) BST_CHECKED, (LPARAM) 0);
                                else
                                  SendMessage(logicwin[i], BM_SETCHECK, (WPARAM) BST_UNCHECKED, (LPARAM) 0);
                          }
                        }
                         
                  }
                  if (widgets[j].generic.type == BUTTON) {
                    // More button pressed
                          //printf("Show window %d\n", IDWIN[j]);
                          ShowWindow(morewindows[IDWIN[j]], SW_SHOWNORMAL);
                  }
                }
          }
          /*
          else if (idcom >= FIRSTCHAINID) {
                i = idcom - FIRSTCHAINID;
                ind = GetWindowLong(hwnd, GWL_USERDATA);
                
                if (i<NEL[ind]) {
                  j = index[ind][i];
                  
                  hwndCtl = (HWND) lParam;
                  ind = GetWindowLong(hwndCtl, GWL_USERDATA);
                  printf("win %d %d ind %d %d\n", editwin[j], hwndCtl, ind, j);
                  
                }
          }*/

          else {
                return DefWindowProc(hwnd, message, wParam, lParam);
          }
        break;
  
  case WM_SYSCOMMAND: 
        if (wParam == SC_CLOSE) {
          ind = GetWindowLong(hwnd, GWL_USERDATA);
          if (ind) {
                ShowWindow(hwnd, SW_HIDE);
                return 0;
          }
        }
        return (DefWindowProc(hwnd, message, wParam, lParam));
        break;
    
  default:
        return (DefWindowProc(hwnd, message, wParam, lParam));
        break;
  }
  return 0;
}


DWORD DialogFunc(LPDWORD lpdwParam) 
{
    int i;
    MSG    msg;
    RECT rect;
    HMENU hMenu;
    int n_action = 0;

    InitCommonControls(); /* Necessary for TRACKBAR class */

    for (i = 0; i < nb_widgets; i++) {
        if ((widgets[i].generic.type == BUTTON) &&
            (widgets[i].button.showlength == 0)) {
                // Elements de la barre de menu
                num_actions[n_action] = i;
                sprintf(command[n_action], "%s", widgets[i].button.command);
                n_action++;
                index[widgets[i].generic.window_id][NEL[widgets[i].generic.window_id]] = -1;

        }
        else {
            // Boutons associes a d'autres fenetres
            if (widgets[i].generic.type == BUTTON) {
                IDWIN[i] = nmore; // Indice dans le tableau morewindows a partir du rang initial de l'element
                INDEXCOM[nmore] = i; // Rang initial de l'element a partir de l'indice de fenetre
                nmore++;

                sprintf(dialoghelpname[nmore], "%s", widgets[i].button.helptxt);
            }
            // Rang du widget(bouton ou non dans la fenetre window_id
            index[widgets[i].generic.window_id][NEL[widgets[i].generic.window_id]]=i;
        }
        NEL[widgets[i].generic.window_id]++;
    }

    mainwidth =  labelwidth+horzpad+textwidth; 
    mainheight = itemheight*(NEL[0]-n_action);

    hMenu = LoadMenu(hInst, (LPCTSTR) "dialog");
    for (i = 0; i < n_action; i++) {
        if (i == 0)
            AppendMenu(hMenu, MFT_STRING | MFT_MENUBARBREAK, 1003+i,
            widgets[num_actions[i]].button.title);
        else
            AppendMenu(hMenu, MFT_STRING, 1003+i,
            widgets[num_actions[i]].button.title);
    }

    commandheight = (n_action) ? GetSystemMetrics(SM_CYMENU) - 1: 0;

    i = 0;

    // Tant que la fenetre principale est trop grande, on reinitialise la structure rect,
    // on diminue la taille de la viewport et on reajuste rect aux nouvelles dimensions
    // de la viewport
    do {
        rect.left = 0; rect.right = mainwidth;
        rect.top = 0; rect.bottom = itemheight*(NEL[0]-n_action-i)+commandheight /* 2nd line menu */;
        i++;
        AdjustWindowRect(&rect, WS_OVERLAPPEDWINDOW, 1 /* Menu present*/);
    } while (rect.bottom - rect.top > screenheight);

    viewportheight = itemheight*(NEL[0]-n_action-i+1);


    SCB = (i > 1) ? 1 : 0; // Test si la scrollbar est necessaire 


    if (SCB) {
        FrameWnd = CreateWindowEx(
            WS_EX_CONTEXTHELP,
            TEXT("dialog"),
            TEXT(window_title[0]),
            WS_SYSMENU | WS_VSCROLL,
            CW_USEDEFAULT,
            CW_USEDEFAULT,
            rect.right - rect.left + 18,
            rect.bottom - rect.top - 2, /* 2nd line menu */
            NULL,
            hMenu,
            hInst,
            NULL);


        GetClientRect(FrameWnd, &rect);
        viewportheight = rect.bottom;
        //printf("Client height %d\n", viewportheight);  

        hWnd = CreateWindowEx(
            0,
            TEXT("dialog"),
            NULL,
            WS_CHILD | WS_VISIBLE,
            0,
            0,
            mainwidth,
            mainheight,
            (HWND) FrameWnd,
            NULL,
            hInst,
            NULL);

    }
    else {

        hWnd = CreateWindowEx(
            WS_EX_CONTEXTHELP,
            TEXT("dialog"),
            TEXT(window_title[0]),
            WS_SYSMENU,
            CW_USEDEFAULT,
            CW_USEDEFAULT,
            rect.right - rect.left,
            rect.bottom - rect.top - 2,
            NULL,
            hMenu,
            hInst,
            NULL);
    }



    /* printf("wind %d\n", hWnd);*/
    if (!hWnd) {
        printf("create window failed\n");
        return (FALSE);
    }


    for (i = 0; i<nmore; i++) {
        rect.left = 0; rect.right = mainwidth;
        rect.top = 0; rect.bottom = itemheight*(NEL[i+1]+1);
        AdjustWindowRect(&rect, WS_OVERLAPPEDWINDOW, 0/* Mo Menu */);   
        morewindows[i] = CreateWindowEx(WS_EX_CONTEXTHELP,
            TEXT("dialog"),
            TEXT(widgets[INDEXCOM[i]].button.moretxt), WS_SYSMENU,
            CW_USEDEFAULT, CW_USEDEFAULT, rect.right-rect.left,rect.bottom-rect.top,
            NULL, NULL, hInst, NULL);


        dialog_help_win[i] = CreateWindowEx(WS_EX_TOOLWINDOW, TEXT("helpdialog"),
            (LPCTSTR) dialoghelpname[i],  
            WS_OVERLAPPEDWINDOW,
            CW_USEDEFAULT, CW_USEDEFAULT,
            600, 300,
            (HWND) NULL, (HMENU) NULL, hInst, (LPSTR) NULL);
    }

    dialog_help_win[nmore] = CreateWindowEx(WS_EX_TOOLWINDOW, TEXT("helpdialog"),
        (LPCTSTR) dialoghelpname[nmore],  
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT,
        600, 300,
        (HWND) NULL, (HMENU) NULL, hInst, (LPSTR) NULL);



    if (SCB) {
        ShowWindow(FrameWnd, SW_SHOWNORMAL);
        /*UpdateWindow(hWnd);*/
        SetForegroundWindow(FrameWnd);
    }
    else {
        ShowWindow(hWnd, SW_SHOWNORMAL);
        /*UpdateWindow(hWnd);*/
        SetForegroundWindow(hWnd);
    }

    sic_post_widget_created( );

    /* Loop getting messages and dispatching them. */
    while (GetMessage(&msg,NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return 0;
}


void on_end_dialog( void)
{
  int i;

  for (i=0; i<NSTRUCT; i++) {
        IDWIN[i] = 0;
  }

  for (i=0; i<MAX_NB_DIALOG; i++) {
        NEL[i] = 0; 
        curheight[i] = 0;
  }

  nb_widgets = 0; nmore=0;
  ncreate=0; nhelpwcreate=0;
  firstpass = 1;
  ERR_CODE = 0;
}

FILE *TempFile;
char TempName[256];
char detach_help[256];

int lastid;

HWND win_help = NULL, helpedit; // fenetre de help de la barre de menu
HANDLE hMenuThrd;
char *helptext;
char dum[256];

LRESULT APIENTRY MenuWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
  UINT i;
  
  switch (message) {
  case WM_CREATE:
         if (strlen((LPSTR) lParam) != 0) {
          helpedit = CreateWindow("RICHEDIT", NULL,       
                                                           WS_CHILD | WS_VISIBLE | WS_VSCROLL | WS_BORDER |
                                                           ES_LEFT | ES_MULTILINE | ES_AUTOVSCROLL | ES_READONLY, 
                                                           0, 0, 0, 0, /* set size in WM_SIZE message  */ 
                                                       hwnd, (HMENU) NULL, hInst, (LPSTR) NULL);
      
          
          SendMessage(helpedit, WM_SETTEXT, 0, (LPARAM) helptext);
          free(helptext);
    }
        else {
          for (i = 0; i<NWINDOWS; i++) {
          if (detach_win[i].task == hMenuThrd)
                  detach_win[i].hWnd = hwnd;
              break;
      }
        }
        break;
  case WM_SIZE:
        if (hwnd == win_help)
          MoveWindow(helpedit, 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE /* Repaint */);
        break;
  case WM_CLOSE:
        ShowWindow(hwnd, SW_HIDE);
        return 0;
  case WM_COMMAND:{
        WORD idcom = LOWORD(wParam) - 100;
        struct _stat statb;
        FILE *fd;
        size_t numread;

    if ((idcom>=0) && (idcom < lastid)) {
                sic_post_command_text(menucommand[idcom]);
        }
        if (idcom == lastid) {

        for (i = 0; i<NWINDOWS; i++) {
            if (detach_win[i].hWnd == hwnd)
                break;
        }
        if (i == NWINDOWS)
            break;

                //printf("%d %s\n", i, detach_win[i].name);
                if (_stat(detach_win[i].name, &statb) == -1) {
          helptext = (char *) malloc(80*sizeof(char));
          sprintf(helptext, "%s", "Not found ..."); 
        }
        else {
          fd = fopen(detach_win[i].name, "r");
          helptext = (char *) malloc((unsigned)(statb.st_size+1));
          numread = fread(helptext, sizeof(char), statb.st_size+1, fd);
                  //printf( "Number of bytes read = %d\n", numread );

          helptext[statb.st_size] = 0;
          fclose(fd);
        }
        if (win_help == NULL) {
                  win_help = CreateWindowEx(WS_EX_TOOLWINDOW, TEXT("sicmenu"), detach_win[i].name,  
                                                            WS_OVERLAPPEDWINDOW,
                                                                        CW_USEDEFAULT, CW_USEDEFAULT,
                                                                        600, 300,
                                                                        (HWND) NULL, (HMENU) NULL, hInst, (LPSTR) "helptest");
              ShowWindow(win_help, SW_SHOWNORMAL);
                  SetForegroundWindow(win_help);
            }
                else {
                  ShowWindow(win_help, SW_SHOW);
          SetForegroundWindow(win_help);
                }

        
        }
        
        

        }
        break;
    
  default:
        return (DefWindowProc(hwnd, message, wParam, lParam));
        break;
  }
  return 0;

}


void update_variable( sic_widget_def_t *widget)
{
        
        int i, j;
        char dum[80];
//      FILE *fsg; // SG
//    fsg = fopen("dialog.txt","w");  // SG
//      fprintf(fsg,"UPDATE %s %d\n", widget->generic.variable, strlen(widget->generic.variable)); //SG

        for (i = 0; i < NSTRUCT; i++) {
                
                if (widgets[i].generic.type == 0) break;
                //printf("%s %d\n", 
                //      widgets[i].generic.variable, strlen(widgets[i].generic.variable));
                if (strncmp(widget->generic.variable, widgets[i].generic.variable, 15) == 0) {
                        switch(widgets[i].generic.type) {
                        case SLIDER:
                                widgets[i].slider.uservalue = 
                                        min(max(widgets[i].slider.min, widget->slider.uservalue), 
                                                widgets[i].slider.min + widgets[i].slider.width);
                                SendMessage(sliderwin[i], TBM_SETPOS, (WPARAM) TRUE,
                                (LPARAM) (100.*(widgets[i].slider.uservalue-widgets[i].slider.min)/widgets[i].slider.width));
                                sprintf(dum, "%g", widget->slider.uservalue);
                                SendMessage(editwin[i], WM_SETTEXT, 0, (LPARAM) dum);
                                break;
                        case LOGIC:
                                widgets[i].logic.userlogic = widget->logic.userlogic;
                                
                                if (widget->logic.userlogic) {
                                  SetWindowText(logicwin[i], (LPCTSTR) "Yes");
                                  SendMessage(logicwin[i], BM_SETCHECK, (WPARAM) BST_CHECKED, (LPARAM) 0);
                                }
                                else {
                                  SetWindowText(logicwin[i], (LPCTSTR) "No");
                                  SendMessage(logicwin[i], BM_SETCHECK, (WPARAM) BST_UNCHECKED, (LPARAM) 0);
                                }
                                break;
                        case CHAIN:
                                
                                strcpy(widgets[i].chain.userchain, widget->chain.userchain);
                                SendMessage(editwin[i], WM_SETTEXT, 0, (LPARAM) widget->chain.userchain);
                                break;
                        case CHOICE:
                                
                                // fprintf(fsg,"SendMessage %d %d %s\n", i, widgets[i].choice.mode, widget->choice.userchoice); //SG
                                // Si les choix sont non editables, on verifie si la mise a jour est valable

                                if (widgets[i].choice.mode == -1) {
//                                      fprintf(fsg,"CHOICE %d\n", strlen(widget->choice.userchoice)); // SG
                                        for (j = 0; j<widgets[i].choice.nchoices; j++) { 
                                                if (strncmp(widget->choice.userchoice,
                                                                        widgets[i].choice.choices[j],
                                                                        strlen(widgets[i].choice.choices[j])) == 0) {
                                                        SendMessage(editwin[i], CB_SETCURSEL, (WPARAM)j, (LPARAM)0);
                                                        strcpy(widgets[i].choice.userchoice, widget->choice.userchoice);
                                                        break;
                                                }       
                                        }
                                }       

                                if (widgets[i].choice.mode == 1) { // Choix non editable indexe
                                        if ((atoi(widget->choice.userchoice) >= 1) && (atoi(widget->choice.userchoice) <= widgets[i].choice.nchoices)) {
//                                              fprintf(fsg,"INDEXE %d\n", strlen(widget->choice.userchoice)); // SG
                                                SendMessage(editwin[i], CB_SETCURSEL, (WPARAM) (atoi(widget->choice.userchoice) - 1), (LPARAM)0);
                                                strcpy(widgets[i].choice.userchoice,
                                                           widgets[i].choice.choices[atoi(widget->choice.userchoice)-1]);
                                        }
                                }
                                
                                if (widgets[i].choice.mode == 0)  { // Choix editable
                                        SendMessage(editwin[i], WM_SETTEXT, 0, (LPARAM) widget->choice.userchoice);
                                        strcpy(widgets[i].choice.userchoice, widget->choice.userchoice);
                                }
                                break;
                        case BROWSER:
                                strcpy(widgets[i].file.userchain, widget->file.userchain);
                                SendMessage(editwin[i], WM_SETTEXT, 0, (LPARAM) widget->file.userchain);
                                break;
                        }
                }
        }
//      fclose(fsg) ; // SG
}

DWORD MenuFunc(const char *tempfilename) 
{
  
  HMENU hMenu, hPopupMenu;
  HWND win_menu;
  RECT rect;
  MSG msg;
  char wintitle[256]; 
  char winhelpfile[256];
  char line[256];
  char label[256];
  int i = 0;
  FILE *fd;
  //HDC hdcScreen;
  fd = fopen(tempfilename, "r");

  fgets(line, 256, fd);
  strncpy(wintitle, line, strlen(line) - 1);
  wintitle[strlen(line)-1] = 0 ; // SG, otherwise bad trailing characters
  fgets(line, 256, fd);
  strncpy(winhelpfile, line, strlen(line) - 1);
  winhelpfile[strlen(line)-1] = 0 ; // SG, otherwise bad trailing characters
  
  hMenu = CreateMenu();

  while (fgets(line, 256, fd) != NULL) {
    if (strncmp(line, "MENU", 4) == 0) {
      fgets(line, 256, fd);

      strncpy(label, line, strlen(line)-1);
      label[strlen(line) - 1] = 0;

          hPopupMenu = CreatePopupMenu();
          AppendMenu(hMenu, MF_STRING | MF_POPUP, (UINT_PTR) hPopupMenu, label);

          for (;;) {
            fgets(line, 256, fd);
            if (strncmp(line, "ENDMENU", 7) == 0) break;

            strncpy(label, line, strlen(line)-1);
            label[strlen(line) - 1] = 0;
            AppendMenu(hPopupMenu, MFT_STRING, 100+i, label);

                fgets(line, 256, fd);
                strncpy(menucommand[i], line, strlen(line)-1);
                menucommand[i][strlen(line) - 1] = 0;

                i++;
      }
        }
        else {
          strncpy(label, line, strlen(line)-1);
      label[strlen(line) - 1] = 0;
      AppendMenu(hMenu, MFT_STRING, 100+i, label);

      fgets(line, 256, fd);
          strncpy(menucommand[i], line, strlen(line)-1);
      menucommand[i][strlen(line) - 1] = 0;

          i++;
    }
  }
        
  AppendMenu(hMenu, MFT_STRING, 100+i, "Help");
  lastid = i;
  fclose(fd);
  if (unlink(tempfilename) == -1) MyErrorHandler("_unlink", "MenuFunc");
  
  rect.left = 0; rect.right = screenwidth -2*GetSystemMetrics(SM_CXFIXEDFRAME); rect.top = rect.bottom = 0;
  AdjustWindowRect(&rect, WS_CAPTION, 1 /* Menu present*/);
 
  win_menu = CreateWindowEx(WS_EX_TOOLWINDOW, TEXT("sicmenu"), wintitle,  
                                                  WS_CAPTION | WS_SYSMENU,
                                              0, 0,
                                                  rect.right - rect.left, rect.bottom - rect.top,
                                                  (HWND) NULL, hMenu, hInst, (LPSTR) NULL);
 
  ShowWindow(win_menu, SW_SHOWNORMAL);
  SetForegroundWindow(win_menu);
  //UpdateWindow(win_menu);

  while (GetMessage(&msg, NULL, 0, 0)) { 
   TranslateMessage(&msg);
   DispatchMessage(&msg); 
  }
  
  return 1;
}

BOOL APIENTRY DllMain(HANDLE hInstance, 
                                          DWORD ul_reason_being_called, LPVOID lpReserved)
{
  WNDCLASS  wc;
  HDC hdcScreen;
  int i;

  switch( ul_reason_being_called ) {
    case DLL_PROCESS_ATTACH:
        //CRT_INIT();
        //printf("Process attachment to dialogs DLL\n");
        
        hInst = hInstance;
        root_win = GetDesktopWindow();


    wc.style = 0;
        wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = hInst;
    wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = GetStockObject(LTGRAY_BRUSH);
        wc.lpszMenuName = NULL; 
        
        wc.lpfnWndProc = (WNDPROC)MenuWndProc;
        wc.lpszClassName = TEXT("sicmenu");
        if (!RegisterClass(&wc)) MyErrorHandler("RegisterClass", "DllMain");
        
    wc.lpfnWndProc = (WNDPROC)MainWndProc;
        wc.lpszClassName = TEXT("dialog");
        if (!RegisterClass(&wc)) MyErrorHandler("RegisterClass", "DllMain");

        wc.lpfnWndProc = (WNDPROC)HelpWndProc;
        wc.lpszClassName = TEXT("helpdialog");
        if (!RegisterClass(&wc)) MyErrorHandler("RegisterClass", "DllMain");

        fontheight = GetDialogBaseUnits();
        fontheight= fontheight>>16;
        //printf("Font Height %d\n", fontheight);
    /*
        if (SystemParametersInfo(SPI_GETBEEP, 0, &beep_on, 0))
                printf("BEEP %d\n", beep_on); 
    
          */
        DlgFont = GetStockObject(DEFAULT_GUI_FONT);
        if (DlgFont == NULL) printf("Could'nt get DEFAULT_GUI_FONT\n");
        VarFont = GetStockObject(ANSI_VAR_FONT);
        if (VarFont == NULL) printf("Could'nt get ANSI_VAR_FONT\n");
        
        hdcScreen = CreateDC("DISPLAY", (LPCSTR) NULL, 
            (LPCSTR) NULL, (CONST DEVMODE *) NULL); 
        
    screenheight = GetDeviceCaps(hdcScreen, VERTRES);
        screenwidth = GetDeviceCaps(hdcScreen, HORZRES);
        //printf("screenwidth %d screenheight %d\n", screenwidth, screenheight);
    DeleteDC(hdcScreen);

        for (i = 0; i < NWINDOWS; i++) strcpy(detach_win[i].name, "NONE");
        
        for (i = 0; i < NMENUCOMMAND; i++) { 
                command[i] = (char *) malloc(256*sizeof(char));
                menucommand[i] = (char *) malloc(256*sizeof(char));
        }
        for (i = 0; i < MAX_NB_DIALOG; i++) dialoghelpname[i] = (char *) malloc(80*sizeof(char));

        LoadLibrary("RICHED32.DLL");
        break;
/*
    case DLL_PROCESS_DETACH:
        CRT_INIT();
        break;
        case DLL_THREAD_ATTACH:
    break;
        case DLL_THREAD_DETACH:
    break;*/

  }
  return 1;
}

---