most.c

/*

MOST - Model Starter
---------------------------------------------------------------------------
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 <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <unistd.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xatom.h>
#include <X11/keysym.h>
#include <X11/XKBlib.h>

#define INT int

#define LINEMAX 256
typedef char String[LINEMAX];
String Buffer;

#ifndef MIN
#define MIN(a,b) ((a) < (b) ? (a) : (b))
#endif

#ifndef MAX
#define MAX(a,b) ((a) > (b) ? (a) : (b))
#endif

#define FULLARC (360 * 64)


#define WINDOW_WIDTH 820

/* Models */

#define PUMA    0
#define SAM     1
#define CAT     2
#define PLASIM  3
#define MODELS  4

/* Resolutions */

#define RES_T15 0
#define RES_T21 1
#define RES_T31 2
#define RES_T42 3
#define RES_T63 4
#define RESOLUTIONS 5

int PlasimSteps[RESOLUTIONS] =
{
   60,  // T15
   45,  // T21
   30,  // T31
   20,  // T42
   10   // T63
};

int PumaSteps[RESOLUTIONS] =
{
   60,  // T15
   60,  // T21
   45,  // T31
   30,  // T42
   15   // T63
};

int ResLat[RESOLUTIONS] =
{
   24,
   32,
   48,
   64,
   96
};

int Resolution = -1;

char *ShortModelName[MODELS] =
{
   "puma",
   "sam",
   "cat",
   "plasim"
};

char *FullModelName[MODELS] =
{
   "PUMA",
   "SAM",
   "CAT",
   "Planet Simulator"
};

int Model = PUMA;

#define ALL    -1
#define EARTH   0
#define MARS    1
#define EXO     2
#define PLANETS 3

char *PlanetName[PLANETS] =
{
   "Earth",
   "Mars",
   "Exo"
};

int Planet = EARTH;

double *OroEarth;  // Earth Orography T42 (128 x 64)
double *OroMars;   // Mars  Orography T42 (128 x 64)
double *OroPrep;   // Preprocessed Orography

Pixmap OpmEarth;
Pixmap OpmMars;
Pixmap OpmPrep;

double RevGra = 1.0 / 9.81;

/* Object types */

#define SEL_TEXT   1
#define SEL_CHECK  2
#define SEL_INT    3
#define SEL_REAL   4
#define SEL_TEVA   5
#define SEL_PLANET 6

struct ItemStruct
{
   char   list[80];      // Name of namelist
   char   name[80];      // Name of variable
   char   text[80];      // Text    value
   float  pvec[PLANETS]; // Planetary parameter
   double rval;          // Real    value
   int    ival;          // Integer value
   int    model;         // Model
   int    flag;          // Flag
};

struct SelStruct
{
   struct SelStruct  *Next; // Link to next Sel
   struct SelStruct  *Prev; // Link to previous Sel
   struct ItemStruct *Item; // Link to item
   int type;                // Type (TEXT,CHECK,INT,REAL)
   int x;                   // x coordinate of box
   int y;                   // y coordinate of box
   int h;                   // height of box
   int w;                   // width of box
   int xo;                  // x offset
   int xt;                  // x coordinate for text
   int yt;                  // y coordinate for text
   int lt;                  // length of text
   int iv;                  // integer value of box content
   int div;                 // default integer value
   int no;                  // 1: not selectable
   int teco;                // text colour
   int edco;                // edit column (cursor)
   int hide;                // 1: don't show
   float fv;                // floating value of box content
   float dfv;               // default floating value
   float fpl[PLANETS];      // planet dependent floats
   int   *piv;              // pointer to linked integer variable
   float *pfv;              // pointer to linked float   variable
   char text[80];           // text to display
   char teva[16];           // box content
};

struct SelStruct SelStart;
struct SelStruct SelModels[MODELS];
struct SelStruct *CursorSel;
struct SelStruct *ComEnd;
struct SelStruct *SelAno;
struct SelStruct *SelTgr;
struct SelStruct *SelOro;
struct SelStruct *SelMod;
struct SelStruct *SelRes; 
struct SelStruct *SelOce;
struct SelStruct *SelLsg;
struct SelStruct *SelIce;
struct SelStruct *SelAnn;
struct SelStruct *SelPlanet[PLANETS];
struct SelStruct *SelSYear;
struct SelStruct *SelCPU;
struct SelStruct *SelMulti;
struct SelStruct *SelLat2;


// Title lines for the entry of resolution

char *DimText1;
char *DimText2;
char *DimText3;

#define DIMLOGO 4

struct SymbolStruct 
{
   int     x;     // x pos
   int     y;     // y pos
   int     w;     // width
   int     h;     // height
   int     b;     // background color
   int     f;     // foreground color
   char  **i;     // image
   char   *d;     // image data
   XImage *X;     // X-Image
   char   t[2][80]; // caption
} Logo[DIMLOGO];
  
int Logos;

struct ColorStrip
{
   double  Lo;
   double  Hi;
   char *Name;
   unsigned long pixel;
};

unsigned long WinBG = 0; // Black background
unsigned long TextC = 0; // Text color
unsigned long HeadC = 0; // Heading color

#define DIMFRAME 3

int Frames;

struct FrameStruct 
{
   void (*Action)();
   Pixmap pixmap;   // pixmap
   int    x;        // x pos
   int    y;        // y pos
   int    w;        // width
   int    h;        // height
   int    b;        // background color
   int    f;        // foreground color
   int    xs;       // x pos  selection
   int    ys;       // y pos  selection
   int    ws;       // width  selection
   int    hs;       // height selection
   char   t[3][80]; // text
} Frame[DIMFRAME];
  
int FrameNo;
int Buttons;
int Button1Down = 1;

#define DIMBUTTON 5

struct ButtonStruct 
{
   void (*Action)();
   int    x;        // x pos
   int    y;        // y pos
   int    w;        // width
   int    h;        // height
   int    b;        // background color
   int    f;        // foreground color
   char   t[3][80]; // text
} Button[DIMBUTTON];
  
int Buttons;


/* Coordinates */

int opbox_x;
int opbox_y;
int opbox_w;
int opbox_h;

int nlbox_x;
int nlbox_y;
int nlbox_w;
int nlbox_h;

int nlpos_x;
int nledi_x;

int sfbox_x;
int sfbox_y;
int sfbox_w;
int sfbox_h;
int sfbox_b;

int bubox_x;
int bubox_y;
int bubox_w;
int bubox_h;

int CursorCol;
int LastSel;
int EdiKeyCode;

#define NL_MAX_ITEMS 100

int NL_items = 0;
struct ItemStruct NL_list[NL_MAX_ITEMS];

int BigEndian;
int Oce;
int Ice;
int Lsg;
int SimStart;
int SimYears;
int nreadsr;
int noutput;
int ndebug;
int nprec;
int ngui;
int noro = 1;
int OroAno;
int OroClear;
int OroAqua;
int TgrAno;
int nac;
int Preprocessed;
int SAMindex;
int ScreenHeight;
int Expert = 1;
int CatEnabled;
int SamEnabled;
int LsgEnabled;
int ModeRadiusSq;
int ForceRebuild;
int dxsh;
int dxs2;
int Yoden;                // PUMA setup for Yoden experiment
int CatSim = 51;          // simulation setup number for CAT

/* Special parameter */

int Latitudes       = 32; // Number of latitudes in atmosphere
int Latitude2       = 32; // Number of latitudes for 2nd. instance
int Levels          = 10; // Number of levels in atmosphere
int Cores           =  1; // Number of cores for parallel version
int Multirun        =  1; // Number of coupled runs
int MultirunEnabled =  0; // Multirun module present?
int Truncation      = 21; // Spectral truncation computed from Latitudes

unsigned Seed;

char cfg_file[256]      = "most_last_used.cfg";
char exec_name[256]     = "most_puma.x";
char exec_nam2[256]     = "most_puma.x";  // 2nd. instance
char exec_ppp[256]      = "most_ppp.x";
char oro_name[256]      = "N064_surf_0129.sra"; // Orography in T42 resolution
char namelist_name[256] = "puma_namelist";
char diag_name[256]     = "puma_diag";
char outp_name[256]     = "puma_output";
char build_name[256]    = "most_puma_build";
char build_ppp[256]     = "most_ppp_build";
char run_name[256]      = "most_puma_run";
char run_ppp[256]       = "most_ppp_run";
char res_name[256]      = "resmod.f90";
char hostname[256]      = "localhost";
char mpirun[256]        = "mpirun";       // "openmpirun" for Open MPI

int ScreenN;
time_t CurrentDate;

Display *display;
unsigned int ScreenW,ScreenH;
int SmallScreen = 1;

static char *progname = "Most";

int DimX;
int DimY;
int DimTr = 21;
int DimSH = 11 * 23;
int DimSE = 11 * 23 + 2;
int ScreenD;
int OffX;
int OffY = 0;
int WinXSize;
int WinYSize;
int WhitePix;
int BlackPix;

int *Ampli;
int *ModeX;
int *ModeY;
int *ModeM;
int *ModeN;

Colormap colormap;

XColor xcolor1,xcolor2;
XColor Red,Green,Blue,Grey,LightRed,DarkRed,LightBlue,DarkBlue;
XColor LightGreen,DarkGreen,Yellow,Cyan,Dummy;

Window Cow; // Control bar
XTextProperty WinconName1;

XEvent WinEvent;

XSizeHints CowSizeHints;
int count;
XEvent report;
GC gc;
char ModFontName[80] = "-misc-fixed-bold-r-normal--15-*-*-*-*-*-*-*";
char FixFontName[80] = "-misc-fixed-bold-r-normal--15-*-*-*-*-*-*-*";
char BigFontName[80] = "-misc-fixed-medium-r-normal--20-*-*-*-*-*-*-*";
//char ModFontName[80] = "9x15bold";
//char FixFontName[80] = "9x15bold";
//char BigFontName[80] = "10x20";
XFontStruct *ModFont;
XFontStruct *FixFont;
XFontStruct *BigFont;
XFontStruct *SamFont;
int ModFontHeight;
int FixFontHeight;
int BigFontHeight;
int ModFontWidth;
int FixFontWidth;
int BigFontWidth;
int ModFontAscent;
int FixFontAscent;
int BigFontAscent;
int EdiFirstKey;
int EdiLastKey;
int EdiSymsPerKey;
int NumLockMask;
int ModeSwitchMask;

int Debug = 0;

KeySym *EdiKeymap;
XModifierKeymap *Mok;

char *display_name = NULL;
XWMHints wm_hints;
XClassHint class_hints;
Atom Delwin;

char *mona[12] =
{
   "Jan","Feb","Mar",
   "Apr","May","Jun",
   "Jul","Aug","Sep",
   "Oct","Nov","Dec"
};

char datch[32];

struct MapImageStruct
{
   char   *d; // Bitmap data
   int     w; // Image width
   int     h; // Image height
   int     f; // Rotation factor
   float   l; // Reference longitude
   float   r; // Rotation speed [deg/step]
   XImage *X; // XImage structure
};

struct MapImageStruct MapHRE; // Hires (2560x1280) Earth image
struct MapImageStruct MapHRM; // Hires (         ) Mars  image
struct MapImageStruct MapLRE; // Lores azimuthal   Earth image
struct MapImageStruct MapLRM; // Lores azimuthal   Mars  image
struct MapImageStruct MapLRK; // Lores azimuthal   Kepler-16
struct MapImageStruct MapLRL; // Lores azimuthal   Kepler-186b

/* Isoarea data */

#define TOLELO 0x0001
#define TOLEHI 0x0002
#define TORILO 0x0004
#define TORIHI 0x0008
#define BOLELO 0x0010
#define BOLEHI 0x0020
#define BORILO 0x0040
#define BORIHI 0x0080
#define TOLEIN 0x0100
#define TOREIN 0x0200
#define BOLEIN 0x0400
#define BOREIN 0x0800

#define IPX(l,m,h) (VGAX * (x + (l-m) / (l-h)))
#define IPY(l,m,h) (VGAY * (y + (l-m) / (l-h)))

int nlon = 128;
int nlat =  64;
int nlev =   5;

int *Flag;

double VGAX;
double VGAY;

Pixmap pix;

/* Orography units are [m2/s2] */

struct ColorStrip OroStrip[] =
{
   {-99999.0,   80.0,"DarkBlue"},
   {    80.0,  800.0,"green"},
   {   800.0, 1600.0,"brown"},
   {  1600.0, 2400.0,"orange"},
   {  2400.0,99999.0,"white"},
   {     0.0,     0.0,NULL}
};

struct ColorStrip OroMarsStrip[] =
{
   {-99999.0,-16000.0,"yellow"},
   {-16000.0,-12000.0,"RoyalBlue4"},
   {-12000.0, -8000.0,"RoyalBlue3"},
   { -8000.0, -4000.0,"RoyalBlue2"},
   { -4000.0,     0.0,"RoyalBlue1"},
   {     0.0,  4000.0,"dark green"},
   {  4000.0,  8000.0,"light green"},
   {  8000.0, 12000.0,"brown"},
   { 12000.0, 16000.0,"orange"},
   { 16000.0, 99999.0,"white"},
   {     0.0,     0.0,NULL}
};

struct ColorStrip GibbStrip[] =
{
   {-99999.0,    0.0,"DarkBlue"},
   {     0.0,99999.0,"green"},
   {     0.0,     0.0,NULL}
};


struct ColorStrip TStrip[] =
{
   {-99.0,-15.0,"RoyalBlue4"},
   {-15.0,-20.0,"RoyalBlue3"},
   {-10.0, -5.0,"RoyalBlue2"},
   { -5.0, -0.1,"RoyalBlue1"},
   { -0.1,  0.1,"yellow"},
   {  0.1,  5.0,"IndianRed1"},
   {  5.0, 10.0,"IndianRed2"},
   { 10.0, 15.0,"IndianRed3"},
   { 15.0, 20.0,"IndianRed4"},
   { 20.0,999.0,"red"},
   {  0.0,  0.0,NULL}
};

void DoNothing(void)
{
   printf("Do nothing\n");
}


void ChangeModel(int NewMo)
{
   int i;
   struct SelStruct *Sel;

   if (NewMo < 0) // locate active model
   {
      NewMo = PUMA; // default if none is specified
      for (i=0 , Sel = SelMod ; i < MODELS; ++i , Sel = Sel->Next)
      {
         if (Sel->iv == 1) NewMo = i;
      }
   }

   ComEnd->Next = &SelModels[NewMo];
   ComEnd->Next->Prev = ComEnd;

   for (i=0 , Sel = SelMod ; i < MODELS; ++i , Sel = Sel->Next)
   {
      if (i == NewMo) Sel->iv = 1;
      else            Sel->iv = 0;
   }
   if (NewMo == PUMA || NewMo == SAM)
   {
       SelAno->hide = 0;
       SelAnn->no   = 0;
       SelOce->no   = 1;
       SelIce->no   = 1;
       SelOro->no   = 0;
       SelSYear->no = 1;
       if (SelLsg) SelLsg->no   = 1;
       for (i=0 ; i < PLANETS ; ++i) SelPlanet[i]->no = 1;
   }
   if (NewMo == PLASIM)
   {
       SelAno->hide = 1;
       SelAnn->no   = 1;
       SelOro->no   = 1;
       SelSYear->no = 0;
       if (Expert)
       {
          SelOce->no   = 0;
          SelIce->no   = 0;
          if (SelLsg) SelLsg->no = 0;
          for (i=0 ; i < PLANETS ; ++i) SelPlanet[i]->no = 0;
       }
   }
   if (Expert)
   {
      if (NewMo == CAT)
      {
         strcpy(DimText1,"NGX          ");
         strcpy(DimText2,"NGY          ");
      }
      else
      {
         strcpy(DimText1,"Latitudes #1 ");
         strcpy(DimText2,"Latitudes #2 ");
      }
   }
   else
   {
      if (NewMo == CAT)
      {
         strcpy(DimText1,"[  64 x 64  ]");
         strcpy(DimText2,"[ 256 x 256 ]");
         strcpy(DimText3,"[1024 x 1024]");
      }
      else
      {
         strcpy(DimText1,"T21   [64x32]");
         strcpy(DimText2,"T31   [96x48]");
         strcpy(DimText3,"T42  [128x64]");
      }
   }
   Model = NewMo;
}


void WriteSettings(void)
{
   int   mxtl;
   char  tb[80];
   FILE *fp;
   struct SelStruct *Sel;

   fp = fopen("most_last_used.cfg","w");
   if (!fp) return;

   fprintf(fp,"[MoSt 17 - configuration file] created %s\n",ctime(&CurrentDate));

   mxtl = 0;
   for (Sel = &SelStart ; Sel ; Sel = Sel->Next)
   {
      if (Sel->type != SEL_TEXT ) mxtl = MAX(mxtl,strlen(Sel->text));
   }

   for (Sel = &SelStart ; Sel ; Sel = Sel->Next)
   {
      if (Sel->type == SEL_TEXT ) fprintf(fp,"\n[%s]\n",Sel->text);
      else
      {
         memset(tb,' ',sizeof(tb));
         strncpy(tb,Sel->text,strlen(Sel->text));
         tb[mxtl] = 0;
         fprintf(fp,"%s = ",tb);
      }
           if (Sel->type == SEL_CHECK) fprintf(fp,"%6d\n",Sel->iv);
      else if (Sel->type == SEL_INT  ) fprintf(fp,"%6d\n",Sel->iv);
      else if (Sel->type == SEL_TEVA ) fprintf(fp,"%s\n",Sel->teva);
      else if (Sel->type == SEL_REAL || Sel->type == SEL_PLANET)
      {
         if (Sel->type == SEL_PLANET) Sel->fv = Sel->fpl[Planet];
         if (fabs(Sel->fv) >= 1.0 && fabs(Sel->fv) < 9000.0)  fprintf(fp,"%10.4f\n",Sel->fv);
         else                                                 fprintf(fp,"%10.4e\n",Sel->fv);
      }
   }
   fclose(fp);
}


void FormatReal(float fv, char *text)
{
   if (fv == 0.0                      ||
      (fv >   0.001 && fv < 99999.0)  ||
      (fv > -9999.0 && fv <  -0.001))
   {
      sprintf(text,"%11.4f",fv);
           if (!strcmp(text+8,"000")) text[ 8] = 0;
      else if (!strcmp(text+9,"00" )) text[ 9] = 0;
      else if (text[10] == '0')       text[10] = 0;
   }
   else
   {
      sprintf(text,"%11.4e",fv);
   }
}


void UpdateSelections(struct SelStruct *Sel)
{
   char text[80];
   int selx;

   selx = 0;

   for (; Sel ; Sel = Sel->Next)
   {
      if (Sel == ComEnd->Next) selx = 1;
      if (selx) Sel->x = nledi_x;
      if (Sel->type == SEL_INT )
      {
         sprintf(text,"%10d",Sel->iv);
         strcpy(Sel->teva,text+10-Sel->edco);
         if (Sel->piv) *Sel->piv = Sel->iv;
      }
      if (Sel->type == SEL_REAL || Sel->type == SEL_PLANET)
      {
         if (Sel->type == SEL_PLANET) Sel->fv = Sel->fpl[Planet];
         FormatReal(Sel->fv,text);
         strcpy(Sel->teva,text);
      }
   }
   // if (SelLat2) SelLat2->no = (SelMulti->iv != 2) ;
}


void ChangePlanet(int NewPlanet)
{
   struct SelStruct *Sel;

   SelPlanet[Planet]->iv = 0;
   Planet = NewPlanet;
   SelPlanet[Planet]->iv = 1;
   strcpy(SelModels[PLASIM].text,PlanetName[Planet]);
   SelModels[PLASIM].lt = strlen(PlanetName[Planet]);

   for (Sel = &SelStart ; Sel ; Sel = Sel->Next)
   {
      if (Sel->type == SEL_PLANET)
      {
         Sel->fv = Sel->fpl[Planet];
      }
   }
   UpdateSelections(ComEnd->Next);
}


int ReadSettings(char *fn)
{
   int pl;
   char  tb[80];
   char *eq;
   FILE *fp;
   struct SelStruct *Sel;

   fp = fopen(fn,"r");
   if (!fp)
   {
      printf("\nUsing default configuration\n");
      return 0;
   }

   fgets(tb,sizeof(tb),fp);
   if (strncmp(tb,"[MoSt",5))
   {
      printf("\nFileheader is: %s\n",tb);
      printf("Expected     : [MoSt ...]\n");
      printf("Using default configuration\n");
      fclose(fp);
      return 0;
   }

   while (!feof(fp))
   {
      eq = strchr(tb,'=');
      if (eq)
      {
         for (Sel = &SelStart ; Sel ; Sel = Sel->Next)
         {
            if (!strncmp(tb,Sel->text,strlen(Sel->text)))
            {
               if (!isalnum(tb[strlen(Sel->text)]))
               {
                  if (Sel->type == SEL_REAL || Sel->type == SEL_PLANET)
                  {
                     Sel->fv = atof(eq+1);
                     if (Sel->pfv) *Sel->pfv = Sel->fv;
                     if (Sel->type == SEL_PLANET) Sel->fpl[Planet] = Sel->fv;
                  }
                  else
                  {
                     Sel->iv = atoi(eq+1);
                     if (Sel->piv) *Sel->piv = Sel->iv;
                  }
               }
            }
         }
      }
      else if (!strncmp(tb,"[Modules]",9)) ChangeModel(-1);
      else
      {
         for (pl=0 ; pl < PLANETS ; ++pl)
         {
            if (!strncmp(tb+1,PlanetName[pl],strlen(PlanetName[pl])) && pl != Planet)
               ChangePlanet(pl);
         }
      }
      fgets(tb,sizeof(tb),fp);
   }
   fclose(fp);
   
   return 1;
}


void Exit(void)
{
   int i;

   WriteSettings();
   // XNextEvent(display,&WinEvent);
   // XCloseDisplay(display);
   exit(0);
}


void AbortMessage(char *s)
{
   printf("\n\n%s\n",s);
   exit(1);
}

void Abort(void)
{
   Exit();
}


void InitNextSelection(struct SelStruct *Sel, int dy, char *t)
{
   Sel->type = Sel->Prev->type;
   Sel->y    = Sel->Prev->y + dy;
   Sel->h    = Sel->Prev->h;
   Sel->w    = Sel->Prev->w;
   Sel->xo   = Sel->Prev->xo;
   Sel->yt   = Sel->Prev->yt + dy;
   strcpy(Sel->text,t);
   Sel->lt   = strlen(Sel->text);
   Sel->teco = Sel->Prev->teco;
   Sel->edco = Sel->Prev->edco;
}


void CursorOn(void)
{
   int x,y,w,h;

   if (CursorSel)
   {
      x = CursorSel->x + CursorCol * FixFontWidth;
      y = CursorSel->y;
      w = CursorSel->w;
      h = CursorSel->h;

      XSetForeground(display,gc,Red.pixel);
      XDrawRectangle(display,Cow,gc,x,y,FixFontWidth,h);
      XDrawRectangle(display,Cow,gc,x-1,y-1,FixFontWidth+2,h+2);
   }
}
   

void RemoveBlanks(char *p)
{
   int l;

   l = strlen(p);
   while (l && p[l-1] == ' ') p[--l] = 0;
}

      
struct SelStruct *NewSel(struct SelStruct *OldSel)
{
   struct SelStruct *Sel;

   Sel = calloc(1,sizeof(struct SelStruct));
   OldSel->Next = Sel;
   Sel->Prev = OldSel;
   return Sel;
}


void NL_i(int m, char *list, char *name, int i)
{
   if (NL_items > NL_MAX_ITEMS-2)
   {
      printf("\n*** Error ***\n");
      printf("Number of namelist items exceeds %d \n",NL_MAX_ITEMS);
      printf("Increase NL_MAX_ITEMS in most,c\n");
      exit(1);
   }
   NL_list[NL_items].model  = m;
   strcpy(NL_list[NL_items].list,list);
   strcpy(NL_list[NL_items].name,name);
   NL_list[NL_items].flag = SEL_INT;
   NL_list[NL_items].ival = i;
   NL_list[NL_items].rval = 0.0;
   NL_list[NL_items].text[0] = 0;
   NL_items++;
}


void NL_r(int m, char *list, char *name, double r)
{
   if (NL_items > NL_MAX_ITEMS-2)
   {
      printf("\n*** Error ***\n");
      printf("Number of namelist items exceeds %d \n",NL_MAX_ITEMS);
      printf("Increase NL_MAX_ITEMS in most,c\n");
      exit(1);
   }
   NL_list[NL_items].model = m;
   strcpy(NL_list[NL_items].list,list);
   strcpy(NL_list[NL_items].name,name);
   NL_list[NL_items].flag = SEL_REAL;
   NL_list[NL_items].ival = 0;
   NL_list[NL_items].rval = r;
   NL_list[NL_items].text[0] = 0;
   NL_items++;
}


void NL_p(char *name, float r[])
{
   if (NL_items > NL_MAX_ITEMS-2)
   {
      printf("\n*** Error ***\n");
      printf("Number of namelist items exceeds %d \n",NL_MAX_ITEMS);
      printf("Increase NL_MAX_ITEMS in most,c\n");
      exit(1);
   }
   NL_list[NL_items].model = PLASIM;
   strcpy(NL_list[NL_items].list,"planet");
   strcpy(NL_list[NL_items].name,name);
   NL_list[NL_items].flag = SEL_PLANET;
   NL_list[NL_items].ival = 0;
   NL_list[NL_items].rval = 0.0;
   NL_list[NL_items].text[0] = 0;
   memcpy(NL_list[NL_items].pvec,r,sizeof(float) * PLANETS);
   NL_items++;
}


void NL_t(int m, char *list, char *name, char *t)
{
   if (NL_items > NL_MAX_ITEMS-2)
   {
      printf("\n*** Error ***\n");
      printf("Number of namelist items exceeds %d \n",NL_MAX_ITEMS);
      printf("Increase NL_MAX_ITEMS in most,c\n");
      exit(1);
   }
   NL_list[NL_items].model = m;
   strcpy(NL_list[NL_items].list,list);
   strcpy(NL_list[NL_items].name,name);
   NL_list[NL_items].flag = SEL_TEVA;
   NL_list[NL_items].ival = 0;
   NL_list[NL_items].rval = 0.0;
   strcpy(NL_list[NL_items].text,t);
   NL_items++;
}


//                             Earth       Mars          Exo
float eccen_vec[PLANETS] = {   0.016715,   0.09341233,   0.0};
float mvelp_vec[PLANETS] = { 102.7     , 336.04084   ,   0.0};
float obliq_vec[PLANETS] = {  23.44    ,  25.19      ,   0.0};
float gsol0_vec[PLANETS] = {1367.0     , 595.0       ,1000.0};

void InitNamelist(void)
{
   // Planet Simulator

   NL_p("ECCEN" , eccen_vec);
   NL_p("MVELP" , mvelp_vec);
   NL_p("OBLIQ" , obliq_vec);
   NL_p("GSOL0" , gsol0_vec);

   NL_i(PLASIM,"planet" ,"NFIXORB" ,  0);
   NL_r(PLASIM,"radmod" ,"CO2"     ,360.0);
   NL_i(PLASIM,"plasim" ,"KICK"    ,  1);
   NL_i(PLASIM,"plasim" ,"MPSTEP"  ,  0);
   NL_i(PLASIM,"plasim" ,"NAQUA"   ,  0);
   NL_i(PLASIM,"plasim" ,"NDIAG"   ,  0);
   NL_i(PLASIM,"plasim" ,"NGUIDBG" ,  0);
   NL_i(PLASIM,"plasim" ,"NQSPEC"  ,  1);
   NL_i(PLASIM,"plasim" ,"NVEG"    ,  0);
   NL_i(PLASIM,"plasim" ,"NWPD"    ,  1);
   NL_i(PLASIM,"plasim" ,"NPRINT"  ,  0);
   NL_i(PLASIM,"plasim" ,"NSYNC"   ,  1);
   NL_i(PLASIM,"rainmod","NCLOUDS" ,  1);
   NL_i(PLASIM,"rainmod","NSTORAIN",  0);
   NL_r(PLASIM,"plasim" ,"SYNCSTR", 0.0);

   // SAM

   NL_i(SAM,"sam","KICK"   ,  1);
   NL_i(SAM,"sam","NAFTER" , 24);
   NL_i(SAM,"sam","NDEL"   ,  8);
   NL_i(SAM,"sam","NDIAG"  ,240);
   NL_i(SAM,"sam","NEXP"   ,  4);
   NL_i(SAM,"sam","NGUIDBG",  0);
   NL_i(SAM,"sam","NTSPD"  ,  0);
   NL_r(SAM,"sam","DISP"   ,0.0);
   NL_r(SAM,"sam","ROTSPD" ,1.0);

   // PUMA

   NL_i(PUMA,"puma","KICK"   ,  1);
   NL_i(PUMA,"puma","MPSTEP" ,  0);
   NL_i(PUMA,"puma","NDEL"   ,  6);
   NL_i(PUMA,"puma","NDHEAT" ,  0);
   NL_i(PUMA,"puma","NDIAG"  ,  0);
   NL_i(PUMA,"puma","NEWSR"  ,  0);
   NL_i(PUMA,"puma","NGUIDBG",  0);
   NL_i(PUMA,"puma","NHELSUA",  0);
   NL_i(PUMA,"puma","NSYNC"  ,  0);
   NL_i(PUMA,"puma","NWPD"   ,  1);
   NL_r(PUMA,"puma","DTEP"   , 60);
   NL_r(PUMA,"puma","DTNS"   ,-70.0);
   NL_r(PUMA,"puma","DTROP"  , 12000.0);
   NL_r(PUMA,"puma","DTTRP"  ,  2.0);
   NL_r(PUMA,"puma","SYNCSTR",  0.0);
   NL_r(PUMA,"puma","ROTSPD" ,  1.0);
   NL_r(PUMA,"puma","TGR"    , 288.0);

   // CAT

   NL_r(CAT,"cat","ALPHA"    ,  0.0);
   NL_r(CAT,"cat","BETA"     ,  0.0);
   NL_r(CAT,"cat","AFORC"    ,  0.001);
   NL_r(CAT,"cat","TFORC"    ,  0.01);
   NL_i(CAT,"cat","NFORC"    ,  0);
   NL_i(CAT,"cat","NGUIDBG"  ,  0);
   NL_i(CAT,"cat","NPOST"    ,  0);
   NL_i(CAT,"cat","NSIM"     ,  0);
   NL_i(CAT,"cat","KFMIN"    ,  0);
   NL_i(CAT,"cat","KFMAX"    ,  8);
   NL_i(CAT,"cat","JACMTHD"  ,  1);
   NL_i(CAT,"cat","NSTEPS"  ,   10000);
}

void NamelistSelector(int model)
{
   int i,yn,n,ml;
   struct SelStruct *Sel;
   int ledi_x,lbox_w,lbox_h;

   yn = opbox_y;
   n  = 0;
   ml = 0;
   Sel = &SelModels[model];

   if (model == PLASIM)
   {
      Sel->type = SEL_TEXT;
      Sel->teco = HeadC;
      Sel->y    = opbox_y;
      Sel->xt   = nlpos_x;
      Sel->yt   = Sel->y + BigFontAscent + 1;
      strcpy(Sel->text,PlanetName[Planet]);
      Sel->lt   = strlen(Sel->text);
      yn += BigFontHeight + 1;
      Sel = NewSel(Sel);
   }

   for (i=0 ; i < NL_items ; ++i)
   if (NL_list[i].model == model)
   {
      Sel->Item = NL_list + i;
      strcpy(Sel->text,NL_list[i].name);
      Sel->lt   = strlen(Sel->text);
      Sel->type = NL_list[i].flag;
      Sel->teco = BlackPix;
      Sel->h    = FixFontHeight + 1;
      Sel->y    = yn;
      Sel->xt   = nlpos_x;
      Sel->yt   = Sel->y + FixFont->ascent + 1;
      if (Sel->lt > ml) ml = Sel->lt;
      if (Sel->lt > ml) ml = Sel->lt;

      if (NL_list[i].flag == SEL_INT)
      {
         Sel->w    =  6 * FixFontWidth + 2;
         Sel->edco =  6;
         Sel->div  = Sel->iv = NL_list[i].ival;
      }
      else if (NL_list[i].flag == SEL_REAL)
      {
         Sel->edco = 11;
         Sel->w    = 11 * FixFontWidth + 2;
         Sel->dfv  = Sel->fv = NL_list[i].rval;
      }
      else if (NL_list[i].flag == SEL_PLANET)
      {
         Sel->edco = 11;
         Sel->w    = 11 * FixFontWidth + 2;
         Sel->dfv  = Sel->fv = NL_list[i].pvec[Planet];
         memcpy(Sel->fpl,NL_list[i].pvec,sizeof(float) * PLANETS);
      }
      else
      {
         Sel->edco = 11;
         Sel->w    = 11 * FixFontWidth + 2;
         strncpy(Sel->teva,NL_list[i].text,15);
      }

      yn += FixFontHeight + 1;
      Sel = NewSel(Sel);
      ++n;
   }
   Sel->Prev->Next = NULL; // Mark end of chain

   /* Compute size of namelist box */

   ledi_x = nlpos_x + (ml + 1) * FixFontWidth;
   lbox_w = (ml + 14) * FixFontWidth;
   lbox_h = BigFontHeight + (n+2) * FixFontHeight;

   if (nledi_x < ledi_x) nledi_x = ledi_x;
   if (nlbox_w < lbox_w) nlbox_w = lbox_w;
   if (nlbox_h < lbox_h) nlbox_h = lbox_h;

   UpdateSelections(ComEnd->Next);
}


void LoadFonts(void)
{
   if (ScreenH < 700)
   {
      strcpy(ModFontName,"5x8");
      strcpy(FixFontName,"6x10");
      strcpy(BigFontName,"7x13");
   }
   else if (ScreenH < 800)
   {
      strcpy(ModFontName,"6x10");
      strcpy(FixFontName,"7x13");
      strcpy(BigFontName,"9x15bold");
   }
   if ((ModFont = XLoadQueryFont(display,ModFontName)) == NULL)
   {
      printf("%s: Cannot open %s font\n",progname,ModFontName);
      exit(-1);
   }
   if ((FixFont = XLoadQueryFont(display,FixFontName)) == NULL)
   {
      printf("%s: Cannot open %s font\n",progname,FixFontName);
      exit(-1);
   }
   if ((BigFont = XLoadQueryFont(display,BigFontName)) == NULL)
   {
      printf("%s: Cannot open %s font\n",progname,BigFontName);
      exit(-1);
   }
   SamFont = XLoadQueryFont(display,"rk24");
   ModFontWidth  = XTextWidth(ModFont,"X",1);
   FixFontWidth  = XTextWidth(FixFont,"X",1);
   BigFontWidth  = XTextWidth(BigFont,"X",1);
   FixFontAscent = FixFont->ascent;
   ModFontAscent = ModFont->ascent;
   BigFontAscent = BigFont->ascent;
   ModFontHeight = ModFont->ascent + ModFont->descent;
   FixFontHeight = FixFont->ascent + FixFont->descent;
   BigFontHeight = BigFont->ascent + BigFont->descent;
   if (Debug)
   {
      printf("ModFont %2d x %2d %s\n",ModFontWidth,ModFontHeight,ModFontName);
      printf("FixFont %2d x %2d %s\n",FixFontWidth,FixFontHeight,FixFontName);
      printf("BigFont %2d x %2d %s\n",BigFontWidth,BigFontHeight,BigFontName);
   }
}

void InitSelections(void)
{
   int i,l,n,dyn,dys,mw,x,dx;
   char text[80];
   struct SelStruct *Sel;
   struct tm *dati;
   FILE *fp;

   opbox_x  = FixFontWidth / 2;

   dyn = FixFontHeight + 1;
   dys = (3 * dyn) / 2;

   // Initialize Sel at anchor SelStart

   Sel = &SelStart;

   // Model

   Sel->type = SEL_TEXT;
   Sel->teco = HeadC;
   Sel->y    = opbox_y;
   Sel->yt   = Sel->y + BigFontAscent + 1;
   strcpy(Sel->text,"Model");
   Sel->lt   = strlen(Sel->text);

   // PUMA

   Sel = NewSel(Sel);
   InitNextSelection(Sel,BigFontHeight,FullModelName[PUMA]);
   Sel->type = SEL_CHECK;
   Sel->teco = BlackPix;
   Sel->h    = FixFontHeight + 1;
   Sel->w    = FixFontHeight + 1;
   Sel->yt   = Sel->y + FixFontAscent + 1;
   Sel->div  = Sel->iv   =  1;
   SelMod = Sel;

   // SAM

   Sel = NewSel(Sel);
   InitNextSelection(Sel,dyn,"SAM");

   // Hide SAM ?

   if (!SamEnabled)
   {
      Sel->no = 1;
      Sel->lt = 0;
   }

   // CAT

   Sel = NewSel(Sel);
   InitNextSelection(Sel,dyn,FullModelName[CAT]);

   // Hide CAT until released

   if (!CatEnabled)
   {
      Sel->no = 1;
      Sel->lt = 0;
   }

   // Planet Simulator

   Sel = NewSel(Sel);
   InitNextSelection(Sel,dyn,FullModelName[PLASIM]);

   // Earth

   Sel = NewSel(Sel);
   InitNextSelection(Sel,dyn,"Earth");
   SelPlanet[EARTH] = Sel;
   Sel->div  = Sel->iv   =  1;
   Sel->no = 1;
   Sel->xo = (5 * FixFontWidth) / 2;

   // Mars

   Sel = NewSel(Sel);
   InitNextSelection(Sel,dyn,"Mars");
   SelPlanet[MARS] = Sel;
   Sel->no  = 1;

   // Exo

   Sel = NewSel(Sel);
   InitNextSelection(Sel,dyn,"Exo");
   SelPlanet[EXO] = Sel;
   Sel->no  = 1;

   // Modules

   Sel = NewSel(Sel);
   InitNextSelection(Sel,dys,"Modules");
   Sel->type = SEL_TEXT;
   Sel->teco = HeadC;
   Sel->h    = 0;
   Sel->w    = 0;
   Sel->yt   = Sel->y + BigFontAscent + 1;
   Sel->xo   = 0;
   
   // Mixed Layer Ocean

   Sel = NewSel(Sel);
   InitNextSelection(Sel,BigFontHeight,"ML  Ocean");
   Sel->type = SEL_CHECK;
   Sel->teco = BlackPix;
   Sel->h    = FixFontHeight + 1;
   Sel->w    = FixFontHeight + 1;
   Sel->yt   = Sel->y + FixFontAscent + 1;
   Sel->div  = Sel->iv   =  0;
   Sel->no   = 1;
   SelOce    = Sel;
   Sel->piv  = &Oce;

   // LSG Ocean

   if (LsgEnabled)
   {
      Sel = NewSel(Sel);
      InitNextSelection(Sel,FixFontHeight,"LSG Ocean");
      Sel->yt   = Sel->y + FixFontAscent + 1;
      Sel->div  = Sel->iv   =  0;
      Sel->no   = 1;
      SelLsg    = Sel;
      Sel->piv  = &Lsg;
   }

   // Ice

   Sel = NewSel(Sel);
   InitNextSelection(Sel,FixFontHeight,"Sea Ice");
   Sel->type = SEL_CHECK;
   Sel->teco = BlackPix;
   Sel->h    = FixFontHeight + 1;
   Sel->w    = FixFontHeight + 1;
   Sel->yt   = Sel->y + FixFontAscent + 1;
   Sel->div  = Sel->iv   =  0;
   Sel->no   = 1;
   SelIce    = Sel;
   Sel->piv  = &Ice;

   // Hardware

   Sel = NewSel(Sel);
   InitNextSelection(Sel,dys,"Parallelism");
   Sel->type = SEL_TEXT;
   Sel->teco = HeadC;
   Sel->h    = 0;
   Sel->w    = 0;
   Sel->yt   = Sel->y + BigFontAscent + 1;
   

   // Number of CPUs

   Sel = NewSel(Sel);
   InitNextSelection(Sel,dys,"Cores");
   Sel->h    = FixFontHeight + 1;
   Sel->w    = FixFontHeight + 1;
   Sel->yt   = Sel->y + FixFont->ascent + 1;
   Sel->w    = 4 * FixFontWidth + 2;
   Sel->type = SEL_INT;
   Sel->edco = 4;
   Sel->div  = Sel->iv = Cores;
   Sel->piv  = &Cores;
   SelCPU    = Sel;
   fp = fopen("most_compiler_mpi","r");
   if (fp) fclose(fp);
   else Sel->no = 1;

   // Number of synchronous runs

   if (MultirunEnabled && Expert)
   {
      Sel = NewSel(Sel);
      InitNextSelection(Sel,dys,"Instances");
      Sel->h    = FixFontHeight + 1;
      Sel->w    = FixFontHeight + 1;
      Sel->yt   = Sel->y + FixFont->ascent + 1;
      Sel->w    = 4 * FixFontWidth + 2;
      Sel->type = SEL_INT;
      Sel->edco = 4;
      Sel->div  = Sel->iv = Multirun;
      Sel->piv  = &Multirun;
      SelMulti  = Sel;
      fp = fopen("most_compiler_mpi","r");
      if (fp) fclose(fp);
      else Sel->no = 1;
   }

   // Resolution

   Sel = NewSel(Sel);
   InitNextSelection(Sel,dys,"Resolution");
   Sel->type = SEL_TEXT;
   Sel->h    = 0;
   Sel->w    = 0;
   Sel->yt   = Sel->y + BigFont->ascent + 1;

   // Horizontal resolution

   if (Expert)
   {
      Sel = NewSel(Sel);
      InitNextSelection(Sel,dys,"Latitudes #1");
      Sel->h    = FixFontHeight + 1;
      Sel->yt   = Sel->y + FixFont->ascent + 1;
      Sel->w    = 4 * FixFontWidth + 2;
      Sel->edco = 4;
      Sel->type = SEL_INT;
      Sel->div  = Sel->iv = Latitudes;
      Sel->piv  = &Latitudes;
      DimText1  = Sel->text;

      Sel = NewSel(Sel);
      InitNextSelection(Sel,dys,"Latitudes #2");
      Sel->div  = Sel->iv = Latitudes;
      Sel->piv  = &Latitude2;
      SelLat2   = Sel;
      DimText2  = Sel->text;
   }
   else
   {
      Sel = NewSel(Sel);
      InitNextSelection(Sel,dys,"T21   [64x32]");
      Sel->type = SEL_CHECK;
      Sel->h    = FixFontHeight + 1;
      Sel->w    = FixFontHeight + 1;
      Sel->yt   = Sel->y + FixFont->ascent + 1;
      Sel->div  = Sel->iv   =  1;
      SelRes    = Sel;
      DimText1  = Sel->text;

      Sel = NewSel(Sel);
      InitNextSelection(Sel,dyn,"T31   [96x48]");
      Sel->type = SEL_CHECK;
      Sel->h    = FixFontHeight + 1;
      Sel->w    = FixFontHeight + 1;
      Sel->div  = Sel->iv   =  0;
      DimText2  = Sel->text;

      Sel = NewSel(Sel);
      InitNextSelection(Sel,dyn,"T42  [128x64]");
      Sel->type = SEL_CHECK;
      Sel->h    = FixFontHeight + 1;
      Sel->w    = FixFontHeight + 1;
      Sel->div  = Sel->iv   =  0;
      DimText3  = Sel->text;
   }

   // Vertical resolution

   if (Expert)
   {
      Sel = NewSel(Sel);
      InitNextSelection(Sel,dys,"Levels");
      Sel->type = SEL_INT;
      Sel->div  = Sel->iv = Levels;
      Sel->piv  = &Levels;
   }

   // Options

   Sel = NewSel(Sel);
   InitNextSelection(Sel,dys,"Options");
   Sel->type = SEL_TEXT;
   Sel->h    = 0;
   Sel->w    = 0;
   Sel->yt   = Sel->y + BigFont->ascent + 1;

   // Global debug switch

   Sel = NewSel(Sel);
   InitNextSelection(Sel,dys,"Debug mode");
   Sel->type = SEL_CHECK;
   Sel->h    = FixFontHeight + 1;
   Sel->w    = FixFontHeight + 1;
   Sel->yt   = Sel->y + FixFont->ascent + 1;
   Sel->div  = Sel->iv   =  0;
   Sel->piv  = &ndebug;

   // Precision switch

   Sel = NewSel(Sel);
   InitNextSelection(Sel,dyn,"Double Precision");
   Sel->piv  = &nprec;

   // Global output switch

   Sel = NewSel(Sel);
   InitNextSelection(Sel,dys,"Write Output");
   Sel->type = SEL_CHECK;
   Sel->h    = FixFontHeight + 1;
   Sel->w    = FixFontHeight + 1;
   Sel->yt   = Sel->y + FixFont->ascent + 1;
   Sel->div  = Sel->iv   =  0;
   Sel->piv  = &noutput;

   // GUI

   Sel = NewSel(Sel);
   InitNextSelection(Sel,dyn,"Run with GUI");
   Sel->type = SEL_CHECK;
   Sel->h    = FixFontHeight + 1;
   Sel->w    = FixFontHeight + 1;
   Sel->div  = Sel->iv   =  1;
   Sel->piv  = &ngui;

   // Orography

   Sel = NewSel(Sel);
   InitNextSelection(Sel,dyn,"Orography");
   Sel->type = SEL_CHECK;
   Sel->div  = Sel->iv   =  1;
   Sel->piv  = &noro;
   SelOro    = Sel;

   // Annual cycle

   Sel = NewSel(Sel);
   InitNextSelection(Sel,dyn,"Annual cycle");
   Sel->type = SEL_CHECK;
   Sel->div  = Sel->iv   =  1;
   SelAnn = Sel;

   // Experiment

   Sel = NewSel(Sel);
   InitNextSelection(Sel,dys,"Simulation");
   Sel->type = SEL_TEXT;
   Sel->h    = 0;
   Sel->w    = 0;
   Sel->yt   = Sel->y + BigFont->ascent + 1;

   // Simulation Start

   dati = localtime(&CurrentDate);
   Sel = NewSel(Sel);
   InitNextSelection(Sel,dys,"Start year");
   Sel->h    = FixFontHeight + 1;
   Sel->yt   = Sel->y + FixFont->ascent + 1;
   Sel->w    = 4 * FixFontWidth + 2;
   Sel->edco = 4;
   Sel->type = SEL_INT;
   Sel->div  = Sel->iv = 1;
   Sel->piv  = &SimStart;
   SelSYear  = Sel;

   // Years

   Sel = NewSel(Sel);
   InitNextSelection(Sel,dyn,"Years to run");
   Sel->h    = FixFontHeight + 1;
   Sel->yt   = Sel->y + FixFont->ascent + 1;
   Sel->w    = 4 * FixFontWidth + 2;
   Sel->type = SEL_INT;
   Sel->div  = Sel->iv   = 10;
   Sel->piv  = &SimYears;

   opbox_h = Sel->y + dys - opbox_y;

   // Orography edit

   Sel = NewSel(Sel);
   InitNextSelection(Sel,dys,"Change [gpm]");
   Sel->h    = FixFontHeight + 1;
   Sel->yt   = Sel->y + FixFont->ascent + 1;
   Sel->w    = 6 * FixFontWidth + 2;
   Sel->type = SEL_INT;
   Sel->div  = Sel->iv   = 0;
   Sel->piv  = &OroAno;
   SelAno    = Sel;

   // Ground temperature edit

/*
   Sel = NewSel(Sel);
   InitNextSelection(Sel,dys,"Change [K]");
   Sel->h    = FixFontHeight + 1;
   Sel->yt   = Sel->y + FixFont->ascent + 1;
   Sel->w    = 6 * FixFontWidth + 2;
   Sel->type = SEL_INT;
   Sel->div  = Sel->iv   = 0;
   Sel->piv  = &TgrAno;
   SelTgr    = Sel;
*/

   // Mark end of common selection chain

   ComEnd = Sel;

   mw = 0;
   for (Sel = &SelStart ; Sel ; Sel = Sel->Next)
      if (Sel->w > mw) mw = Sel->w;

   for (Sel = &SelStart ; Sel ; Sel = Sel->Next)
   {
      Sel->xt = Sel->xo + FixFontWidth * 2 + mw;
      if (!Sel->x) Sel->x  = Sel->xt - Sel->w - FixFontWidth;
      if (Sel->type == SEL_INT )
      {
         sprintf(text,"%10d",Sel->iv);
         strcpy(Sel->teva,text+10-Sel->edco);
      }
   }

   for (x = 0 , Sel = &SelStart ; Sel ; Sel = Sel->Next)
   {
      if (Sel->type == SEL_TEXT) l = Sel->lt * BigFontWidth;
      else                       l = Sel->lt * FixFontWidth;
      if (x < l) x = l;
   }
   opbox_w = x + mw + 2 * FixFontWidth;

   nlbox_x = opbox_x + opbox_w + FixFontWidth;
   nlbox_y = opbox_y;
   nlpos_x = nlbox_x + FixFontWidth;
}

void CheckMark(int x, int y, int d)
{
   XSetForeground(display,gc,LightGreen.pixel);
   XFillArc(display,Cow,gc,x+1,y+1,d-5,d-5,0,FULLARC);
}


void DisplayTeVa(int x, int y, int w, char *t)
{
   int l;

   l = strlen(t);
   if (l > w / FixFontWidth) l = w / FixFontWidth;
   XSetForeground(display,gc,WhitePix);
   XSetBackground(display,gc,BlackPix);
   if (l) XDrawImageString(display,Cow,gc,x,y,t,l);
}


void ShowSelection(struct SelStruct *Sel)
{
   int x,y,h,w;

   if (Sel->hide) return;
   h = Sel->h;
   w = Sel->w;
   x = Sel->x;
   y = Sel->y;

   if (!Sel->no)
   {
      if (Sel->type == SEL_CHECK)
      {
         XSetForeground(display,gc,TextC);
         XDrawArc(display,Cow,gc,x,y,w-2,h-2,0,FULLARC);
         if (Sel->iv) CheckMark(x,y,w+1);
      }
      else DisplayTeVa(x+1,Sel->yt,w,Sel->teva);
   }

   XSetForeground(display,gc,TextC);
   XSetBackground(display,gc,WinBG);
   if (Sel->type == SEL_TEXT)
   {
      XSetFont(display, gc, BigFont->fid);
      XSetForeground(display,gc,Sel->teco);
      XDrawImageString(display,Cow,gc,Sel->xt,Sel->yt,Sel->text,Sel->lt);
      XSetFont(display, gc, FixFont->fid);
   }
   else
      XDrawImageString(display,Cow,gc,Sel->xt,Sel->yt,Sel->text,Sel->lt);
}

void InitLogo(void)
{
   int n;

   // KlimaCampus

   n = 0;
   Logo[n].x = FixFontWidth;
   Logo[n].y = 8;

   // PUMA

   ++n;
   strcpy(Logo[n].t[0],FullModelName[PUMA]);

   // Plasim

   ++n;
   strcpy(Logo[n].t[0],FullModelName[PLASIM]);

   // Cat

   ++n;
   strcpy(Logo[n].t[0],FullModelName[CAT]);

   Logos = n+1;
}

void GenerateNames(void)
{
   Truncation = (2 * Latitudes - 1) / 3;
   sprintf(namelist_name,"%s_namelist",ShortModelName[Model]);
   if (Model == CAT)
   {
      if (Cores < 2) strcpy(exec_name,"most_cat.x");
      else           strcpy(exec_name,"most_cat_mpi.x");
   }
   else if (Model == PUMA)
   {
      if (Cores < 2) strcpy(exec_name,"most_puma.x");
      else           strcpy(exec_name,"most_puma_mpi.x");
   }
   else if (Model == SAM)
   {
      if (Cores < 2) strcpy(exec_name,"most_sam.x");
      else           strcpy(exec_name,"most_sam_mpi.x");
   }
   else
      sprintf(exec_name,"most_%s_t%d_l%d_p%d.x",
      ShortModelName[Model],Truncation,Levels,Cores);

   sprintf(diag_name,"%s_diag",ShortModelName[Model]);
   sprintf(outp_name,"%s_output",ShortModelName[Model]);
   sprintf(build_name,"most_%s_build",ShortModelName[Model]);
   sprintf(build_ppp,"most_%s_build","ppp");
   sprintf(run_name,"most_%s_run",ShortModelName[Model]);
   if (Latitudes < 1000) sprintf(oro_name,"N%3.3d_surf_0129.sra",Latitudes);
   else                  sprintf(oro_name,"N%d_surf_0129.sra",Latitudes);
}


int WriteRunScript(int model)
{
   int i;
   int porm;
   FILE *fp;
   char command[256];
   char run[256];

   strcpy(exec_nam2,exec_name); // Duplicate exec name

   if (model == CAT) // Add Dimensions
   {
      sprintf(exec_name+strlen(exec_name)," %d %d",Latitudes,Latitude2);
   }

   if (model == PUMA) // Add Latitudes and Levels as arguments
   {
      sprintf(exec_name+strlen(exec_name)," %d %d",Latitudes,Levels);
      sprintf(exec_nam2+strlen(exec_nam2)," %d %d",Latitude2,Levels);
   }

   if (model == SAM) // Add Latitudes as arguments
   {
      sprintf(exec_name+strlen(exec_name)," %d",Latitudes);
      sprintf(exec_nam2+strlen(exec_nam2)," %d",Latitude2);
   }

   // porm is for Parallel OR Multiprocessing

   porm = MAX(Cores,Multirun);

   strcpy(run,ShortModelName[model]);
   strcat(run,"/run/");
   strcat(run,run_name);

   fp = fopen(run,"w");
   if (fp == NULL)
   {
      printf("Could not open file <%s> for writing\n",run);
      return 0; /* Failure */
   }
   fputs("#!/bin/bash\n",fp);
   fprintf(fp,"# run-script generated by Most %s",ctime(&CurrentDate));
   fputs("EXP=MOST    # Name your experiment here\n",fp);
   fprintf(fp,"[ $# == 1 ] && cd $1\n");
   fprintf(fp,"rm -f %s_restart\n",ShortModelName[model]);
   fputs("rm -f Abort_Message\n",fp);
   fputs("YEAR=0\n",fp);
   fprintf(fp,"YEARS=%d\n",SimYears);
   if (Multirun > 1) fprintf(fp,"INSTANCES=%d\n",Multirun);
   if (ngui) fputs("# Remove '#' from 'while' and 'end' lines for restart loop\n",fp);
   if (ngui) fputs("# ",fp); /* deactivate loop for GUI case */
   fputs("while [ $YEAR -lt $YEARS ]\n",fp);
   if (ngui) fputs("# ",fp); /* deactivate loop for GUI case */
   fputs("do\n",fp);
   fputs("   YEAR=`expr $YEAR + 1`\n",fp);
   fputs("   DATANAME=`printf '%s.%03d' $EXP $YEAR`\n",fp);
   fputs("   DIAGNAME=`printf '%s_DIAG.%03d' $EXP $YEAR`\n",fp);
   fputs("   RESTNAME=`printf '%s_REST.%03d' $EXP $YEAR`\n",fp);
   if (porm < 2)
   {
      fprintf(fp,"   ./%s\n",exec_name);
   }
   else 
   {
      if (Multirun > 1) 
      {    
         fprintf(fp,"   %s",mpirun);
         fprintf(fp," -np 1 %s : -np 1 %s\n",exec_name,exec_nam2);
      }    
      else 
      {    
         fprintf(fp,"   %s -np %d %s\n",mpirun,porm,exec_name);
      }    
   }
   fputs("   [ -e Abort_Message ] && exit 1\n",fp);
   if (Multirun > 1)
   {
      fputs("   INST=0\n",fp);
      fputs("   while [ $INST -lt $INSTANCES ]\n   do\n",fp);
      fputs("      EXT=`printf '%02d' $INST`\n",fp);
      fprintf(fp,"      [ -e %s_$EXT ] && mv %s_$EXT ${EXT}_$DATANAME\n",
              outp_name,outp_name);
      fprintf(fp,"      mv %s_$EXT   ${EXT}_$DIAGNAME\n",diag_name);
      fprintf(fp,"      cp %s_status_$EXT %s_restart_$EXT\n",
              ShortModelName[model],ShortModelName[model]);
      fprintf(fp,"      mv %s_status_$EXT ${EXT}_$RESTNAME\n",ShortModelName[model]);
      fputs("      INST=`expr $INST + 1`\n",fp);
      fputs("   done\n",fp);
   }
   else
   {
      fprintf(fp,"   [ -e %s ] && mv %s $DATANAME\n",outp_name,outp_name);
      fprintf(fp,"   [ -e %s ] && mv %s $DIAGNAME\n",diag_name,diag_name);
      fprintf(fp,"   [ -e %s_status ] && cp %s_status %s_restart\n",
              ShortModelName[model],ShortModelName[model],ShortModelName[model]);
      fprintf(fp,"   [ -e %s_status ] && mv %s_status $RESTNAME\n",
              ShortModelName[model],ShortModelName[model]);
   }
   if (ngui) fputs("# ",fp); /* deactivate loop for GUI case */
   fputs("done\n",fp);
   fclose(fp);
   sprintf(command,"chmod a+x %s",run);
   system(command);
   return 1; /* Success */
}


void BlueMessage(char *mess)
{
   int l,x,y,w,h;

   XSetFont(display, gc, FixFont->fid);
   l = strlen(mess);
   w = FixFontWidth * (l + 4);
   h = FixFontHeight * 3;
   if (w > WinXSize) w = WinXSize;
   XSetForeground(display,gc,Blue.pixel);
   x = (WinXSize - w) / 2;
   y = (WinYSize - h) / 2;
   XFillRectangle(display,Cow,gc,x,y,w,h);
   XSetForeground(display,gc,WhitePix);
   XSetBackground(display,gc,Blue.pixel);
   XDrawRectangle(display,Cow,gc,x-1,y-1,w+1,h+1);
   x += 2 * FixFontWidth;
   y += 2 * FixFontHeight;
   XDrawImageString(display,Cow,gc,x,y,mess,l);
   XSync(display,0);
}


void RedMessage(char *mess)
{
   int l,x,y,w,h;

   XSetFont(display, gc, FixFont->fid);
   l = strlen(mess);
   w = FixFontWidth * (l + 4);
   h = FixFontHeight * 3;
   if (w > WinXSize) w = WinXSize;
   XSetForeground(display,gc,Red.pixel);
   x = (WinXSize - w) / 2;
   y = (WinYSize - h) / 2;
   XFillRectangle(display,Cow,gc,x,y,w,h);
   XSetForeground(display,gc,WhitePix);
   XSetBackground(display,gc,Red.pixel);
   XDrawRectangle(display,Cow,gc,x-1,y-1,w+1,h+1);
   x += 2 * FixFontWidth;
   y += 2 * FixFontHeight;
   XDrawImageString(display,Cow,gc,x,y,mess,l);
   XSync(display,0);
}


int WriteRunPPP(void)
{
   int i;
   FILE *fp;
   char command[256];
   char run[256];

   strcpy(run,ShortModelName[Model]);
   strcat(run,"/run/");
   strcat(run,run_ppp);

   fp = fopen(run,"w");
   if (fp == NULL)
   {
      printf("Could not open file <%s> for writing\n",run);
      return 0; /* Failure */
   }
   fputs("#!/bin/bash\n",fp);
   fprintf(fp,"# run-script generated by Most %s",ctime(&CurrentDate));
   fputs("[ $# == 1 ] && cd $1\n",fp);
   if (OroClear) fprintf(fp,"rm -f %s\n",oro_name);
   else if (!OroAqua)
      fprintf(fp,"[ ! -e %s -a -e ../dat/%s ] && cp -p ../dat/%s .\n",
              oro_name,oro_name,oro_name);
   fprintf(fp,"   ./%s >!ppp.out\n",exec_ppp);
   fclose(fp);
   sprintf(command,"chmod a+x %s",run);
   system(command);
   strcpy(command,run);
   BlueMessage("Running PUMA Preprocessor");
   sprintf(command,"%s/run/%s %s/run",ShortModelName[Model],run_ppp,ShortModelName[Model]);
   system(command);
   OroAno = 0; /* Anomaly applied -> reset it */
   SelAno->iv = 0;
   return 1; /* Success */
}


void WriteResmod(char *res)
{
   FILE *fp;
   int OldLat,OldLev,OldPro;
   char Line[80];

   // Read existing file if there and check for changes

   fp = fopen(res,"r");
   if (fp)
   {
      fgets(Line,80,fp); // header line 1
      fgets(Line,80,fp); // header line 2
      fgets(Line,80,fp);
      OldLat = atoi(Line+27);
      fgets(Line,80,fp);
      OldLev = atoi(Line+27);
      fgets(Line,80,fp);
      OldPro = atoi(Line+27);
      fclose(fp);
      if (OldLat == Latitudes && OldLev == Levels && OldPro == Cores) return;
   }
   fp = fopen(res,"w");
   if (fp == NULL)
   {
      printf("Could not open file <%s> for writing\n",res);
      exit(1); /* Failure */
   }
   fprintf(fp,"      module resmod ! generated by MoSt %s\n",ctime(&CurrentDate));
   fprintf(fp,"      parameter(NLAT_ATM = %d)\n",Latitudes);
   fprintf(fp,"      parameter(NLEV_ATM = %d)\n",Levels);
   fprintf(fp,"      parameter(NPRO_ATM = %d)\n",Cores);
   fprintf(fp,"      end module resmod\n");
   fclose(fp);
}


int Build(int model)
{
   int i,l,x,y,ierr;
   int porm;
   FILE *fp;
   char script_backup[256];
   char command[256];
   char message[256];
   char bld[256];
   char res[256];
   char *shomo;

   porm = MAX(Cores,Multirun);

   shomo = ShortModelName[model];
   strcpy(bld,shomo);
   strcat(bld,"/bld/");
   strcpy(res,bld);
   strcat(bld,build_name);
   strcat(res,res_name);
   strcpy(script_backup,bld);
   strcat(script_backup,".bak");
   rename(bld,script_backup);

   if (model == PLASIM) WriteResmod(res);

   fp = fopen(bld,"w");
   if (fp == NULL)
   {
      printf("Could not open file <%s> for writing\n",bld);
      return 0; /* Failure */
   }
   fputs("#!/bin/bash\n",fp);
   fprintf(fp,"# compile-script generated by Most %s",ctime(&CurrentDate));

   fputs("[ $# == 1 ] && cd $1\n",fp);
   if (ForceRebuild) fputs("rm -f *.x *.o *.mod\n",fp);
   fputs("cp -p ../src/* .\n",fp);
   if (ngui == 0) // Use stub routines and switch off X11 lib
   {
      putenv("GUIMOD=guimod_stub");
      putenv("PUMAX=pumax_stub");
      putenv("GUIX11=guix11_stub");
      putenv("GUILIB=");    
   }
   if (Planet == MARS) putenv("PLAMOD=p_mars");
   if (Planet == EXO ) putenv("PLAMOD=p_exo");
   if (Lsg)
   {
      fputs("cp -p ../../lsg/src/lsgmod.f90 .\n",fp);
      putenv("OCEANCOUP=cpl");
   }
   else
   {
      putenv("OCEANCOUP=cpl_stub");
   }
   if (Latitudes < 4) putenv("FFTMOD=fft991mod");
   if (porm > 1)
   {
      fputs("[ ! -e MPI ] && rm -f *.o *.mod *.x\n",fp);
      fputs("touch MPI\n",fp);
      fputs("cat ../../most_compiler_mpi",fp);
      if (Multirun > 1) putenv("MPIMOD=mpimod_multi");
   }
   else
   {
      fputs("[ -e MPI ] && rm -f *.o *.mod *.x MPI\n",fp);
      fputs("cat ../../most_compiler",fp);
   }
   if (ndebug) fputs(" ../../most_debug_options",fp);
   if (nprec)
   {
      fputs(" ../../most_precision_options",fp);
   }
   fprintf(fp," make_%s > makefile\n",shomo);
   fputs("make -e\n",fp);

   fprintf(fp,"[ $? == 0 ] && cp %s.x ../bin/%s\n",shomo,exec_name);

   fclose(fp);
   sprintf(command,"chmod a+x %s",bld);
   system(command);

   sprintf(message,"Building %s - wait a minute!",FullModelName[Model]);
   BlueMessage(message);
   strcat(bld," ");
   strcat(bld,shomo);
   strcat(bld,"/bld");
   if (system(bld))
   {
      RedMessage("Error in build process");
      sleep(5);
      return 0; // error
   }
   sprintf(command,"cp %s/bin/%s %s/run\n",shomo,exec_name,shomo);
   system(command);

   // copy CAT simulation namelist to run directory

   if (model == CAT)
   {
      sprintf(command,"cp cat/dat/sim_%4.4d.nl cat/run/sim_namelist\n",CatSim);
      system(command);
   }

   // copy hires background bitmap for Earth or Mars

   if (model == PUMA || model == PLASIM )
   {
       if (model == PLASIM && Planet == MARS)
       {
          sprintf(command,"cp images/mars.bmp %s/run/map.bmp\n",shomo);
       system(command);
       }
       else if (model == PLASIM && Planet == EARTH)
       {
          sprintf(command,"cp images/earth.bmp %s/run/map.bmp\n",shomo);
          system(command);
       }
   }

   // copy surface data in matching resolution to run directory

   if (model == PLASIM)
   {
      if (Planet == MARS)
         sprintf(command,"cp plasim/dat/T%d_mars/* plasim/run/\n",Truncation);
      else if (Planet == EXO)
         sprintf(command,"cp plasim/dat/T%d_exo/* plasim/run/\n",Truncation);
      else
         sprintf(command,"cp plasim/dat/T%d/* plasim/run/\n",Truncation);
      system(command);

      if (Lsg) // copy data for LSG ocean model and select LSG GUI configuration
      {    
         sprintf(command,"cp lsg/dat/* %s/run\n",shomo);
         system(command);
         sprintf(command,"cp %s/dat/GUI_LSG.cfg %s/run/GUI.cfg\n",shomo,shomo);
         system(command);
      }
      else
      {
         sprintf(command,"cp %s/dat/GUI.cfg %s/run\n",shomo,shomo);
         system(command);
      }
   }
   else
   {
      sprintf(command,"cp %s/dat/GUI.cfg %s/run\n",shomo,shomo);
      system(command);
   }

   // copy second GUI configuration for two-instances run

   if (Multirun > 1)
   {
      sprintf(command,"cp %s/dat/GUI_0?.cfg %s/run\n",shomo,shomo);
      system(command);
   }
   return 1; /* Success */
}


int BuildPPP(void)
{
   int i,l,x,y;
   FILE *fp;
   char script_backup[256];
   char command[256];
   char message[256];
   char bld[256];
   char res[256];

   strcpy(bld,ShortModelName[Model]);
   strcat(bld,"/bld/");
   strcpy(res,bld);
   strcat(bld,build_ppp);
   strcat(res,res_name);
   strcpy(script_backup,bld);
   strcat(script_backup,".bak");
   rename(bld,script_backup);

   fp = fopen(bld,"w");
   if (fp == NULL)
   {
      printf("Could not open file <%s> for writing\n",bld);
      return 0; /* Failure */
   }
   fputs("#!/bin/bash\n",fp);
   fprintf(fp,"# compile-script generated by Most %s",ctime(&CurrentDate));
   fputs("[ $# == 1 ] && cd $1\n",fp);
   fputs("rm -f *.o *.mod\n",fp);
   fputs("cp ../src/make_ppp .\n",fp);
   fputs("cp ../src/*.f90 .\n",fp);
   fputs("cat ../../most_compiler",fp);
   if (ndebug) fputs(" ../../most_debug_options",fp);
   if (nprec)  fputs(" ../../most_precision_options",fp);
   fprintf(fp," make_ppp > makefile_ppp\n");
   fputs("make -e -f makefile_ppp\n",fp);
   fprintf(fp,"cp ppp.x ../bin/%s\n",exec_ppp);

   fclose(fp);
   sprintf(command,"chmod a+x %s",bld);
   system(command);

   sprintf(command,"%s/bin/%s",ShortModelName[Model],exec_ppp);
   if (!(fp = fopen(command,"r")))
   {
      sprintf(message,"Building preprocessor ppp");
      BlueMessage(message);
      strcat(bld," ");
      strcat(bld,ShortModelName[Model]);
      strcat(bld,"/bld");
      system(bld);
   }
   else fclose(fp); // Executable exists already

   sprintf(command,"cp %s/bin/%s %s/run\n",ShortModelName[Model],exec_ppp,ShortModelName[Model]);
   system(command);
   return 1; /* Success */
}


void FinishLine(void)
{
   char text[80];
   int  OldCores;

   OldCores = Cores;

   if (CursorSel == NULL) return;
   if (CursorSel->type == SEL_INT)
   {
      CursorSel->iv = atoi(CursorSel->teva);
      sprintf(text,"%10d",CursorSel->iv);
      strcpy(CursorSel->teva,text+10-CursorSel->edco);
      if (CursorSel->piv) *CursorSel->piv = CursorSel->iv;
   }
   if (CursorSel->type == SEL_REAL)
   {
      CursorSel->fv = atof(CursorSel->teva);
      FormatReal(CursorSel->fv,text);
      strcpy(CursorSel->teva,text);
   }

/*
   if (CursorSel == SelMulti)  // Enable or disable Lat2
   {
      SelLat2->no = (SelMulti->iv != 2) ;
   }
*/
   if (OldCores == 1 && Cores  > 1) ForceRebuild = 1;
   if (OldCores  > 1 && Cores == 1) ForceRebuild = 1;
   if (Model == PLASIM && OldCores != Cores) ForceRebuild = 1;
}


int CheckPumaNamelist(void)
{
   int i,safe_ntspd;
   int *ntspd;
   int *nyoden = NULL;
   double s;
   struct SelStruct *Sel;
   FILE *fp;

   FinishLine();

   for (Sel = &SelStart ; Sel ; Sel = Sel->Next)
   {
      if (Sel->piv) *Sel->piv = Sel->iv;
      if (!strcmp(Sel->text,"NTSPD"       )) ntspd    = &Sel->iv;
      if (!strcmp(Sel->text,"NYODEN"      )) nyoden   = &Sel->iv;
      if (!strcmp(Sel->text,"Orography"   )) nreadsr  = Sel->iv;
      if (!strcmp(Sel->text,"Annual cycle")) nac      = Sel->iv;
   }

   // Check for resolution defines as T value

   if (Resolution > 0) Latitudes = ResLat[Resolution];

   // Check # of latitudes for correct values (FFT requirements)

/*
        if (Latitudes >= 2048) Latitudes = 2048; // T1365
   else if (Latitudes >= 1024) Latitudes = 1024; // T682
   else if (Latitudes >=  512) Latitudes =  512; // T341
   else if (Latitudes >=  256) Latitudes =  256; // T170
   else if (Latitudes >=  192) Latitudes =  192; // T127
   else if (Latitudes >=  160) Latitudes =  160; // T106
   else if (Latitudes >=  128) Latitudes =  128; // T85
   else if (Latitudes >=   96) Latitudes =   96; // T63
   else if (Latitudes >=   64) Latitudes =   64; // T42
   else if (Latitudes >=   48) Latitudes =   48; // T31
   else if (Latitudes >=   32) Latitudes =   32; // T21
   else if (Latitudes >=   24) Latitudes =   24; // T15
   else                        Latitudes =   16; // T10
*/

   if (Debug) printf("Latitudes = %d\n",Latitudes);

   // Force # of levels to 20 for predefined Yoden profiles

   if (nyoden && *nyoden > 0)
   {
      Levels = 20;
      Yoden  = *nyoden;
   }

   // Make sure # of CPU's is a power of 2 and in the proper range

   if (Cores > Latitudes/2) Cores = Latitudes/2;
   if (Cores <           1) Cores =           1;
   if ((Latitudes/2) % Cores != 0) Cores = 1;


   // Multirun is currently implemented for two runs only

   if (Multirun >= 2)
   {
      Multirun   = SelMulti->iv = 2;
      Cores = SelCPU->iv   = 1;
   }
   return 0; /* Success */
}


int CheckCATNamelist(void)
{
   int i,safe_ntspd;
   int *ntspd;
   int *nyoden = NULL;
   double s;
   struct SelStruct *Sel;
   FILE *fp;

   FinishLine();

/*
   for (Sel = &SelStart ; Sel ; Sel = Sel->Next)
   {
      if (Sel->piv) *Sel->piv = Sel->iv;
      if (!strcmp(Sel->text,"NTSPD"       )) ntspd    = &Sel->iv;
      if (!strcmp(Sel->text,"NYODEN"      )) nyoden   = &Sel->iv;
      if (!strcmp(Sel->text,"Orography"   )) nreadsr  = Sel->iv;
      if (!strcmp(Sel->text,"Annual cycle")) nac      = Sel->iv;
   }
*/

   // Check for resolution

        if (Resolution == 1)
      Latitudes = Latitude2 = 64;
   else if (Resolution == 2)
      Latitudes = Latitude2 = 256;
   else if (Resolution == 3)
      Latitudes = Latitude2 = 1024;

   if (Debug) printf("NGX = NGY = %d\n",Latitudes);

   return 0; /* Success */
}


int CheckPlasimNamelist(void)
{
   int i,safe_mpstep;
   int *mpstep;
   double s;
   struct SelStruct *Sel;
   FILE *fp;

   FinishLine();

   for (Sel = &SelStart ; Sel ; Sel = Sel->Next)
   {
      if (Sel->piv) *Sel->piv = Sel->iv;
      if (!strcmp(Sel->text,"MPSTEP")) mpstep = &Sel->iv;
      if (!strcmp(Sel->text,"Orography"   )) nreadsr  = Sel->iv;
      if (!strcmp(Sel->text,"Annual cycle")) nac      = Sel->iv;
   }

   // Check for resolution defines as T value

   if (Resolution > 0) Latitudes = ResLat[Resolution];

   // LSG works currently only with T21 PlaSim
   
   if (Lsg)
   {
       Resolution = RES_T21;
       Latitudes = ResLat[RES_T21];
   }

   // Check # of latitudes for correct values (FFT requirements)

        if (Latitudes >=  64) Latitudes =  64; // T42
   else if (Latitudes >=  48) Latitudes =  48; // T31
   else if (Latitudes >=  32) Latitudes =  32; // T21
   else if (Latitudes >=   4) Latitudes =   4; // T2
   else if (Latitudes >=   2) Latitudes =   2; // T1

   // Set mpstep to a safe value

   if (Resolution > 0) *mpstep = PlasimSteps[Resolution];
   else
   {
      s = log(Latitudes / 32.0) / log(2.0);
      safe_mpstep = 45.0 / pow(3.0,s);
      if (*mpstep > safe_mpstep) *mpstep = safe_mpstep;
   }

   // Make sure # of CPU's is a power of 2 and in the proper range

   if (Cores > Latitudes) Cores = Latitudes;
   if (Cores <         1) Cores =         1;

   if (Latitudes % Cores != 0) Cores = 1;

   return 0; /* Success */
}


double *ReadGrid(const char *fn, int klat, double Sc)
{
   int i,j,k,jlev,iteml,gridsize;
   FILE *ifp;
   int head[8];
   double *gp;
   char Line[256];
   char Elem[16];

   nlat = klat;
   nlon = nlat + nlat;
   VGAX = (double)sfbox_w / nlon;
   VGAY = (double)sfbox_h / (nlat-1);
   gridsize = (nlon+1) * nlat * sizeof(double);

   gp = malloc(gridsize);
   ifp = fopen(fn,"r");
   if (!ifp) return NULL;
   fgets(Line,sizeof(Line),ifp);
   for (i = 0 ; i < 8 ; ++i)
   {
      strncpy(Elem,Line+i*10,10);
      Elem[10] = 0;
      head[i] = atoi(Elem);
   }
   if (head[4] == nlon && head[5] == nlat)
   {
      for (j = 0 ; j < nlat ; ++j)
      {
         for (i = 0 ; i < nlon ; i+=8)
         {
            fgets(Line,sizeof(Line),ifp);
            iteml = strlen(Line) / 8;
            for (k=0 ; k < 8 ; ++k)
            {
               strncpy(Elem,Line+k*iteml,iteml);
               Elem[iteml] = 0;
               gp[k+i+j*(nlon+1)] = atof(Elem) * Sc;
            }
         }
         gp[nlon+j*(nlon+1)] = gp[j*(nlon+1)];
      }
   }
   else printf("head[4] = %d   head[5] = %d\n",head[4],head[5]);
   fclose(ifp);
   return gp;
}


void WriteOroNamelist(FILE *fp)
{
   int lon1,lon2,lat1,lat2;
   double w,h;

   w = Frame[0].w;
   h = Frame[0].h;

   // Round to next gridpoint

   lon1 = 1 + (Frame[0].xs * Latitudes*2) / w;
   lon2 = 1 +((Frame[0].xs  + Frame[0].ws) * Latitudes*2) / w;
   lat1 = 1 + (Frame[0].ys * Latitudes) / h;
   lat2 = 1 +((Frame[0].ys  + Frame[0].hs) * Latitudes) / h;

   fprintf(fp," %-8s=%d\n","NSRV"   ,   0);
   fprintf(fp," %-8s=%d\n","NORO"   ,noro);
   fprintf(fp," %-8s=%d\n","OROANO" ,OroAno);
   fprintf(fp," %-8s=%d\n","LON1ORO",lon1);
   fprintf(fp," %-8s=%d\n","LON2ORO",lon2);
   fprintf(fp," %-8s=%d\n","LAT1ORO",lat1);
   fprintf(fp," %-8s=%d\n","LAT2ORO",lat2);
   fprintf(fp," %-8s=%d\n","TGRANO" ,TgrAno);

   lon1 = 1 + (Frame[1].xs * Latitudes*2) / Frame[1].w;
   lon2 = 1 +((Frame[1].xs  + Frame[1].ws) * Latitudes*2) / Frame[1].w;
   lat1 = 1 + (Frame[1].ys * Latitudes) / Frame[1].h;
   lat2 = 1 +((Frame[1].ys  + Frame[1].hs) * Latitudes) / Frame[1].h;

   fprintf(fp," %-8s=%d\n","LON1TGR",lon1);
   fprintf(fp," %-8s=%d\n","LON2TGR",lon2);
   fprintf(fp," %-8s=%d\n","LAT1TGR",lat1);
   fprintf(fp," %-8s=%d\n","LAT2TGR",lat2);
   return; /* Success */
}


void WriteResolutionNamelist(void)
{
   int i;
   char nln[256];
   FILE *fp;

   for (i = 0 ; i < Multirun ; ++i)
   {
      sprintf(nln,"%s/run/resolution_namelist",ShortModelName[Model]);
      if (Multirun > 1) sprintf(nln+strlen(nln),"_%2.2d",i);
      fp = fopen(nln,"w");
      if (fp == NULL)
      {
         printf("Could not open file <%s> for writing\n",nln);
         return; /* Failure */
      }

      fprintf(fp," &RES\n");
      fprintf(fp," NLAT = %d\n" ,Latitudes);
      if (Model != SAM) fprintf(fp," NLEV = %d\n" ,Levels);
      fprintf(fp," /END\n");
      fclose(fp);
   }
}


/* ================= */
/* WritePumaNamelist */
/* ================= */

int WritePumaNamelist(void)  /* also used for model SAM */
{
   int i,j,k,sum,val,imr;
   FILE *fp;
   char backup_name[256];
   char nln[256];
   struct SelStruct *Sel;

   FinishLine();

   // Write file <puma_namelist> or <sam_namelist>

   for (imr = 0 ; imr < Multirun ; ++imr)
   {
      strcpy(nln,ShortModelName[Model]);
      strcat(nln,"/run/");
      strcat(nln,namelist_name);
      if (Multirun > 1) sprintf(nln+strlen(nln),"_%2.2d",imr);
      fp = fopen(nln,"w");
      if (fp == NULL)
      {
         printf("Could not open file <%s> for writing\n",nln);
         return 0; /* Failure */
      }

      fprintf(fp," &%s_nl\n",ShortModelName[Model]);

      if (Preprocessed || noro) nreadsr = 1;
      fprintf(fp," %-8s=%6d\n","NOUTPUT" ,noutput);
      fprintf(fp," %-8s=%6d\n","NGUI"    ,ngui);
      if (nac)
      {
         fprintf(fp," %-8s=%11.4f\n","TAC"  ,360.0);
         fprintf(fp," %-8s=%11.4f\n","PAC"  ,  0.0);
      }
      else
      {
         fprintf(fp," %-8s=%11.4f\n","TAC"  ,  0.0);
         fprintf(fp," %-8s=%11.4f\n","PAC"  ,  0.0);
      }
      if (ngui) fprintf(fp," %-8s=%6d\n","NYEARS",SimYears);
      else      fprintf(fp," %-8s=%6d\n","NYEARS",1);
      fprintf(fp," %-8s=%6d\n","NMONTHS",0);

      for (Sel = ComEnd->Next ; Sel ; Sel = Sel->Next)
      {
         if (Sel->type == SEL_INT)
            fprintf(fp," %-8s=%6d\n",Sel->text,Sel->iv);
         if (Sel->type == SEL_REAL)
            fprintf(fp," %-8s=%s\n",Sel->text,Sel->teva);
      }

      // Check for mode selections

      for (i=0,sum=0 ; i < DimSH ; ++i) sum += Ampli[i];
      if (sum != DimSH) // Some modes are off
      {
         fprintf(fp," NSPECSEL = ");
         i = 0;
         while (i < DimSH)
         {
            val = Ampli[i];
            j = i;
            while (j < DimSH && Ampli[j] == val) ++j;
            k = j - i;
            if (k == 1)    fprintf(fp,"%d",val);
            else           fprintf(fp,"%d*%d",k,val);
            if (j < DimSH) fprintf(fp,",");
            i = j;
         }
         fprintf(fp,"\n");
      }
      fprintf(fp," /END\n");
      fclose(fp);
   }
   return 1; /* Success */
}


/* ================ */
/* WriteCatNamelist */
/* ================ */

int WriteCatNamelist(void)
{
   int i,j,k,sum,val;
   FILE *fp;
   char backup_name[256];
   char nln[256];
   struct SelStruct *Sel;

   FinishLine();

   // Write file <cat_namelist>

   strcpy(nln,ShortModelName[Model]);
   strcat(nln,"/run/");
   strcat(nln,namelist_name);
   fp = fopen(nln,"w");
   if (fp == NULL)
   {
      printf("Could not open file <%s> for writing\n",nln);
      return 0; /* Failure */
   }

   fprintf(fp," &%s_nl\n",ShortModelName[Model]);

   fprintf(fp," %-8s=%6d\n","NGUI"    ,ngui);

   for (Sel = ComEnd->Next ; Sel ; Sel = Sel->Next)
   {
      if (Sel->type == SEL_INT)
         fprintf(fp," %-8s=%6d\n",Sel->text,Sel->iv);
      if (Sel->type == SEL_REAL)
         fprintf(fp," %-8s=%s\n",Sel->text,Sel->teva);
      if (!strncmp(Sel->text,"NSIM",4))
      {
         if (Sel->iv > 0) CatSim = Sel->iv;
      }
   }

   fprintf(fp," /END\n");
   fclose(fp);

   return 1; /* Success */
}


/* ================ */
/* WritePPPNamelist */
/* ================ */

int WritePPPNamelist(void)
{
   int i,j,k,sum,val;
   FILE *fp;
   char backup_name[256];
   char nln[256];
   struct SelStruct *Sel;

   FinishLine();

   WriteResolutionNamelist();

   /* 2. Write file <ppp_namelist> */

   strcpy(nln,ShortModelName[Model]);
   strcat(nln,"/run/");
   strcat(nln,"ppp_namelist");
   strcpy(backup_name,nln);
   strcat(backup_name,".bak");
   rename(nln,backup_name);
   fp = fopen(nln,"w");
   if (fp == NULL)
   {
      printf("Could not open file <%s> for writing\n",nln);
      return 0; /* Failure */
   }

   fprintf(fp," &ppp_nl\n");

   if (Preprocessed || noro) nreadsr = 1;
   fprintf(fp," %-8s=%d\n","NOUTPUT" ,noutput);
   fprintf(fp," %-8s=%d\n","NGUI"    ,ngui);
   if (nac)
   {
      fprintf(fp," %-8s=%11.4f\n","TAC"  ,360.0);
      fprintf(fp," %-8s=%11.4f\n","PAC"  ,  0.0);
   }
   else
   {
      fprintf(fp," %-8s=%11.4f\n","TAC"  ,  0.0);
      fprintf(fp," %-8s=%11.4f\n","PAC"  ,  0.0);
   }

   for (Sel = ComEnd->Next ; Sel ; Sel = Sel->Next)
   {
      if (Sel->type == SEL_INT)
         fprintf(fp," %-8s=%6d\n",Sel->text,Sel->iv);
      if (Sel->type == SEL_REAL)
         fprintf(fp," %-8s=%s\n",Sel->text,Sel->teva);
   }

   WriteOroNamelist(fp);
   fprintf(fp," /END\n");
   fclose(fp);
   return 1; /* Success */
}


/* ======== */
/* FillPoly */
/* ======== */

void FillPoly(int n, double Poly[])
{
   int i;
   XPoint xpol[8];
   for (i=0; i < n ; ++i)
   {
      xpol[i].x = OffX + Poly[i+i  ] + 0.5;
      xpol[i].y = OffY + Poly[i+i+1] + 0.5;
   }
   XFillPolygon(display,pix,gc,xpol,n,Convex,CoordModeOrigin);
}


/* ======= */
/* IsoArea */
/* ======= */

void IsoArea(INT y, double vl, double vh, double Top[], double Bot[], INT Dim)
{
   INT  f,x,p;
   double xl,xr,yt,yb;
   double Poly[16];

   for (x=0 ; x < Dim-1 ; x++)
   {
      Flag[x] = 0;
      if (Top[x  ] <  vl) Flag[x] |= TOLELO;
      if (Top[x  ] >= vh) Flag[x] |= TOLEHI;
      if (Top[x+1] <  vl) Flag[x] |= TORILO;
      if (Top[x+1] >= vh) Flag[x] |= TORIHI;
      if (Bot[x  ] <  vl) Flag[x] |= BOLELO;
      if (Bot[x  ] >= vh) Flag[x] |= BOLEHI;
      if (Bot[x+1] <  vl) Flag[x] |= BORILO;
      if (Bot[x+1] >= vh) Flag[x] |= BORIHI;
   }

   x = 0;

   while (x < Dim-1)
   {
      xl = VGAX *  x   ;
      xr = VGAX * (x+1);
      yt = VGAY *  y   ;
      yb = VGAY * (y+1);
      f  = Flag[x];

      if (f == 0)
      {
	 x++;
	 while (x < Dim-1 && Flag[x] == 0)
	 {
	    x++;
	    xr = VGAX * x;
	 }
	 Poly[0] = Poly[6] = xl;
	 Poly[1] = Poly[3] = yt;
	 Poly[2] = Poly[4] = xr;
	 Poly[5] = Poly[7] = yb;

	 FillPoly(4,Poly);

      }
      else if (f == (TOLELO | TORILO | BOLELO | BORILO) ||
	       f == (TOLEHI | TORIHI | BOLEHI | BORIHI))   x++;
      else if (Top[x] < vl && Top[x+1] >= vl && Bot[x] >= vl && Bot[x+1] < vl)
      {
	 Poly[1] = Poly[3] = yt;
	 Poly[2] = Poly[4] = xr;
         Poly[0] = IPX(Top[x  ],vl,Top[x+1]);
         Poly[5] = IPY(Top[x+1],vl,Bot[x+1]);
         FillPoly(3,Poly);
         Poly[1] = Poly[3] = yb;
         Poly[2] = Poly[4] = xl;
         Poly[0] = IPX(Bot[x  ],vl,Bot[x+1]);
         Poly[5] = IPY(Top[x  ],vl,Bot[x  ]);
         FillPoly(3,Poly);
         ++x;
      }
      else if (Top[x] >= vl && Top[x+1] < vl && Bot[x] < vl && Bot[x+1] >= vl)
      {
	 Poly[0] = Poly[4] = xl;
	 Poly[1] = Poly[3] = yt;
         Poly[2] = IPX(Top[x  ],vl,Top[x+1]);
         Poly[5] = IPY(Top[x  ],vl,Bot[x  ]);
         FillPoly(3,Poly);
         Poly[0] = Poly[2] = xr;
         Poly[3] = Poly[5] = yb;
         Poly[1] = IPY(Top[x+1],vl,Bot[x+1]);
         Poly[4] = IPX(Bot[x  ],vl,Bot[x+1]);
         FillPoly(3,Poly);
         ++x;
      }
      else
      {
	 p = 0;

	 if (Top[x] < vl)
	 {
	    if (Top[x+1] >= vl)
	    {
	       Poly[p++] = IPX(Top[x],vl,Top[x+1]);
	       Poly[p++] = yt;
	    }

	    if (Top[x+1] >= vh)
	    {
	       Poly[p++] = IPX(Top[x],vh,Top[x+1]);
	       Poly[p++] = yt;
	    }
	 }
	 else if (Top[x] >= vh)
	 {
	    if (Top[x+1] < vh)
	    {
	       Poly[p++] = IPX(Top[x],vh,Top[x+1]);
	       Poly[p++] = yt;
	    }
	    if (Top[x+1] < vl)
	    {
	       Poly[p++] = IPX(Top[x],vl,Top[x+1]);
	       Poly[p++] = yt;
	    }
	 }
	 else
	 {
	    Poly[p++] = xl;
	    Poly[p++] = yt;
	    if (Top[x+1] < vl)
	    {
	       Poly[p++] = IPX(Top[x],vl,Top[x+1]);
	       Poly[p++] = yt;
	    }
	    if (Top[x+1] >= vh)
	    {
	       Poly[p++] = IPX(Top[x],vh,Top[x+1]);
	       Poly[p++] = yt;
	    }
	 }

	 if (Top[x+1] < vl)
	 {
	    if (Bot[x+1] >= vl)
	    {
	       Poly[p++] = xr;
	       Poly[p++] = IPY(Top[x+1],vl,Bot[x+1]);
	    }

	    if (Bot[x+1] >= vh)
	    {
	       Poly[p++] = xr;
	       Poly[p++] = IPY(Top[x+1],vh,Bot[x+1]);
	    }
	 }
	 else if (Top[x+1] >= vh)
	 {
	    if (Bot[x+1] < vh)
	    {
	       Poly[p++] = xr;
	       Poly[p++] = IPY(Top[x+1],vh,Bot[x+1]);
	    }
	    if (Bot[x+1] < vl)
	    {
	       Poly[p++] = xr;
	       Poly[p++] = IPY(Top[x+1],vl,Bot[x+1]);
	    }
	 }
	 else
	 {
	    Poly[p++] = xr;
	    Poly[p++] = yt;
	    if (Bot[x+1] < vl)
	    {
	       Poly[p++] = xr;
	       Poly[p++] = IPY(Top[x+1],vl,Bot[x+1]);
	    }
	    if (Bot[x+1] >= vh)
	    {
	       Poly[p++] = xr;
	       Poly[p++] = IPY(Top[x+1],vh,Bot[x+1]);
	    }
	 }

	 if (Bot[x+1] < vl)
	 {
	    if (Bot[x] >= vl)
	    {
	       Poly[p++] = IPX(Bot[x],vl,Bot[x+1]);
	       Poly[p++] = yb;
	    }
	    if (Bot[x] >= vh)
	    {
	       Poly[p++] = IPX(Bot[x],vh,Bot[x+1]);
	       Poly[p++] = yb;
	    }
	 }
	 else if (Bot[x+1] >= vh)
	 {
	    if (Bot[x] < vh)
	    {
	       Poly[p++] = IPX(Bot[x],vh,Bot[x+1]);
	       Poly[p++] = yb;
	    }
	    if (Bot[x] < vl)
	    {
	       Poly[p++] = IPX(Bot[x],vl,Bot[x+1]);
	       Poly[p++] = yb;
	    }
	 }
	 else
	 {
	    Poly[p++] = xr;
	    Poly[p++] = yb;
	    if (Bot[x] < vl)
	    {
	       Poly[p++] = IPX(Bot[x],vl,Bot[x+1]);
	       Poly[p++] = yb;
	    }
	    if (Bot[x] >= vh)
	    {
	       Poly[p++] = IPX(Bot[x],vh,Bot[x+1]);
	       Poly[p++] = yb;
	    }
	 }

	 if (Bot[x] < vl)
	 {
	    if (Top[x] >= vl)
	    {
	       Poly[p++] = xl;
	       Poly[p++] = IPY(Top[x],vl,Bot[x]);
	    }

	    if (Top[x] >= vh)
	    {
	       Poly[p++] = xl;
	       Poly[p++] = IPY(Top[x],vh,Bot[x]);
	    }
	 }
	 else if (Bot[x] >= vh)
	 {
	    if (Top[x] < vh)
	    {
	       Poly[p++] = xl;
	       Poly[p++] = IPY(Top[x],vh,Bot[x]);
	    }
	    if (Top[x] < vl)
	    {
	       Poly[p++] = xl;
	       Poly[p++] = IPY(Top[x],vl,Bot[x]);
	    }
	 }
	 else
	 {
	    Poly[p++] = xl;
	    Poly[p++] = yb;
	    if (Top[x] < vl)
	    {
	       Poly[p++] = xl;
	       Poly[p++] = IPY(Top[x],vl,Bot[x]);
	    }
	    if (Top[x] >= vh)
	    {
	       Poly[p++] = xl;
	       Poly[p++] = IPY(Top[x],vh,Bot[x]);
	    }
	 }
	 FillPoly(p>>1,Poly);
	 x++;
      }
   }
}


/* ======== */
/* IsoAreas */
/* ======== */

void IsoAreas(double *Field, int DimX, int DimY, struct ColorStrip Strip[])
{
   INT  i;
   INT  y;
   double *Top;
   double *Bot;

   i = 0;
   while (Strip[i].Name)
   {
      Top = Field;
      Bot = Field + DimX;
      XSetForeground(display,gc,Strip[i].pixel);
      for (y = 0 ; y < DimY-1 ; y++)
      {
	 IsoArea(y,Strip[i].Lo,Strip[i].Hi,Top,Bot,DimX);
	 Top += DimX;
	 Bot += DimX;
      }
      ++i;
   }
}


/* ========= */
/* CalcFrame */
/* ========= */

int CalcFrame(int lats)
{
//   int i,l,x,y;
//   double *Grid;
//
//   nlat = lats;
//   nlon = lats * 2;
//   VGAX = (sfbox_w - 1.0) / nlon;
//   VGAY = (sfbox_h - 1.0) / (nlat-1);
//
//   if (!Flag) Flag = malloc((nlon+1) * sizeof(int));
//   if (!Frame[0].Grid) Frame[0].Grid = malloc(nlon * nlat * nlev * sizeof(double));
//   if (!Frame[0].pixmap) Frame[0].pixmap = XCreatePixmap(display,Cow,sfbox_w,sfbox_h,ScreenD);
//   pix = Frame[0].pixmap;
//   Grid = Frame[0].Grid;
//   IsoAreas(Grid,nlon+1,nlat,Frame[0].Strip);
   return 0;
}


Pixmap IsoPixmap(double *Grid, int nlon, int nlat, struct ColorStrip Strip[])
{
   pix = XCreatePixmap(display,Cow,sfbox_w,sfbox_h,ScreenD);
   //XFillRectangle(display,Cow,gc,0,0,Frame[0].w,Frame[0].h);
   Flag = realloc(Flag,(nlon+1) * sizeof(int));
   IsoAreas(Grid,nlon+1,nlat,Strip);
   //XSetForeground(display,gc,Blue.pixel);
   //XDrawRectangle(display,Cow,gc,Frame[0].x-1,Frame[0].y-1,Frame[0].w,Frame[0].h);
   return pix;
}


int PPPCompiled(void)
{
   FILE *fp;
   char fn[128];

   strcpy(fn,"puma/run/");
   strcat(fn,exec_ppp);

   if ((fp = fopen(fn,"r")))
   {
      fclose(fp);
      return 1;
   }
   return 0;
}


void ShowOrography(void)
{
   int i,m,n,k,l,x,y,h,w,lon1,lon2,lat1,lat2,tx,ty,dx;
   int r,len,width,height,xp,yp;
   char Text[80];
   double flon,flat;

   XSetFont(display, gc, FixFont->fid);
   XSetForeground(display,gc,TextC);
   XSetBackground(display,gc,WinBG);

   if (Model == PLASIM)
   {
      if (Planet == MARS)
      {
         XCopyArea(display,OpmMars,Cow,gc,0,0,
                   Frame[0].w,Frame[0].h,Frame[0].x,Frame[0].y);
      }
      else if (Planet == EARTH)
      {
         XCopyArea(display,OpmEarth,Cow,gc,0,0,
                   Frame[0].w,Frame[0].h,Frame[0].x,Frame[0].y);
      }
      return;
   }

   k = 0; // Frame number 0 reserved for topography
   if (noro == 0) // No orography
   {
      XSetForeground(display,gc,Blue.pixel);
      XFillRectangle(display,Cow,gc,Frame[k].x-1,Frame[k].y-1,Frame[k].w,Frame[k].h);
      XSetForeground(display,gc,WhitePix);
      XSetBackground(display,gc,Blue.pixel);
      l = strlen("Aqua Planet Setup");
      tx = Frame[k].x + (Frame[k].w - l * FixFontWidth) / 2;
      ty = Frame[k].y + Frame[k].h / 2 - FixFontHeight;
      XDrawImageString(display,Cow,gc,tx,ty,"Aqua Planet Setup",l);
      l = strlen("To change mark option 'Orography'");
      tx = Frame[k].x + (Frame[k].w - l * FixFontWidth) / 2;
      ty += FixFontHeight;
      XDrawImageString(display,Cow,gc,tx,ty,"To change mark option 'Orography'",l);
      XSetBackground(display,gc,WinBG);
   }
   else
   {
      XCopyArea(display,OpmPrep,Cow,gc,0,0,Frame[0].w,Frame[0].h,Frame[0].x,Frame[0].y);
      XDrawRectangle(display,Cow,gc,Frame[k].x-1,Frame[k].y-1,Frame[k].w,Frame[k].h);
      l = strlen(Frame[k].t[0]);
      tx = Frame[k].x + (Frame[k].w - l * FixFontWidth) / 2;
      ty = Frame[k].y - FixFont->descent - 2;
      XDrawImageString(display,Cow,gc,tx,ty,Frame[k].t[0],l);
   }
   if (noro && (Button1Down || (Frame[k].ws && Frame[k].hs)))
   {
      x = Frame[k].x+Frame[k].xs;
      y = Frame[k].y+Frame[k].ys;
      w = Frame[k].ws;
      h = Frame[k].hs;
      if (w < 0) {x += w; w = -w;}
      if (h < 0) {y += h; h = -h;}
      XSetForeground(display,gc,WhitePix);
      XDrawArc(display,Cow,gc,x,y,w,h,0,FULLARC);
      XSetForeground(display,gc,BlackPix);
      XDrawArc(display,Cow,gc,x-1,y-1,w+2,h+2,0,FULLARC);
      flon = 360.0 / Frame[k].w;
      flat = 180.0 / Frame[k].h;
      lon1 = flon * (x - Frame[k].x);
      lon2 = lon1 + flon * w;
      lat1 = 90.0 - flat * (y - Frame[k].y);
      lat2 = lat1 - flat * h;
      sprintf(Frame[k].t[1],"Lon: (%3d:%3d) Lat: (%3d:%3d)",lon1,lon2,lat2,lat1);
      l = strlen(Frame[k].t[1]);
      tx = Frame[k].x;
      ty = Frame[k].y + Frame[k].h + FixFont->ascent;
      XDrawImageString(display,Cow,gc,tx,ty,Frame[k].t[1],l);
      XSetForeground(display,gc,WhitePix);
      sprintf(Frame[k].t[1],"Mouse marks area             ");
      l = strlen(Frame[k].t[1]);
      tx = Frame[k].x;
      ty = Frame[k].y + Frame[k].h + FixFont->ascent;
      XDrawImageString(display,Cow,gc,tx,ty,Frame[k].t[1],l);
   }
}


void ShowMars(void)
{
   if (Debug) printf("ShowMars\n");
   XPutImage(display,Cow,gc,MapLRM.X,0,0,Frame[1].x,Frame[1].y,MapLRM.w,MapLRM.h);
}


void ShowExo(void)
{
   XPutImage(display,Cow,gc,MapLRL.X,0,0,Frame[0].x,Frame[0].y,MapLRL.w,MapLRL.h);
   XPutImage(display,Cow,gc,MapLRK.X,0,0,Frame[1].x,Frame[1].y,MapLRK.w,MapLRK.h);
}


void ShowEarth(void)
{
   if (Debug) printf("ShowEarth\n");
   XPutImage(display,Cow,gc,MapLRE.X,0,0,Frame[1].x,Frame[1].y,MapLRE.w,MapLRE.h);
}


void ShowModeSelector(void)
{
   int k,dx,r,m,i,n,len,width,height,xp,yp,l,tx,ty;
   char Text[80];

   if (Debug) printf("ShowModeSelector\n");
   k  = 1; // Frame number 1 reserved for mode display
   pix = Frame[k].pixmap;
   strcpy(Frame[1].t[0],"Spherical Harmonics mode selector");
   dx = dxsh;
   r  = (dx+dx) / 3;
   XSetForeground(display,gc,BlackPix);
   XFillRectangle(display,pix,gc,0,0,Frame[k].w,Frame[k].h);
   for (m=0,i=0 ; m <= DimTr ; ++m)
   {
      for (n=m ; n <= DimTr ; ++n,++i)
      {
         if (Ampli[i]) XSetForeground(display,gc,Green.pixel);
         else          XSetForeground(display,gc,  Red.pixel);
         XFillArc(display,pix,gc,ModeX[i]-dxs2,ModeY[i]-dxs2,r,r,0,360*64);
      }
   }

   /* Draw mode legend */
   
   XSetForeground(display,gc,Yellow.pixel);
   XSetBackground(display,gc,BlackPix);
   XSetFont(display, gc, ModFont->fid);
   for (i=0 ; i < 21 ; i+=2)
   {
      sprintf(Text,"%d",i);
      len    = strlen(Text);
      width  = XTextWidth(ModFont,Text,len);
      height = ModFont->ascent + ModFont->descent;
      xp     = dx + i * dx - width/2 - ModFontWidth/2 + 1;
      yp     = ModFontHeight;
      XDrawImageString(display,pix,gc,xp,yp,Text,len);
   }
   strcpy(Text,"PUMA T21 only!");
   len = strlen(Text);
   xp  = dx - ModFontWidth/2 + 1;
   yp  = 2 * ModFontHeight + 10 * dx;
   XDrawImageString(display,pix,gc,xp,yp,Text,len);

   XSetForeground(display,gc,WhitePix);
   strcpy(Text,"MB 1: Toggle mode");
   len = strlen(Text);
   yp += 2*dx;
   XDrawImageString(display,pix,gc,xp,yp,Text,len);

   strcpy(Text,"MB 2: Toggle column");
   len = strlen(Text);
   yp += dx;
   XDrawImageString(display,pix,gc,xp,yp,Text,len);

   strcpy(Text,"MB 3: Toggle row");
   len = strlen(Text);
   yp += dx;
   XDrawImageString(display,pix,gc,xp,yp,Text,len);

   XSetForeground(display,gc,Yellow.pixel);
   strcpy(Text,"n : Total Wavenumber");
   len = strlen(Text);
   xp  = dx - ModFontWidth/2 + 1;
   yp  = 2 * ModFontHeight + 18 * dx;
   XDrawImageString(display,pix,gc,xp,yp,Text,len);

   XSetForeground(display,gc,LightBlue.pixel);
   for (i=0 ; i < 21 ; i+=2)
   {
      sprintf(Text,"%d",i);
      len    = strlen(Text);
      width  = XTextWidth(ModFont,Text,len);
      height = ModFont->ascent + ModFont->descent;
      xp     = Frame[k].w - width - 2;
      yp     = 2 * ModFontHeight + i * dx;
      XDrawImageString(display,pix,gc,xp,yp,Text,len);
   }
   strcpy(Text,"m : Zonal Wavenumber");
   len = strlen(Text);
   xp  = dx - ModFontWidth/2 + 1;
   yp  = 2 * ModFontHeight + 19 * dx;
   XDrawImageString(display,pix,gc,xp,yp,Text,len);

   XSetForeground(display,gc,Green.pixel);
   strcpy(Text,"Mode is on");
   len = strlen(Text);
   xp  = dx - ModFontWidth/2 + 1;
   yp  = ModFontHeight + 16 * dx;
   XFillArc(display,pix,gc,xp,yp+ModFont->descent+2,r,r,0,360*64);
   xp += dx;
   yp += dx;
   XDrawImageString(display,pix,gc,xp,yp,Text,len);

   XSetForeground(display,gc,Red.pixel);
   strcpy(Text,"Mode is off");
   len = strlen(Text);
   xp  = dx - ModFontWidth/2 + 1;
   yp  = ModFontHeight + 17 * dx;
   XFillArc(display,pix,gc,xp,yp+ModFont->descent+2,r,r,0,360*64);
   xp += dx;
   yp += dx;
   XDrawImageString(display,pix,gc,xp,yp,Text,len);

   XSetForeground(display,gc,WhitePix);
   strcpy(Text,"Switch all modes on");
   len = strlen(Text);
   xp  = dx - ModFontWidth/2 + 1;
   yp  = ModFontHeight + 20 * dx;
   XFillArc(display,pix,gc,xp,yp+ModFont->descent+2,r,r,0,360*64);
   xp += dx;
   yp += dx;
   XSetForeground(display,gc,Green.pixel);
   XDrawImageString(display,pix,gc,xp,yp,Text,len);

   XSetForeground(display,gc,WhitePix);
   strcpy(Text,"Switch all modes off");
   len = strlen(Text);
   xp  = dx - ModFontWidth/2 + 1;
   yp  = ModFontHeight + 21 * dx;
   XFillArc(display,pix,gc,xp,yp+ModFont->descent+2,r,r,0,360*64);
   xp += dx;
   yp += dx;
   XSetForeground(display,gc,Red.pixel);
   XDrawImageString(display,pix,gc,xp,yp,Text,len);

   XCopyArea(display,Frame[k].pixmap,Cow,gc,0,0,Frame[k].w,Frame[k].h,Frame[k].x,Frame[k].y);

   XSetForeground(display,gc,Cyan.pixel);
   l = strlen(Frame[k].t[0]);
   tx = Frame[k].x + (Frame[k].w - l * FixFontWidth) / 2;
   ty = Frame[k].y - FixFont->descent - 2;
   XDrawImageString(display,Cow,gc,tx,ty,Frame[k].t[0],l);
   XSetForeground(display,gc,LightBlue.pixel);
   l = strlen(Frame[k].t[1]);
   if (l)
   {
      tx = Frame[k].x + (3 * ModFontWidth) / 2;
      ty = Frame[k].y + Frame[k].h + FixFont->ascent;
      XDrawImageString(display,Cow,gc,tx,ty,Frame[k].t[1],l);
   }
}


void ShowFrame1(void)
{
   if (Model == PLASIM)
   {
           if (Planet == MARS) ShowMars();
      else if (Planet == EXO ) ShowExo();
      else                     ShowEarth();
   }
   else ShowModeSelector();
}


void PreProcess(void)
{
   FinishLine();
   if (Model == PUMA)
   {
      if (CheckPumaNamelist()) return;
      GenerateNames();
      WritePPPNamelist();
      WritePumaNamelist();
      if (!PPPCompiled()) BuildPPP();
      WriteRunPPP();
      Preprocessed = 1;
      if (Latitudes < 1000)
         sprintf(oro_name,"puma/run/N%3.3d_surf_0129.sra",Latitudes);
      else
         sprintf(oro_name,"puma/run/N%d_surf_0129.sra",Latitudes);
      OroPrep = ReadGrid(oro_name,Latitudes,RevGra);
      OpmPrep = IsoPixmap(OroPrep,2*Latitudes,Latitudes,OroStrip);
      free(OroPrep);
      OroClear = 0;
   }
   else
   {
      RedMessage("Preprocessing is for PUMA only");
      sleep(5);
   }
}


void ClearOro(void)
{
   OroClear = 1;
   OroAqua  = 1;
   OroAno   = 0;
   PreProcess();   
}

void WriteNamelistFile(char *nl,  int instance)
{
   char *shomo = ShortModelName[Model];
   struct SelStruct *Sel;
   char fn[256];
   FILE *fp;

   if (Multirun > 1)
      sprintf(fn,"%s/run/%s_namelist_%2.2d",shomo,nl,instance);
   else
      sprintf(fn,"%s/run/%s_namelist",shomo,nl);

   fp = fopen(fn,"w");
   if (fp == NULL)
   {
      printf("Could not open file <%s> for writing\n",fn);
      return; /* Failure */
   }

   // Write namelist file

   fprintf(fp," &%s_nl\n",nl);

   // Write special parameters

   if (!strcmp(nl,"icemod"))
   {
      fprintf(fp," %-12s=%6d\n","NICE",Ice);
   }
   if (!strcmp(nl,"oceanmod"))
   {
      fprintf(fp," %-12s=%6d\n","NOCEAN",Oce);
      fprintf(fp," %-12s=%6d\n","NLSG"  ,Lsg);
   }
   if (!strcmp(nl,"plasim"))
   {
      fprintf(fp," %-12s=%6d\n","NOUTPUT",noutput);
      fprintf(fp," %-12s=%6d\n","NGUI"  ,ngui);
      fprintf(fp," %-12s=%6d\n","N_START_YEAR",SimStart);
      if (Lsg)        fprintf(fp," %-12s=%6d\n","N_DAYS_PER_YEAR",360);
      else if (Planet != MARS) fprintf(fp," %-12s=%6d\n","N_DAYS_PER_YEAR",365);
      if (ngui) fprintf(fp," %-12s=%6d\n","N_RUN_YEARS",SimYears);
      else      fprintf(fp," %-12s=%6d\n","N_RUN_YEARS",1);
      fprintf(fp," %-12s=%6d\n","N_RUN_MONTHS",0);
      fprintf(fp," %-12s=%6d\n","N_RUN_DAYS",0);
   }
   for (Sel = ComEnd->Next ; Sel ; Sel = Sel->Next)
   {
      if (Sel->Item && !strcasecmp(Sel->Item->list,nl))
      {    
         if (Sel->type == SEL_TEVA)
            fprintf(fp," %-12s=%c%s%c\n",Sel->text,'\"',Sel->teva,'\"');
         else
            fprintf(fp," %-12s=%s\n",Sel->text,Sel->teva);
      }    
   }
   fprintf(fp," /END\n");
   fclose(fp);
}


/* =================== */
/* WritePlasimNamelist */
/* =================== */

void WritePlasimNamelist(void)
{
   int imr;

   FinishLine();

   for (imr = 0 ; imr < Multirun ; ++imr)
   {
      WriteNamelistFile("fluxmod" ,imr);
      WriteNamelistFile("icemod"  ,imr);
      WriteNamelistFile("landmod" ,imr);
      WriteNamelistFile("vegmod"  ,imr);
      WriteNamelistFile("miscmod" ,imr);
      WriteNamelistFile("oceanmod",imr);
      WriteNamelistFile("planet"  ,imr);
      WriteNamelistFile("plasim"  ,imr);
      WriteNamelistFile("radmod"  ,imr);
      WriteNamelistFile("rainmod" ,imr);
      WriteNamelistFile("seamod"  ,imr);
      WriteNamelistFile("surfmod" ,imr);
   }
}


void BuildScripts(void)
{
   if (Model == PUMA)
   {
      if (CheckPumaNamelist()) return;
      GenerateNames();
      WritePumaNamelist();
      if (!Build(PUMA)) Exit();
      WriteRunScript(PUMA);
   }
   if (Model == SAM)
   {
      if (CheckPumaNamelist()) return;
      GenerateNames();
      WritePumaNamelist();
      if (!Build(SAM)) Exit();
      WriteRunScript(SAM);
   }
   if (Model == CAT)
   {
      if (CheckCATNamelist()) return;
      GenerateNames();
      WriteCatNamelist();
      if (!Build(CAT)) Exit();
      WriteRunScript(CAT);
   }
   if (Model == PLASIM)
   {
      CheckPlasimNamelist();
      GenerateNames();
      WritePlasimNamelist();
      if (!Build(PLASIM)) Exit();
      WriteRunScript(PLASIM);
   }
}


void SaveExit(void)
{
   BuildScripts();
   if ((noro || Yoden) && !Preprocessed && Model == PUMA) PreProcess();
   Exit();
}


void SaveRun(void)
{
   char command[256];
   BuildScripts();
   if ((noro || Yoden) && !Preprocessed && Model == PUMA) PreProcess();
   sprintf(command,"%s/run/%s %s/run &",ShortModelName[Model],run_name,ShortModelName[Model]);
   system(command);
   printf("\n=== Success: Launched process %s ===\n\n",run_name);
   Exit();
}


void MarkRectangle(void)
{
   if (Model != PUMA) return;
   if (WinEvent.type == ButtonPress) 
   {
      Frame[FrameNo].xs = WinEvent.xbutton.x - Frame[FrameNo].x;
      Frame[FrameNo].ys = WinEvent.xbutton.y - Frame[FrameNo].y;
      Frame[FrameNo].ws = 0;
      Frame[FrameNo].hs = 0;
   }
   if (WinEvent.type == ButtonRelease) 
   {
      Frame[FrameNo].ws = WinEvent.xbutton.x - Frame[FrameNo].x - Frame[FrameNo].xs;
      Frame[FrameNo].hs = WinEvent.xbutton.y - Frame[FrameNo].y - Frame[FrameNo].ys;
   }
   if (WinEvent.type == MotionNotify && Button1Down) 
   {
      Frame[FrameNo].ws = WinEvent.xbutton.x - Frame[FrameNo].x - Frame[FrameNo].xs;
      Frame[FrameNo].hs = WinEvent.xbutton.y - Frame[FrameNo].y - Frame[FrameNo].ys;
   }
}


/* ==================================================== */
/* AzimuthalImage - Display map in azimuthal projection */
/* ==================================================== */

void AzimuthalImage(struct MapImageStruct *s, struct MapImageStruct *d)
{
   int lam;           // lambda pixel coordinate in source image
   int phi;           // phi    pixel coordinate in source image
   int x  ;           // x      pixel coordinate in destination image
   int y  ;           // y      pixel coordinate in destination image
   int dxc;           // pixel coordinate of centre     position
   int dxl;           // pixel coordinate of left  most position
   int dxr;           // pixel coordinate of right most position
   int dx ;           // centre relative x position
   int dy ;           // centre relative y position
   int p00;           // euqator
   int l00;           // reference longitude

   unsigned int dih;  // destination image height
   unsigned int diw;  // destination image width
   unsigned int dpw;  // destination image padded width

   double rad;        // pixel radius of new image
   double ysc;        // yscale = source height / destination height
   double rho;        // distance from centre
   double xpi;        // x scale factor = 2 * PI / width
   double ypi;        // y scale factor =     PI / height
   double xrf;
   double yrf;

   XImage *sX;        // source      image
   XImage *dX;        // destination image


   // Destroy old image structure inclusive data storage

   if (d->X) XDestroyImage(d->X);

   // Set width of new image

   diw = d->w;

   // Pad width of new image to a multiple of 8

   dpw = (diw + 7) & 0xFFF8;

   // Set height of new image

   dih =  d->h;

   // Allocate space for image data

   d->d = calloc(dpw * dih,4);

   // Create image structure

   dX = d->X = XCreateImage(display,CopyFromParent,ScreenD,ZPixmap,0,d->d,dpw,dih,8,0);
   sX = s->X;

   p00 = s->h >> 1;
   rad = dih  >> 1;
   dxc = diw  >> 1;
   dxl = MAX(dxc - rad,   0);
   dxr = MIN(dxc + rad, diw);
   xpi = s->w / M_PI * 0.5;
   ypi = s->h / M_PI;
   ysc = (double)s->h / (double)dih;
   l00 = (int)((d->l * s->w) / 360 + s->w/2) % s->w;
   xrf = (double)diw / pow(2.0,31),
   yrf = (double)dih / pow(2.0,31);

   // Paint some stars on the sky

   srandom(Seed);
   for (y = 0 ; y < (diw * dih) >> 8  ; ++y)
      XPutPixel(dX,xrf*random(),yrf*random(),WhitePix);

   for (y = 0 ; y < dih ; ++y)
   {
      dy  = y - rad;
      phi = y * ysc;
      for (x = dxl ; x < dxr ; ++x)
      {
         dx = x - dxc;
         rho = sqrt(dx * dx + dy * dy);
         if (rho < rad)
         {
            lam = l00 + xpi * atan2(dx / rad, cos(asin(rho / rad)));
            phi = p00 + ypi *  asin(dy / rad);
            XPutPixel(dX,x,y,XGetPixel(sX,lam,phi));
         }
      }
   }
}


/* =============================================== */
/* RectImage - Display map in azimuthal projection */
/* =============================================== */

void RectImage(struct MapImageStruct *s, struct MapImageStruct *d)
{
   int x  ;           // x      pixel coordinate in destination image
   int y  ;           // y      pixel coordinate in destination image

   unsigned int dih;  // destination image height
   unsigned int diw;  // destination image width
   unsigned int dpw;  // destination image padded width

   XImage *sX;        // source      image
   XImage *dX;        // destination image


   // Destroy old image structure inclusive data storage

   if (d->X) XDestroyImage(d->X);

   // Set width of new image

   diw = d->w;

   // Pad width of new image to a multiple of 8

   dpw = (diw + 7) & 0xFFF8;

   // Set height of new image

   dih =  d->h;

   // Allocate space for image data

   d->d = calloc(dpw * dih,4);

   // Create image structure

   dX = d->X = XCreateImage(display,CopyFromParent,ScreenD,ZPixmap,0,d->d,dpw,dih,8,0);
   sX = s->X;

   for (y = 0 ; y < dih ; ++y)
   {
      for (x = 0 ; x < diw ; ++x)
      {
         XPutPixel(dX,x,y,XGetPixel(sX,x,y));
      }
   }
}


void ToggleMode(void)
{
   int i,j,m,n,mx,my,dx,dy;

   if (Model == PLASIM) // Rotate image
   {
      if (WinEvent.xbutton.button == Button1) // Rotate right
      {
         if (Planet == MARS)
         {
            MapLRM.l += 10;
            if (MapLRM.l >  180) MapLRM.l -= 360;
            AzimuthalImage(&MapHRM,&MapLRM);
         }
         else
         {
            MapLRE.l += 10;
            if (MapLRE.l >  180) MapLRE.l -= 360;
            AzimuthalImage(&MapHRE,&MapLRE);
         }
      }
      else if (WinEvent.xbutton.button == Button3) // Rotate left
      {
         if (Planet == MARS)
         {
            MapLRM.l -= 10;
            if (MapLRM.l < -180) MapLRM.l += 360;
            AzimuthalImage(&MapHRM,&MapLRM);
         }
         else
         {
            MapLRE.l -= 10;
            if (MapLRE.l < -180) MapLRE.l += 360;
            AzimuthalImage(&MapHRE,&MapLRE);
         }
      }
      return;
   }
   if (WinEvent.type == ButtonPress) 
   {
      mx = WinEvent.xbutton.x - Frame[FrameNo].x;
      my = WinEvent.xbutton.y - Frame[FrameNo].y;
      for (i=0 ; i < DimSE ; ++i)
      {
         dx = mx - ModeX[i];
         dy = my - ModeY[i];
         if ((dx*dx + dy*dy) < ModeRadiusSq) break;
      }
      if (WinEvent.xbutton.button == Button1)
      {
               if (i == DimSH  ) // All modes on
            for (j=0 ; j < DimSH ; ++j) Ampli[j] = 1;
         else if (i == DimSH+1) // All modes off
            for (j=0 ; j < DimSH ; ++j) Ampli[j] = 0;
         else Ampli[i] = 1 - Ampli[i];
      }
      else if (WinEvent.xbutton.button == Button2 && i < DimSH)
      {
         n = ModeN[i];
         for (j=0 ; j < DimSH ; ++j)
            if (ModeN[j] == n) Ampli[j] = 1 - Ampli[j];
      }
      else if (WinEvent.xbutton.button == Button3 && i < DimSH)
      {
         m = ModeM[i];
         for (j=0 ; j < DimSH ; ++j)
            if (ModeM[j] == m) Ampli[j] = 1 - Ampli[j];
      }
   }
   if (WinEvent.type == MotionNotify) 
   {
      mx = WinEvent.xbutton.x - Frame[FrameNo].x;
      my = WinEvent.xbutton.y - Frame[FrameNo].y;
      for (i=0 ; i < DimSH ; ++i)
      {
         dx = mx - ModeX[i];
         dy = my - ModeY[i];
         if ((dx*dx + dy*dy) < ModeRadiusSq)
         {
            sprintf(Frame[1].t[1],"Mode (%2d:%2d)",ModeN[i],ModeM[i]);
            return;
         }
      }
      Frame[1].t[1][0] = 0;
   }
   return;
}


void InitFrames(void)
{
   int i,j,n;
   int moselw;
   FILE *ftp;

   /* Size and position of orography window */

   sfbox_w = 360;
   sfbox_h = 180;
   sfbox_x = WINDOW_WIDTH - sfbox_w - 3 * FixFontWidth;
   sfbox_y = nlbox_y + 4;

   /* Parameter for default orographies */

   nlat = 64;
   nlon = nlat * 2;
   VGAX = (sfbox_w - 1.0) / nlon;
   VGAY = (sfbox_h - 1.0) / (nlat-1);

   /* Read T42 orography for Earth and Mars */

   OroEarth = ReadGrid("plasim/dat/T42/N064_surf_0129.sra",nlat,RevGra);
   OroMars  = ReadGrid("plasim/dat/T42_mars/N064_surf_0129.sra",nlat,1.0/3.74);
   OpmEarth = IsoPixmap(OroEarth,nlon,nlat,OroStrip);
   OpmPrep  = IsoPixmap(OroEarth,nlon,nlat,OroStrip);
   OpmMars  = IsoPixmap(OroMars ,nlon,nlat,OroMarsStrip);
   free(OroEarth);
   free(OroMars);

   /* Check for orography in run directory */

   ftp = fopen(oro_name,"r");
   if (ftp) fclose(ftp);
   else strcpy(oro_name,"puma/dat/N064_surf_0129.sra");

   // Orography

   n = 0;

   Frame[n].x = sfbox_x;
   Frame[n].y = sfbox_y + FixFontHeight;
   Frame[n].w = sfbox_w;
   Frame[n].h = sfbox_h;
   Frame[n].b = DarkGreen.pixel;
   Frame[n].f = WhitePix;
   strcpy(Frame[n].t[0],"Orography");
   strcpy(Frame[n].t[1],"64 x 32");
   strcpy(Frame[n].t[2],"");
   Frame[n].Action = MarkRectangle;
   Frame[n].xs =  110;
   Frame[n].ys =   95;
   Frame[n].ws =   60;
   Frame[n].hs =   40;
   SelAno->x    = Frame[n].x;
   SelAno->y    = Frame[n].y + Frame[n].h + FixFontHeight;
   SelAno->edco = 6;
   SelAno->w    = SelAno->edco * FixFontWidth + 2;
   SelAno->xt   = SelAno->x + (SelAno->edco + 1) * FixFontWidth;
   SelAno->yt   = SelAno->y + FixFont->ascent + 1;
   strcpy(SelAno->teva,"     0");
   Button[4].y = SelAno->y - FixFontHeight/2; // Clear orography button 
   Button[4].x = Frame[n].x + Frame[n].w - 6 * FixFontWidth;

   // T21 mode selector


   ++n;
   Frame[n].x = sfbox_x;
   Frame[n].y = Frame[n-1].y + Frame[n-1].h + 4 * FixFontHeight;
   moselw = sfbox_w;
   if (SmallScreen)
   {
       moselw = WinYSize - Frame[n].y - FixFontHeight - FixFontHeight/2;
       Frame[n].x += (sfbox_x - moselw) / 2;
   }
   Frame[n].w = moselw;
   Frame[n].h = moselw;
   Frame[n].b = BlackPix;
   Frame[n].f = WhitePix;
   strcpy(Frame[n].t[0],"Spherical Harmonics mode selector");
   strcpy(Frame[n].t[1],"");
   strcpy(Frame[n].t[2],"");
   Frame[n].Action = ToggleMode;

   sfbox_b = Frame[n].y + Frame[n].h - Frame[0].y + 2 * FixFontHeight + FixFontHeight/2;

   Frames = n + 1;
}


void InitButtons(void)
{
   int n;

   bubox_w = 64;
   bubox_h = 64;
   bubox_x = WINDOW_WIDTH - 4 * 64 - 6 * FixFontWidth;
   bubox_y = 8;

   // Preprocess

   n = 0;

   Button[n].x = bubox_x;
   Button[n].y = bubox_y;
   Button[n].w = bubox_w;
   Button[n].h = bubox_h;
   Button[n].b = Yellow.pixel;
   Button[n].f = BlackPix;
   strcpy(Button[n].t[0],"Pre-");
   strcpy(Button[n].t[1],"pro-");
   strcpy(Button[n].t[2],"cess");
   Button[n].Action = PreProcess;

   // Save & Exit

   ++n;
   Button[n].x = Button[n-1].x + Button[n-1].w + FixFontWidth;
   Button[n].y = Button[n-1].y;
   Button[n].w = bubox_w;
   Button[n].h = bubox_h;
   Button[n].b = DarkGreen.pixel;
   Button[n].f = WhitePix;
   strcpy(Button[n].t[0],"Save");
   strcpy(Button[n].t[1],"&");
   strcpy(Button[n].t[2],"Exit");
   Button[n].Action = SaveExit;

   // Save & Run

   ++n;
   Button[n].x = Button[n-1].x + Button[n-1].w + FixFontWidth;
   Button[n].y = Button[n-1].y;
   Button[n].w = bubox_w;
   Button[n].h = bubox_h;
   Button[n].b = DarkBlue.pixel;
   Button[n].f = WhitePix;
   strcpy(Button[n].t[0],"Save");
   strcpy(Button[n].t[1],"&");
   strcpy(Button[n].t[2],"Run");
   Button[n].Action = SaveRun;

   // Abort

   ++n;
   Button[n].x = Button[n-1].x + Button[n-1].w + FixFontWidth;
   Button[n].y = Button[n-1].y;
   Button[n].w = bubox_w;
   Button[n].h = bubox_h;
   Button[n].b = Red.pixel;
   Button[n].f = WhitePix;
   strcpy(Button[n].t[1],"Abort");
   Button[n].Action = Abort;

   // Clear orography

   ++n;
   // Button[n].x = Button[n-1].x;
   // Button[n].y = Button[n-1].y; // set in InitFrames
   Button[n].w = 6 * FixFontWidth;
   Button[n].h = 2 * FixFontHeight;
   Button[n].b = DarkBlue.pixel;
   Button[n].f = Yellow.pixel;
   strcpy(Button[n].t[1],"Clear");
   Button[n].Action = ClearOro;
}

/* ================== */
/* CreateModeSelector */
/* ================== */

void CreateModeSelector(int k)
{
   int i,j,m,n;
   int x,y,len,width,height;
   int r,dx,dy,xp,yp;
   char Text[20];

   pix = Frame[k].pixmap = XCreatePixmap(display,Cow,Frame[k].w,Frame[k].h,ScreenD);

   if (!Ampli) Ampli = malloc(DimSE * sizeof(int));
   if (!ModeX) ModeX = malloc(DimSE * sizeof(int));
   if (!ModeY) ModeY = malloc(DimSE * sizeof(int));
   if (!ModeM) ModeM = malloc(DimSE * sizeof(int));
   if (!ModeN) ModeN = malloc(DimSE * sizeof(int));

   dxsh = Frame[k].w / (DimTr + 3);
   dxs2 = dxsh / 2;
   dx   = dxsh;
   r  = (dx+dx) / 3;
   ModeRadiusSq = r*r;

   for (m=0,i=0 ; m <= DimTr ; ++m)
   {
      y = ModFontHeight + 4 + m * dx;
      for (n=m ; n <= DimTr ; ++n,++i)
      {
         x = dx/2 + n * dx;
         Ampli[i] = 1;
         ModeX[i] = x + dx/2;
         ModeY[i] = y + dx/2;
         ModeM[i] = m;
         ModeN[i] = n;
      }
   }
   i  = DimSH; // Button for all modes on
   x  = dx - ModFontWidth/2 + 1;
   y  = ModFontHeight + ModFont->descent + 2 + 20 * dx;
   Ampli[i] = 0;
   ModeX[i] = x + dx/2;
   ModeY[i] = y + dx/2;
   i++;       // Button for all modes off
   y += dx;
   Ampli[i] = 0;
   ModeX[i] = x + dx/2;
   ModeY[i] = y + dx/2;

   /* Draw mode legend */
   
   dx = dxsh;
   XSetForeground(display,gc,Red.pixel);
   XSetBackground(display,gc,BlackPix);
   for (i=0 ; i < 21 ; i+=2)
   {
      sprintf(Text,"%d",i);
      len    = strlen(Text);
      width  = XTextWidth(ModFont,Text,len);
      height = ModFont->ascent + ModFont->descent;
      xp     = dx + i * dx - width/2 - ModFontWidth/2 + 1;
      yp     = ModFontHeight;
      XDrawImageString(display,pix,gc,xp,yp,Text,len);
   }
   XSetForeground(display,gc,Blue.pixel);
   for (i=0 ; i < 21 ; i+=2)
   {
      sprintf(Text,"%d",i);
      len    = strlen(Text);
      width  = XTextWidth(ModFont,Text,len);
      height = ModFont->ascent + ModFont->descent;
      xp     = Frame[k].x + Frame[k].w - width - 2;
      yp     = 2 * ModFontHeight + i * dx;
      XDrawImageString(display,pix,gc,xp,yp,Text,len);
   }
}


void ShowButtons(void)
{
   int i,k,l,x,y,d;

   XSetFont(display, gc, FixFont->fid);
   for (k=0 ; k < DIMBUTTON ; ++k)
   {
      if (k == 4 && SelAno->hide) continue;
      d = Button[k].h / 4;
      XSetForeground(display,gc,Button[k].b);
      XFillRectangle(display,Cow,gc,Button[k].x,Button[k].y,Button[k].w,Button[k].h);
      XSetForeground(display,gc,Button[k].f);
      XSetBackground(display,gc,Button[k].b);
      for (i=0 ; i < 3 ; ++i)
      if (Button[k].t[i][0])
      {
         l = strlen(Button[k].t[i]);
         x = Button[k].x + (Button[k].w - l * FixFontWidth) / 2;
         y = Button[k].y + i * d + FixFont->ascent + d/2;
         XDrawImageString(display,Cow,gc,x,y,Button[k].t[i],l);
      }
   }
}


int AllocateColorCells(struct ColorStrip cs[])
{
   int i = 0;
   XColor xcolor1,xcolor2;

   while (cs[i].Name)
   {
      XAllocNamedColor(display,colormap,cs[i].Name,&xcolor1,&xcolor2);
      cs[i].pixel = xcolor1.pixel;
      ++i;
   }   
   return i;
}

void InitColors(void)
{
/*
   Visual *visual;
   int count,st;
   XStandardColormap *best_map_info;
   XStandardColormap bmi[8];

   visual = DefaultVisual(display,0);
   memset(bmi,0,8*sizeof(XStandardColormap));
   best_map_info = bmi;

   count = 0;
   st = XGetRGBColormaps(display,RootWindow(display,0),&best_map_info,&count,XA_RGB_DEFAULT_MAP);
   {
      printf("status = %d  count=%d\n",st,count);
      printf("colormap = %p\n",bmi[0].colormap);
      printf("mapping = %x/%x/%x\n",bmi[0].red_max,bmi[0].green_max,bmi[0].blue_max);
   }
*/

   // colormap = best_map_info->colormap;

   AllocateColorCells(OroStrip);
   AllocateColorCells(OroMarsStrip);
   AllocateColorCells(GibbStrip);
   AllocateColorCells(TStrip);

   XAllocNamedColor(display,colormap,"red"        ,&Red       ,&Dummy);
   XAllocNamedColor(display,colormap,"green"      ,&Green     ,&Dummy);
   XAllocNamedColor(display,colormap,"blue"       ,&Blue      ,&Dummy);
   XAllocNamedColor(display,colormap,"grey"       ,&Grey      ,&Dummy);
   XAllocNamedColor(display,colormap,"hot pink"   ,&LightRed  ,&Dummy);
   XAllocNamedColor(display,colormap,"dark red"   ,&DarkRed   ,&Dummy);
   XAllocNamedColor(display,colormap,"light blue" ,&LightBlue ,&Dummy);
   XAllocNamedColor(display,colormap,"dark blue"  ,&DarkBlue  ,&Dummy);
   XAllocNamedColor(display,colormap,"light green",&LightGreen,&Dummy);
   XAllocNamedColor(display,colormap,"dark green" ,&DarkGreen ,&Dummy);
   XAllocNamedColor(display,colormap,"yellow"     ,&Yellow    ,&Dummy);
   XAllocNamedColor(display,colormap,"cyan"       ,&Cyan      ,&Dummy);

   TextC = Yellow.pixel;
   HeadC = Cyan.pixel;
}

struct BMIstruct
{
   int   Size;
   int   Width;
   int   Height;
   short Planes;
   short Count;
   int   Compression;
   int   SizeImage;
   int   XPelsPerMeter;
   int   YPelsPerMeter;
   int   ClrUsed;
   int   ClrImportant;
};

// Convert an RGB value to an X11 Pixel

unsigned long create_pixel(long red, long green, long blue)
{
   if (ScreenD == 24)       // 24 bit true color
   {
       return blue | green << 8 | red << 16;
   }
   else if (ScreenD == 16)  // 16 bit RGB 565
   {
      return blue >> 3 | (green >> 2) << 5 | (red >> 3) << 11;

   }
   else return 0;
}


void SwapIEEE16(char W[2])
{
   char B;

   B = W[0]; W[0] = W[1]; W[1] = B; 
}

void SwapIEEE32(char W[4])
{
   char B;

   B = W[0]; W[0] = W[3]; W[3] = B; 
   B = W[1]; W[1] = W[2]; W[2] = B; 
}

int ReadINT(FILE *fpi)
{
   int k;
   fread(&k,sizeof(k),1,fpi);
   if (BigEndian) SwapIEEE32((char *)&k);
   return k;
}

short ReadSHORT(FILE *fpi)
{
   short k;
   fread(&k,sizeof(k),1,fpi);
   if (BigEndian) SwapIEEE16((char *)&k);
   return k;
}

struct BMIstruct ImageBMI;

void ReadImage(struct MapImageStruct *ei, char *filename)
{
   char ch;
   int i,n,x,y,z;
   long r,g,b;
   int FileSize;
   int Reserved;
   int OffBits;
   int PicBytes;
   int ImgBytes;
   int PadWidth;
   int PadBytes;
   int bpp;
   int byr;
   FILE *fp;
   unsigned char *BuffImageData;

   if (!(fp = fopen(filename,"r"))) return;
   ch = fgetc(fp);
   if (ch != 'B') return;
   ch = fgetc(fp);
   if (ch != 'M') return;
   FileSize = ReadINT(fp);
   Reserved = ReadINT(fp);
   OffBits  = ReadINT(fp);

   if (Debug)
   {
      printf("Properties of %s:\n",filename);
      printf("FileSize   = %d\n",FileSize);
      printf("FileOffset = %d\n",OffBits);
   }

   ImageBMI.Size          = ReadINT(fp);
   ImageBMI.Width         = ReadINT(fp);
   ImageBMI.Height        = ReadINT(fp);
   ImageBMI.Planes        = ReadSHORT(fp);
   ImageBMI.Count         = ReadSHORT(fp);
   ImageBMI.Compression   = ReadINT(fp);
   ImageBMI.SizeImage     = ReadINT(fp);
   ImageBMI.XPelsPerMeter = ReadINT(fp);
   ImageBMI.YPelsPerMeter = ReadINT(fp);
   ImageBMI.ClrUsed       = ReadINT(fp);
   ImageBMI.ClrImportant  = ReadINT(fp);

   PadWidth = (ImageBMI.Width + 7) & 0xFFF8;
   bpp      =  ImageBMI.Count >> 3;
   PadBytes = (4 - ((ImageBMI.Width * bpp) % 4)) % 4 ;

   if (Debug)
   {
      printf("BMI Size     = %d\n",ImageBMI.Size);
      printf("BMI Width    = %d\n",ImageBMI.Width);
      printf("BMI Height   = %d\n",ImageBMI.Height);
      printf("BMI Planes   = %d\n",ImageBMI.Planes);
      printf("BMI Count    = %d\n",ImageBMI.Count);
      printf("BMI ClrUsed  = %d\n",ImageBMI.ClrUsed);
      printf("BMI ClrImpo  = %d\n",ImageBMI.ClrImportant);
      printf("Pad Bytes    = %d\n",PadBytes);
      printf("Pad Width    = %d\n",PadWidth);
   }

   PicBytes = (bpp * ImageBMI.Width + PadBytes) * ImageBMI.Height;
   ImgBytes = 4 * PadWidth * ImageBMI.Height;
   ei->d = calloc(ImgBytes,1);
   BuffImageData = malloc(PicBytes);

   fseek(fp,OffBits,SEEK_SET);
   n = fread(BuffImageData,1,PicBytes,fp);
   fclose(fp);  

   if (Debug)
   {
      printf("Size Bytes   = %d\n",PicBytes);
      printf("Read Bytes   = %d\n",n);
   }
   
   ei->X = XCreateImage(display,CopyFromParent,ScreenD,ZPixmap,0,
                  ei->d,PadWidth,ImageBMI.Height,8,0);

   for (y = 0 ; y < ImageBMI.Height ; ++y)
   {
      for (x = 0 ; x < ImageBMI.Width  ; ++x)
      {
          i = bpp * x + (ImageBMI.Height - 1 - y) * (ImageBMI.Width*bpp+PadBytes);
          b = BuffImageData[i  ];
          g = BuffImageData[i+1];
          r = BuffImageData[i+2];
          XPutPixel(ei->X, x, y, create_pixel(r,g,b));
      }
   }
   free(BuffImageData);
   ei->w = ImageBMI.Width;
   ei->h = ImageBMI.Height;
}

void ReadLogo(int logo, char *filename)
{
   struct MapImageStruct MapI;

   ReadImage(&MapI,filename);

   Logo[logo].w = MapI.w;
   Logo[logo].h = MapI.h;
   Logo[logo].X = MapI.X;

   if (logo)
   {
      Logo[logo].x = Logo[logo-1].x + Logo[logo-1].w;
      Logo[logo].y = Logo[logo-1].y;
   }
}

void ShowCopyright(void)
{
   int x,y;
   x = CowSizeHints.min_width - 18.5 * ModFontWidth;
   y = CowSizeHints.min_height - ModFontHeight/2;
   XSetFont(display, gc, ModFont->fid);
   XSetForeground(display,gc,Grey.pixel);
   XSetBackground(display,gc,BlackPix);
   XDrawImageString(display,Cow,gc,x,y,"Image Credit: NASA",18);
}

int redaco;

int RedrawControlWindow(void)
{
   int i,l,x,y;
   double xrf,yrf;
   struct SelStruct *Sel;

   XWindowAttributes CurAtt;

   if (Debug) printf("Redraw %d\n",redaco++);
   XGetWindowAttributes(display,Cow,&CurAtt);
   WinXSize = CurAtt.width;
   WinYSize = CurAtt.height;
   
   XSetWindowBackground(display,Cow,WinBG);
   XClearWindow(display,Cow);

   // Paint some stars on the sky

   xrf = (double)WinXSize / pow(2.0,31),
   yrf = (double)WinYSize / pow(2.0,31);

   XSetForeground(display,gc,WhitePix);
   srandom(Seed);
   for (y = 0 ; y < ((WinXSize * WinYSize) >> 8)  ; ++y)
      XDrawPoint(display,Cow,gc,xrf*random(),yrf*random());

   XSetForeground(display,gc,BlackPix);
   XSetBackground(display,gc,WhitePix);

   for (Sel = &SelStart ; Sel ; Sel = Sel->Next) ShowSelection(Sel);

   if (CursorSel) CursorOn();

   ShowOrography();
   ShowFrame1();
   ShowButtons();
   for (l=0 ; l < Logos ; ++l)
   {
      XPutImage(display,Cow,gc,Logo[l].X,0,0,Logo[l].x,Logo[l].y,Logo[l].w,Logo[l].h);
   }
   if (Model == PLASIM) ShowCopyright();
   XSync(display,0);
   return 0;
}


void ChangeResolution(int NewRes)
{
   int i;
   struct SelStruct *Sel;

   for (i=RES_T21 , Sel = SelRes ; i <= RES_T42; ++i , Sel = Sel->Next)
   {
      if (i == NewRes) Sel->iv = 1;
      else             Sel->iv = 0;
   }
   Resolution = NewRes;
}


void UpdateResolution(void)
{
   int i;
   struct SelStruct *Sel;

   if (SelRes)
   for (i=RES_T21 , Sel = SelRes ; i <= RES_T42; ++i , Sel = Sel->Next)
   {
      if (Sel && Sel->iv == 1) Resolution = i;
   }
}


char *vcn[6] =
{
   "StaticGray",
   "GrayScale",
   "StaticColor",
   "PseudoColor",
   "TrueColor",
   "DirectColor"
};


void InitGUI(void)
{
   int argc = 1;
   int i,j,k;
   char *WinconTitle1 = {"MoSt - Model Suite (17) - University of Hamburg"};
   unsigned long valuemask = 0; /* ignore XGCvalues and use defaults */
   FILE *ftp;
   FILE *xpp;
   XVisualInfo vinfo;

   XGCValues values;
   XEvent Event;
   XWindowAttributes CurAtt;

   if ((display=XOpenDisplay(display_name)) == NULL)
   {
      fprintf(stderr,"%s: cannot connect to X server %s\n", 
              progname, XDisplayName(display_name));
      exit(1);
   }
   ScreenN  = DefaultScreen(display);
   ScreenD  = XDefaultDepth(display,ScreenN);
   ScreenW  = DisplayWidth (display,ScreenN);
   ScreenH  = DisplayHeight(display,ScreenN);
   if (ScreenHeight) ScreenH = ScreenHeight;

   if (Debug)
   {
      i=5;
      while (!XMatchVisualInfo(display,ScreenN,ScreenD,i--,&vinfo));
      printf("Found visual %s at depth %d\n",vcn[++i],ScreenD);
      printf("Red   mask = %8lx\n",vinfo.red_mask);
      printf("Green mask = %8lx\n",vinfo.green_mask);
      printf("Blue  mask = %8lx\n",vinfo.blue_mask);
   }

   BlackPix = BlackPixel(display,ScreenN);
   WhitePix = WhitePixel(display,ScreenN);
   SmallScreen = ScreenH < 768;

   wm_hints.initial_state = NormalState;
   wm_hints.input = True;
   wm_hints.flags = StateHint | InputHint;
   
   class_hints.res_name = progname;
   class_hints.res_class = "MOST";

   Delwin = XInternAtom(display,"WM_DELETE_WINDOW",0);


   LoadFonts();

   /* Setup control window */

   CowSizeHints.flags      = PPosition | PSize | PMinSize | PMaxSize;
   CowSizeHints.min_width  = MIN(WINDOW_WIDTH,ScreenW);
   CowSizeHints.min_height = MIN(740,ScreenH);
   CowSizeHints.max_width  = CowSizeHints.min_width;
   CowSizeHints.max_height = CowSizeHints.min_height;
   Cow = XCreateSimpleWindow(display,RootWindow(display,ScreenN), 
               0,0,
               CowSizeHints.max_width,CowSizeHints.max_height,
               4,BlackPix,WhitePix);
   XStringListToTextProperty(&WinconTitle1,1,&WinconName1);
   XSetWMProtocols(display,Cow,&Delwin,1);
   XSetWMProperties(display,Cow,&WinconName1,NULL,
		NULL,0,&CowSizeHints,&wm_hints,&class_hints);
   XSelectInput(display,Cow,ButtonPressMask | ButtonReleaseMask | 
                PointerMotionMask | KeyPressMask | ExposureMask);
   XMapWindow(display,Cow);


   XGetWindowAttributes(display,Cow,&CurAtt);
   WinXSize = CurAtt.width;
   WinYSize = CurAtt.height;

   /* Prepare GC */

   gc = XCreateGC(display, Cow, valuemask, &values);
   XSetFont(display, gc, FixFont->fid);
   colormap = XDefaultColormap(display,ScreenN);
   XSetForeground(display,gc,BlackPix);
   XSetBackground(display,gc,WhitePix);

   Mok = XGetModifierMapping(display);

   InitColors();

   /* Look for Num_Lock key */

   for (j=0 ; j < 8 ; ++j)
   {
      k = Mok->modifiermap[j * Mok->max_keypermod];
      if (XkbKeycodeToKeysym(display,k,0,0) == XK_Num_Lock   ) NumLockMask    = 1 << j;
      if (XkbKeycodeToKeysym(display,k,0,0) == XK_Mode_switch) ModeSwitchMask = 1 << j;
   }
   if (Debug) printf("NumLockMask    = %02X\n",NumLockMask   );
   if (Debug) printf("ModeSwitchMask = %02X\n",ModeSwitchMask);
   if (Debug)
   for (j=0 ; j < 8 ; ++j)
   {
      printf("Mok [%d] %d:",Mok->max_keypermod,j);
      for (i=0 ; i < Mok->max_keypermod ; ++i)
      {
	 k = Mok->modifiermap[i+j*Mok->max_keypermod];
         if (XkbKeycodeToKeysym(display,k,0,0) != NoSymbol)
         printf("  %4x %-16.16s   ",k,XKeysymToString(XkbKeycodeToKeysym(display,k,0,0)));
      }
      printf("\n");
   }
   XDisplayKeycodes(display,&EdiFirstKey,&EdiLastKey);
   EdiKeymap = XGetKeyboardMapping(display,EdiFirstKey,EdiLastKey-EdiFirstKey+1,&EdiSymsPerKey);

   /* Sun keymaps don't have lower case entries */

   for (j=EdiFirstKey ; j <= EdiLastKey ; ++j)
   {
      k = (j - EdiFirstKey) * EdiSymsPerKey;
      if (EdiKeymap[k] >= 'A' && EdiKeymap[k] < 0xE0 && EdiKeymap[k+1] == 0)
      {
         EdiKeymap[k+1] = EdiKeymap[k];
         EdiKeymap[k]  += 0x20;
      }
   }

   xpp = fopen("Beginner","r"); // Expert mode ?
   if (xpp)
   {
      Expert = 0;
      fclose(xpp);
   }

   xpp = fopen("cat","r"); // Cat enabled
   if (xpp)
   {
      CatEnabled = 1;
      fclose(xpp);
   }

   xpp = fopen("sam","r"); // Sam enabled
   if (xpp)
   {
      SamEnabled = 1;
      fclose(xpp);
   }

   xpp = fopen("lsg/src/lsgmod.f90","r"); // LSG there ?
   if (xpp)
   {
      LsgEnabled = 1;
      fclose(xpp);
   }

   xpp = fopen("puma/src/mpimod_multi.f90","r"); // Multirun module there ?
   if (xpp)
   {
      MultirunEnabled = 1;
      fclose(xpp);
   }

   // Read name of MPI execute command

   xpp = fopen("most_compiler_mpi","r"); // MPI installed ?
   if (xpp)
   {
      fgets(Buffer,LINEMAX,xpp);
      if (Buffer[strlen(Buffer)-1] == 10) Buffer[strlen(Buffer)-1] = 0;
      if (Buffer[strlen(Buffer)-1] == 13) Buffer[strlen(Buffer)-1] = 0;
      if (!strncmp(Buffer,"MPI_RUN=",8))  strcpy(mpirun,Buffer+8);
      fclose(xpp);
   }

   InitLogo();
   ReadLogo(0,"images/KC-Logo_RGB.bmp");
   ReadLogo(1,"images/puma.bmp");
   ReadLogo(2,"images/cat.bmp");
   ReadLogo(3,"images/plasim.bmp");
   ReadImage(&MapHRE,"images/earth.bmp");
   ReadImage(&MapHRM,"images/mars.bmp");
   ReadImage(&MapLRK,"images/Kepler-16.bmp");
   ReadImage(&MapLRL,"images/habit360x180.bmp");
   opbox_y = 8 + 64 + 2 * FixFontHeight;
   InitSelections();

   InitNamelist();
   
   ChangeModel(PLASIM);
   NamelistSelector(PLASIM);
   ChangeModel(CAT);
   NamelistSelector(CAT);
   ChangeModel(SAM);
   NamelistSelector(SAM);
   ChangeModel(PUMA);
   NamelistSelector(PUMA);

   if (ReadSettings(cfg_file))
   {
      UpdateResolution();
      UpdateSelections(&SelStart);
   }

   InitFrames();
   CalcFrame(nlat);
   CreateModeSelector(1);
   InitButtons();
   MapLRE.w = Frame[1].w;
   MapLRE.h = Frame[1].h;
   MapLRK.w = Frame[1].w;
   MapLRK.h = Frame[1].h;
   MapLRM.w = Frame[1].w;
   MapLRM.h = Frame[1].h;
   MapLRL.w = Frame[0].w;
   MapLRL.h = Frame[0].h;
   MapLRM.l = -90;
   AzimuthalImage(&MapHRE,&MapLRE);
   AzimuthalImage(&MapHRM,&MapLRM);
   RedrawControlWindow();
}


int HitBox(struct SelStruct *Sel)
{
   return (
   (WinEvent.xbutton.button == Button1) &&
   (WinEvent.xbutton.x >= Sel->x) &&
   (WinEvent.xbutton.x <  Sel->x + Sel->w) &&
   (WinEvent.xbutton.y >= Sel->y) &&
   (WinEvent.xbutton.y <  Sel->y + Sel->h));
}


int HitButton(int k)
{
   return (
   (WinEvent.xbutton.button == Button1) &&
   (WinEvent.xbutton.x >= Button[k].x) &&
   (WinEvent.xbutton.x <  Button[k].x + Button[k].w) &&
   (WinEvent.xbutton.y >= Button[k].y) &&
   (WinEvent.xbutton.y <  Button[k].y + Button[k].h));
}


int HitFrame(int k)
{
   return (
   (WinEvent.xbutton.x >= Frame[k].x) &&
   (WinEvent.xbutton.x <  Frame[k].x + Frame[k].w) &&
   (WinEvent.xbutton.y >= Frame[k].y) &&
   (WinEvent.xbutton.y <  Frame[k].y + Frame[k].h));
}


int OnFrame(int i)
{
   if (HitFrame(i))
   {
      FrameNo = i;
      Frame[i].Action();
      return 1;
   }
   return 0;
}

void OnMouseClick(void)
{
   int i,j,cp;
   struct SelStruct *Sel;

   /* Check Action Buttons */

   for (i=0 ; i < DIMBUTTON ; ++i)
   {
      if (HitButton(i))
      {
         Button[i].Action();
         return;
      }
   }

   /* Check for model switch */

   for (i = PUMA , Sel = SelMod ; i < MODELS ; ++i , Sel = Sel->Next)
   {
      if (HitBox(Sel) && Model != i)
      {
         if (i == CAT && !CatEnabled) return; // Hide CAT
         if (Debug) printf("Change model from %d to %d\n",Model,i);
         ChangeModel(i);
         CalcFrame(Latitudes);
         return;
      }
   }

   /* Continue with all other boxes */

   for ( ; Sel ; Sel = Sel->Next)
   {
      if (Sel->type == SEL_CHECK && HitBox(Sel) && !Sel->no)
      {
         cp = -1;
         for (i=0 ; i < PLANETS ; ++i) if (Sel == SelPlanet[i]) cp = i;
         if (cp >= 0 && Planet != cp) ChangePlanet(cp);
         else
         {
            Sel->iv = !Sel->iv;
            if (Sel->piv) *Sel->piv = Sel->iv;
         }
      }
      else if ((Sel->type == SEL_INT || Sel->type == SEL_REAL) && HitBox(Sel))
      {
         // printf("Target is <%s>\n",Sel->text);
         if (Sel != CursorSel) FinishLine();
         CursorSel = Sel;
         CursorCol = (WinEvent.xbutton.x - Sel->x) / FixFontWidth;
         if (CursorCol > Sel->edco-1) CursorCol = Sel->edco-1;
         CursorOn();
      }
   }

   /* Allow only one horizontal resolution */

   if (SelRes)
   {
      for (i = RES_T21 , Sel = SelRes ; i <= RES_T42 ; ++i , Sel = Sel->Next)
      if (HitBox(Sel))
      {
         ChangeResolution(i);
         return;
      }
   }
}


int EdiDecodeKey(void)
{
   int ShiftStatus;
   int ShiftIndex;
   int KeyCode;
   int KeyIndex;

   ShiftStatus =  WinEvent.xkey.state;
   KeyIndex    = (WinEvent.xkey.keycode-EdiFirstKey) * EdiSymsPerKey;
   KeyCode     = EdiKeymap[KeyIndex]; // Code with no modifiers
   if (ShiftStatus & 0x04)            // Control
   {
      if (KeyCode >= 0x40 && KeyCode < 0x80) KeyCode &= 0x1F;
   }
   else if (ShiftStatus & NumLockMask &&
            EdiKeymap[KeyIndex+1] >= XK_KP_Separator &&  // Numlock
	    EdiKeymap[KeyIndex+1] <= XK_KP_9)            // PC Keypad
      KeyCode = EdiKeymap[KeyIndex+1] - XK_KP_Space;
   else if (ShiftStatus & NumLockMask &&
            EdiKeymap[KeyIndex+2] >= XK_KP_Separator &&  // Numlock
	    EdiKeymap[KeyIndex+2] <= XK_KP_9)            // SUN Keypad
      KeyCode = EdiKeymap[KeyIndex+2] - XK_KP_Space;
   else
   {
      if (ShiftStatus & ModeSwitchMask) ShiftIndex = 2; // Alt Gr
      else ShiftIndex = ShiftStatus & 1;      // Normal & Shift
      if (ShiftIndex == 1 && KeyCode >= XK_F1 && KeyCode <= XK_F12) KeyCode += 12;
      else KeyCode = EdiKeymap[KeyIndex + ShiftIndex];
   }
   if (ShiftStatus & 0x02) // Caps Lock
   {
      if (KeyCode >= 'a'  && KeyCode <= 'z' ) KeyCode -= 0x20; // ASCII
      if (KeyCode >= 0xE0 && KeyCode <= 0xFD) KeyCode -= 0x20; // Latin-1
   }
   if (KeyCode == XK_KP_Left      ) KeyCode = XK_Left;
   if (KeyCode == XK_KP_Right     ) KeyCode = XK_Right;
   if (KeyCode == XK_KP_Up        ) KeyCode = XK_Up;
   if (KeyCode == XK_KP_Down      ) KeyCode = XK_Down;
   if (KeyCode == XK_KP_Home      ) KeyCode = XK_Home;
   if (KeyCode == XK_KP_End       ) KeyCode = XK_End  ;
   if (KeyCode == XK_KP_Page_Up   ) KeyCode = XK_Page_Up;
   if (KeyCode == XK_KP_Page_Down ) KeyCode = XK_Page_Down;
   if (KeyCode == XK_KP_Enter     ) KeyCode = XK_Return;
   if (KeyCode == XK_KP_Add       ) KeyCode = '+';
   if (KeyCode == XK_KP_Subtract  ) KeyCode = '-';
   if (KeyCode == XK_KP_Multiply  ) KeyCode = '*';
   if (KeyCode == XK_KP_Divide    ) KeyCode = '/';
   if (Debug)
   {
      if (KeyCode >= ' ' && KeyCode <= 255) printf("'%c' ",KeyCode);
      else                                  printf("--- ");
      printf("Key [%x] State [%2x]\n",WinEvent.xkey.keycode,WinEvent.xkey.state);
      for (ShiftIndex = 0 ; ShiftIndex < EdiSymsPerKey ; ++ShiftIndex)
      {
	 if (EdiKeymap[KeyIndex + ShiftIndex] && XKeysymToString(EdiKeymap[KeyIndex + ShiftIndex]))
         {
            printf("   %d: <%x> '%c' (%s)\n",
	       ShiftIndex,(unsigned int)EdiKeymap[KeyIndex + ShiftIndex],
	                  (int)EdiKeymap[KeyIndex + ShiftIndex],
	       XKeysymToString(EdiKeymap[KeyIndex + ShiftIndex]));
	 }
      }
      printf("\n");
   }
   return KeyCode;
}

void EditUpLine(void)
{
   FinishLine();
   if (CursorSel == NULL || CursorSel->Prev == NULL) return;
   if (CursorSel->Prev->type != SEL_INT && CursorSel->Prev->type != SEL_REAL) return;
   CursorSel = CursorSel->Prev;
   if (CursorCol > CursorSel->edco-1) CursorCol = CursorSel->edco-1;
}

void EditDownLine(void)
{
   FinishLine();
   if (CursorSel == NULL || CursorSel->Next == NULL) return;
   if (CursorSel->Next->type != SEL_INT && CursorSel->Next->type != SEL_REAL) return;
   CursorSel = CursorSel->Next;
   if (CursorCol > CursorSel->edco-1) CursorCol = CursorSel->edco-1;
}

void EditReturnLine(void)
{
   CursorCol = 0;
   EditDownLine();
}

void EditLeftChar(void)
{
   if (CursorCol > 0) --CursorCol;
}

void EditRightChar(void)
{
   if (CursorCol < CursorSel->edco-1) ++CursorCol;
}

void EmitChar(int ch)
{
   if (CursorSel)
   {
      CursorSel->teva[CursorCol] = ch;
      EditRightChar();
   }
} /* EmitChar */


void DeleteRightChar(void)
{
   int i;

   for (i=CursorCol ; i < CursorSel->edco-1 ; ++i)
      CursorSel->teva[i] = CursorSel->teva[i+1];
   CursorSel->teva[CursorSel->edco-1] = ' ';
}


void DeleteLeftChar(void)
{
   if (CursorCol == 0) return;
   EditLeftChar();
   DeleteRightChar();
}


void InsertBlank(void)
{
   int i;

   for (i = CursorSel->edco-1 ; i > CursorCol ; --i)
      CursorSel->teva[i] = CursorSel->teva[i-1];
   CursorSel->teva[CursorCol] = ' ';
}


void ProcChar(int Key)
{
   if (CursorSel)
   switch (Key)
   {
      case XK_Up       : EditUpLine();           break;
      case XK_Left     : EditLeftChar();         break;
      case XK_Right    : EditRightChar();        break;
      case XK_Down     : EditDownLine();         break;
      case XK_Return   : EditReturnLine();       break;
      case XK_BackSpace: DeleteLeftChar();       break;
      case XK_Delete   : DeleteRightChar();      break;
      case XK_Insert   : InsertBlank();          break;
   }
}


void LoopGUI(void)
{
   int w;

   while (1)
   {
      XNextEvent(display,&WinEvent);

      switch (WinEvent.type)
      {
         case ClientMessage: return;
         case MotionNotify : if (OnFrame(0)) ShowOrography();
                             if (Model == PUMA && OnFrame(1)) ShowModeSelector();
                             break;
         case ButtonRelease: Button1Down = 0; if (OnFrame(0)) ShowOrography(); break;
         case ButtonPress  : Button1Down = 1;
                             if (!OnFrame(0) && !OnFrame(1)) OnMouseClick();
         case Expose       : RedrawControlWindow(); break;
         case KeyPress     : EdiKeyCode = EdiDecodeKey();
                             if (EdiKeyCode >= ' ' && EdiKeyCode < 256) EmitChar(EdiKeyCode);
                             else                                       ProcChar(EdiKeyCode);
                             RedrawControlWindow();
                             break;

      }
   }
}

int CheckEndianess(void)
{
   union EndianCheck
   {
      char b[sizeof(int)];
      int  i;
   } ec;

   ec.i = 8; 
   return (ec.b[0] == 0);
}

int main(int argc, char *argv[])
{
   int ia;
   for (ia = 1 ; ia < argc ; ++ia)
   {
           if (!strcmp(argv[ia],"-d")) Debug = 1;
      else if (!strcmp(argv[ia],"-i")) cfg_file[0] = 0;
      else if (!strcmp(argv[ia],"-h")) ScreenHeight = atoi(argv[++ia]);
      else strncpy(cfg_file,argv[1],sizeof(cfg_file));
   }
   CurrentDate = time(NULL);
   BigEndian = CheckEndianess();
   InitGUI();
   LoopGUI();
   return 0;
}