#include <graphics.h>
#include <stdio.h>
#include <stdlib.h>
#include <dos.h>
#include <dir.h>
#include <string.h>
#include <ctype.h>
#include <wnd_asm.h>

#define ALLOC 61   /* буфер для сохраняемых строк*/
//#define STACK 8192 /* размер стека */
//unsigned _stklen=STACK;    // in <dos.h>
MODE Index1=NO; // Индекс помощи в указателе
//extern MENU oprmode; extern CASE tablmode[];
extern int STRtoPAGE,COLtoPAGE;
extern MODE Prn; extern char buttons;
extern FUN  Ext_Function;
extern MODE Line;
extern void Set_Direction(void);
MODE What=0x00;
// xxxx xxx1 - Help File is;
// xxxx xx1x - DBF file initialized
// xxxx x1xx - Information about current program condition is received;
// xxxx 1xxx -
// xxx1 xxxx - 1-Normal; 0-Regul;
// xx1x xxxx - Input of boarders: Yes or No (Sel_Peregon,Vybor,One_Per);
// 11xx xxxx - 00 -Ris 6, 01 - Ris 8, 10 - Ris9

extern unsigned char Thank;
extern void Init_Izmer(void),Win_Reg(void),Read_Reg(void);

void Init_Path(char far *); int Go_Work (void); void IndexHelp (void);
FILE far *Open_File (char far *, FILE far *); void Close_File (FILE far *);
void Open_Config (void); void Save_Config(void); void Restore_Config(void);
char far *Read_From_Config (char far *,int ); void Init_Date (void);
void Mistake (int Err); int strlen__ (char far *str,int *kol);
void About_Program (void); void Prepare_To_Ret (void);
void Amplitude (void),Ris7(void),Ris6(void),Ris8(void),Win_Info(void),
 Tf_Td_count(void),For_Periods(void);
void Write68 (char *,int ,int,long),Write9 (char *,int ,int, long);
int Read_Cfg (char *,char *),Write_Cfg (char *,char *);
void Topics (void); void ChangeToPage (char To);
void Modes (void); void Cursor (int Left,int Up,int Right,int Bottom, int Color);
void Prepare_To_Pause (void); void Pause(void);

///////////////// Глобальные данные:
unsigned long LastFile; unsigned Zapusk;
int NOD,PCH,
 PER; // = 0 - All,= -1 - New, >= 1 - Selected
unsigned char Peregon_[33],NOD_Str[21],PCH_Str[21];
int Per[2];// Начало и конец перегона
//unsigned km[6]; // км/пк/стык - нач. и конец уч-ка
MODE Rails_,Shpala_,Epura_,Radius_;
char far *Rails0[3]={"Р50","Р65","Р75"};
char far *Shpala0[2]={"Деревянные","Железобетонные"};
char far *Epura0[2]={"1840","2000"};
int far Radius0[8]={0,2000,1200,1000,800,600,500,300};

float Sl=25.0;  // Длина рельса -- пока константа !!!
float Tf,Td; // Фактическая и допускаемая температура
float Amp[4]= {30.0,10.0,10.0,10.0}; // Распределение темп.амплитуды
int Tmax=50,Tmin=-50; // Макс.и мин. темп-ра для направления
unsigned Temp_Type=1;
int Norm_Zazor_=1;
float Dop14[2]={2.,8.,},     // Расчетный допуск на 1 и 4 стыка
      A14[2]={1.,4.};        // Назначенный допуск на 1 и 4 стыка
int KN=23; // Макс.зазор==21 || 23
char far WallPattern[8]={ 0x04, 0x04, 0x04, 0xff, 0x20, 0x20, 0x20, 0xff };
////////////////////////////////////////////////////////////////////
void Schet(void),Rail(void),Shpala(void),Epura(void),Radius(void); void SelectSchet(void);

char SOUND=0x01; // Звук
char CONFIG=0x01; // Наличие файла конфигурации
char Mouse=0x00; // Наличие "мыши"
#define CONFIG_NAME "rsz2.cfg"
#define MAX_PATH 128
char far Path[MAX_PATH]; // Путь и имя файла конфигурации
MODE PathLen;
static char far Str[1300]; // Буферная строка
FILE far *Config;
char Day,Mon; int Year;
int DirectPos=0, CatalogPos=0;  /* Позиции в БД направлений и каталога */

#define MAX_POINTS 5  // Макс.число пунктов гор.меню

void main (int argc, char far *argv[]) {
 Init_Path(argv[0]);
 Open_Config();
 Restore_Config();
 Init_System();
 setfillstyle( 1, 15 );
 bar( 0, 0, 639, 11);
 bar( 0, MAXY-12, 639, MAXY);
 Clr_Scr ();
 Init_Date();
 //if (tablmode[2].zam) { // Нужна заставка
  Thank|=0x12; About ();
 //}
 Print( 15, 2, 9, 12, "Рас$ч$ет   $П$омощь   $В$ыход" );
 Clear_Buf();
 //if (tablmode[1].zam) { // Нужна мышь
  Mouse=Init_Mouse ();
  //if (!Mouse) { tablmode[1].zam=tablmode[1].color2=0; tablmode[1].color1=1; }
 //}
// extern void Test_Graph(void); //!!!
// Test_Graph(); //!!!
 Menu_Deis();
}

void Init_System( void ) {
 int GraphDriver = EGA;
 int GraphMode=1,Errorcode;
 registerfarbgidriver( EGAVGA_driver_far );
 initgraph( &GraphDriver, &GraphMode, "" );
 Errorcode=graphresult();
 if (Errorcode != grOk) {
  printf("\nОшибка графики: %s\n->",grapherrormsg(Errorcode));
  getchar(); exit (1);
 }
 Set_Graph_Sim();
 return;
}

void Close_System( void ) {
 closegraph(); printf ("\nНет памяти"); exit (1);
}

void Clr_Scr (void) {
 CURSOR_OFF();
 setfillpattern( WallPattern, 7 ); //8,14
 bar( 0, 12, 639, MAXY - 13 );
 CURSOR_ON();
 return;
}

void Ret_In_Dos( void ) {
 char far *s="Вы действительно желаете закончить работу ?";
 CASE  text_exit = { 134,100,502,150, 0,12,0,"",s };
 if( !Answ_Menu( &text_exit ) ) {
  closegraph ();
  Save_Config(); Close_File(Config);
  exit( 0 );
 }
 return;
}

void About (void) {
 CASE   Text = { 170,115,470,235,14,12,0,"",
  "Программа расчета стыковых зазоров&&"
  "             Версия $2$&&"
  "    $Сибирская  Государственная&"
  "     Академия Путей Сообщения$&&"
  "        Новосибирск, $1996$"
 };

 Message_Text( &Text );
 return;
}
/////////////////////////////////////////////////////////////////////////
void Init_Path(char far *StartName) { // Параметр - строка запуска
 //struct ffblk file;
 char far *Ptr, far *ChDisk=" :";
 int j;
 if (*StartName) { // Path in DOS string
  if (isalpha (StartName[0]) &&  StartName[1]==':') { // Путь с именем диска
   ChDisk[0]=StartName[0];
   j=system (ChDisk); // Меняем диск
   if (j) {
    printf ("\nSystem error! Can't locate drive %c:",StartName[0]);
    exit (1);
   }
  }
  Ptr=_fstrrchr (StartName,'\\'); *(++Ptr)='\0';
  _fstrcpy (Path,StartName);
 }
 else getcwd (Path,MAX_PATH); // Set current directory
 j=_fstrlen (Path);
 if (Path[j-1]!='\\') { _fstrcat (Path,"\\"); j++; }
 PathLen=j;
 return;
}

FILE far *Open_File (char far *Name, FILE *fp) {
 extern dbffile DB; //char Ret=0x01;
 _fstrcat (Path,Name);
 fp=fopen (Path,"r+b");
 if (fp==NULL) {
  // Fun_Bar (Name);
  if (!(DB.Cond & 0x08)) Mistake (2);
  //Ret=0x00;
 }
 Path[PathLen]='\0';
 return (fp);
}

void Close_File (FILE far *fp) {
 fseek (fp,0L,SEEK_END);
 fclose (fp);
 return;
}

int Go_Work (void) {
 // Пытается перейти в рабочий каталог программы.
 // Возвращает не ноль - ошибка.
 int Res;
 if (PathLen>3) Path[PathLen-1]='\0';
 Res=chdir (Path); // Path[PathLen] - рабочая директория
 if (PathLen>3) Path[PathLen-1]='\\';
 if (Res) { Mistake (32); return 1; } // Не найден рабочий каталог
 else return 0;
}

void Open_Config (void) {
 if ((Config=Open_File (CONFIG_NAME,Config))==NULL) CONFIG=0x00;
 else {
  fread (Str,3,1,Config);
  if (_fstrnicmp(Str,"RSZ",3)) CONFIG=0x00;
 }
 return;
}

void Save_Config(void) {
 //MODE i;
 if (CONFIG) {
  fseek (Config, 3L, SEEK_SET);
  fwrite (&Rails_,1,1,Config);
  fwrite (&Shpala_,1,1,Config);
  fwrite (&Epura_,1,1,Config);
  fwrite (&Radius_,1,1,Config);
  fwrite (&DirectPos,2,1,Config);
  fwrite (&CatalogPos,2,1,Config);
  fwrite (&STRtoPAGE,2,1,Config);
  fwrite (&COLtoPAGE,2,1,Config);
  fwrite (&Prn,1,1,Config);
  fwrite (&LastFile,4,1,Config);
  fwrite (&Zapusk,2,1,Config);
  fwrite (&Index1,1,1,Config);
//  for (i=0; i<3; i++) fwrite (&tablmode[i].zam,1,1,Config);
 } return;
}

void Restore_Config(void) {
 //MODE i;
 if (CONFIG) {
  fseek (Config, 3L, SEEK_SET);
  fread (&Rails_,1,1,Config);
  fread (&Shpala_,1,1,Config);
  fread (&Epura_,1,1,Config);
  fread (&Radius_,1,1,Config);
  fread (&DirectPos,2,1,Config);
  fread (&CatalogPos,2,1,Config);
  fread (&STRtoPAGE,2,1,Config);
  fread (&COLtoPAGE,2,1,Config);
  fread (&Prn,1,1,Config);
  fread (&LastFile,4,1,Config);
  fread (&Zapusk,2,1,Config);
  fread (&Index1,1,1,Config);
//  for (i=0; i<3; i++) {
//   fread (&tablmode[i].zam,1,1,Config);
//   tablmode[i].color2=tablmode[i].zam;
//  } SOUND=tablmode[0].zam;
 } return;
}

char far *Read_From_Config (char far *Str,int Num) {
 char far *Ptr=Str;
 unsigned Offset,Len; size_t i;
 if (CONFIG) {
  fseek (Config, 259L, SEEK_SET);
  fseek (Config, (long)(Num<<2), SEEK_CUR);
  fread (&Offset,2,1,Config);
  fread (&Len,2,1,Config);
  if (Offset<659) goto RET_NULL;
  fseek (Config, Offset, SEEK_SET);
  i=fread (Str,Len,1,Config);
  if (i==0) goto RET_NULL;
  Str[Len]='\0';
  return (Ptr);
 }
RET_NULL: return (NULL);
}

#define DATE_X 512
#define DATE_Y 2
void Init_Date (void) {
 char far *Month[12]={
  "января","февраля","марта","апреля","мая","июня",
  "июля","августа","сентября","октября","ноября","декабря"
 };
 asm { mov ah,2ah; int 21h ; mov Day,dl; mov Mon,dh; mov Year,cx; }
 //setfillstyle (1,15); bar (DATE_X1,MAXY-30,DATE_X2,MAXY-18);
 setcolor (0);
 Gprintf (DATE_X,DATE_Y,"%2u %s %4u",Day,Month[Mon-1],Year);
 return;
}

#define HELP_STRLEN 40
#define MISTAKE_Y1 100
  /* Длина строки помощи и верхняя граница окна */
void Mistake (int Err) {
 CASE Program_Text = { 318-4*HELP_STRLEN,MISTAKE_Y1,340+4*HELP_STRLEN,232,14,12,0,"",Str };
 int i,Len=0;
 Bad_Sound ();
 if (CONFIG) {
  if (Read_From_Config (Str,Err)==NULL) {
   goto NO_HELP;
  }
  Len=strlen__ (Str,&i);
  Program_Text.y2=MISTAKE_Y1+30+i*10;
 }
 else {
NO_HELP:
  strcpy (Str,"Ошибка номер $     ");
  itoa ( Err,&Str[14],10);
  strcat (Str,"$&&Не могу сообщить более подробную инфор-&"
	      "мацию из-за отсутствия файла конфигура-&"
	      "ции $rsz2.cfg$");
 }
 Message_Text( &Program_Text );
 return;
}

int strlen__ (char far *str,int *kol) {
 // Длина строки без символов '&','$' (перевод строки и смена цвета)
 // Возвращает длину максиммальной подстроки и
 // количество подстрок через параметр *kol
 char far *ptr=str;
 int mcol=0,i=0;
 (*kol)=1;
 for (;*ptr!='\0'; ptr++) {
  if (*ptr=='&') {
   if (i>mcol) mcol=i; i=0; (*kol)++;
  }
  else if (*ptr!='$') i++;
 }
 if (i==0) (*kol)--;
 if (i>mcol) mcol=i;
 return (mcol);
}

/////////////////////////////////////////////////////////////////////////
/*
void Schet (void) {
 static MODE i=0;
 MENU  opr = { 15, 11, 112, 66, 3, "pPзЗyYнНgGпПdDвВ" };
 CASE  tabl[4] = {
  {14, 29,308,91, 0,12,1, "$З$апуск",
  "  Пункт $З$апуск запускает программу&"
  "расчета стыковых зазоров." , SelectSchet},
  {14, 40,308,102, 0,12,0, "$Н$астройки",
  "  Управляет окружением программы -&"
  "звук, 'мышь' и т. п." , Modes},
  {14, 51,308,113, 0,12,0, "$П$ауза",
  "  Пункт включает хранитель экрана.&"
  "Для выхода - любая клавиша." , Prepare_To_Pause},
  {14,62, 308,124, 0, 12, 0, "$В$ыход",
  "  Пункт $В$ыход - завершение работы&"
  "и возврат в $DOS$" , Prepare_To_Ret}
 };
 Menu_Wnd ( &opr, tabl, i );
 return;
}

void Prepare_To_Ret (void) {
 Ext_Function=Ret_In_Dos;
 Set_Key (2,ESC,START);
 return;
}


void Modes (void) {
 Case_Wnd( &oprmode, tablmode );
 if (tablmode[1].zam) {
  if (!Mouse) { // Включить мышь
   if (Init_Mouse()) Mouse=0x01;
  }
 }
 else { CURSOR_OFF(); Mouse=0x00; }
 SOUND=tablmode[0].zam;
 Set_Key (1,ESC);
 return;
}

////////////////////////////////////////////////////////
// Часть для вывода хранителя экрана
////////////////////////////////////////////////////////
void Prepare_To_Pause (void) {
 Ext_Function=Pause;
 Set_Key (2,ESC,START);
 return;
}

#define STARS 12
struct Star{ int x,y; char delta,spr; };
#define SPEED 20
// Speed=63 is max;  Delta is:
// 1xxx xxxx - X-speed sign
// x1xx xxxx - Y-speed sign
// xxXX XXXX - XY-speed
void Init_Star (struct Star *); int In_Bar (int ,int ,int *);

void Pause(void) {
 int x,y,istar,k; char delta,cc,sprite;
 char *sprites[4]={"·","∙","\004","\003"};
 int zones[3][4]; struct Star star[STARS];
 ChangeToPage (0x01); CURSOR_OFF();
 for (istar=0; istar<3; istar++) {
  zones[istar][0]=(3-istar)*639/8; zones[istar][2]=(istar+5)*639/8; //X-borders
  zones[istar][1]=(3-istar)*349/8; zones[istar][3]=(istar+5)*349/8; //Y-borders
 }
 for (istar=0; istar<STARS; istar++) Init_Star (&star[istar]);
 istar=0;
 while (!Hit_Key()) {
  if (AnyClick()) break;
  setcolor (0);  x=star[istar].x; y=star[istar].y;
  outtextxy (x,y,sprites[star[istar].spr]);
  sprite=3;
  for (k=0; k<3; k++) if (In_Bar(x,y,zones[k])) { sprite=k; break; }
  cc=star[istar].delta; delta=cc&0x3f;
  if (cc&0x80) x+=delta; else x-=delta;
  if (cc&0x40) y+=(SPEED-delta); else y-=(SPEED-delta);
  if (x<8 || x>631 || y<8 || y>341) Init_Star (&star[istar]);
  else {
   if (sprite<3) setcolor (YELLOW); else setcolor (LIGHTRED);
   outtextxy (x,y,sprites[sprite]);
   star[istar].x=x; star[istar].y=y;
  }
  if (sprite!=star[istar].spr) star[istar].spr=sprite;
  istar++; delay(10);
  if (istar==STARS) istar=0;
 } Clear_Buf(); CURSOR_ON(); ChangeToPage (0x00);  return;
}

void Init_Star (struct Star *star) {
 char dd;
 star->x=getmaxx()/2; star->y=getmaxy()/2; star->spr=0x00;
 dd=random (SPEED);
 if (random(2)) dd|=0x80; // X-positive
 if (random(2)) dd|=0x40; // Y-positive
 star->delta=dd; return;
}

int In_Bar (int x,int y,int *xy) {
 if (x>xy[0] && x<xy[2] && y>xy[1] && y<xy[3]) return 1;
 return 0; }
*/
//////////////////////////////////////////////////////////////////

/*
void SelectSchet (void) {
 Ext_Function=Set_Direction;
 Set_Key (2,ESC,START);
 return;
}
*/
/*
void IndexHelp (void) {
 static MODE i=1;
 MENU  opr = { 87, 11, 200, 44, 1, "eEуУjJоО" };
 static char *Help1=
  "  Пункт $У$казатель выдает контекстно&"
  "независимые подсказки.&"
  "  Пункт $О$ программе - окно автор-&"
  "ских прав.";
 CASE  tabl[2] = {
  {94, 29,396,111, 0,12,0, "$У$казатель...", Help1, Topics},
  {94,40,396,122, 0, 12, 1, "$О$ программе", Help1, About_Program}
 };
 Menu_Wnd ( &opr, tabl, i );
 return;
}

void About_Program (void) {
 Ext_Function=About;
 Set_Key (2,ESC,START);
 return;
}


void Topics (void) {
 Good_Sound();
 Ext_Function=Help;
 Set_Key (2,ESC,START);
 return;
}
*/
#define LCOL WHITE
#define LBAK BLACK
#define CURS WHITE
#define LTOP 10
#define TTOP 22
#define T3 25
#define L3 245
#define B3 325
#define R3 615
#define START_HELP 50
 // Номер записи, с которой начинаются строки помощи в файле rsz2.cfg
void Help (void) {
 char far  *Top= "Общие сведения&&Управление&&Расчеты&&Работа с окном БД&&"
            "Работа с файлом направлений&&"
           "Работа с файлом участков&&Работа с файлами измерений&&"
	   "Вывод результатов&&Печать&&Помощь и настройки&&";
 CASE   Program_Text = { 158,100,500,232,14,12,0,"",
   "НЕ МОГУ ОТКРЫТЬ ФАЙЛ ПОМОЩИ&$rsz2.cfg$ для вывода&информации!",Nop };
 char far *Bar="$ESC$ Выход  $ENTER$ Выбрать подсказку  $DOWN$ Вниз  $UP$ Вверх";
 KEY Bar_Keys[4]={ESC,ENTER,DOWN,UP};
 int Pos_Keys[5]={15,103,303,391,463};
 char Num_Keys=4;
 static int i,Len=0,Kol=0,y2,y=Index1,jj;
 KEY Key;

 if (Go_Work()) return;
NO_HELP:
 if (!CONFIG) {
  Message_Text (&Program_Text); return;
 }
 ChangeToPage (0x01);
 CURSOR_OFF();
 setfillstyle( SOLID_FILL,LBAK);
 bar( 0, 12, 639, MAXY - 13 );
 setcolor (LCOL); rectangle( 0, 12, 639, MAXY - 13 );
 rectangle (L3-10,T3-5,R3+10,B3+5); rectangle (L3-8,T3-3,R3+8,B3+3);
 Len=strlen__(Top,&Kol); y2=LTOP+8*Len; Kol/=2; //!!!
 CURSOR_ON();
 Print (LTOP,TTOP,LIGHTGREEN,LIGHTRED,Top);
 Fun_Bar (Bar);

 for (;;) {
  Cursor (LTOP-2,TTOP+20*y-2,y2+2,TTOP+20*(y+1)-8,CURS); //On
  if (Mouse) while (!Hit_Key()) {
   ms_state();
   if (buttons==0x01) {
    if (Fun_Bar_Keys (Num_Keys,Bar_Keys,Pos_Keys)) goto KEYBOARD;
    if (Mouse_In_Field (LTOP,TTOP,y2-8,12,1,Kol,0,8,LIGHTGREEN,&i,&jj)) {
     if (y==jj) { Set_Key (1,ENTER); goto KEYBOARD; }
     else {
      Cursor (LTOP-2,TTOP+20*y-2,y2+2,TTOP+20*(y+1)-8,LBAK); //Off
      y=jj;
      Cursor (LTOP-2,TTOP+20*y-2,y2+2,TTOP+20*(y+1)-8,CURS);//On
      continue;
     }
    }
   }
  }
KEYBOARD:
  Key=Get_Key();
  Cursor (LTOP-2,TTOP+20*y-2,y2+2,TTOP+20*(y+1)-8,LBAK); //Off
  switch (Key) {
   case ESC:
    //CURSOR_OFF(); setcolor (LBAK); rectangle (L3-10,T3-5,R3+10,B3+5);
    //rectangle (L3-8,T3-3,R3+8,B3+3); CURSOR_ON();
    Index1=y;
    ChangeToPage (0x00);
   return;
   case ENTER:
    CURSOR_OFF();
    setfillstyle( SOLID_FILL,LBAK);
    bar (L3,T3,R3,B3);
    CURSOR_ON();
    if (Read_From_Config (Str,START_HELP+y)!=NULL) {
     Print (L3,T3+10,LIGHTCYAN,LIGHTRED,Str);
    }
    else Print (L3,T3+10,LIGHTCYAN,LIGHTRED,"&&&В файле помощи $нет$ информации по этому пункту");
   break;
   case DOWN: if (y<Kol-1) y++; else y=0; break;
   case UP: if (y>0) y--; else y=Kol-1; break;
   case PAGE_UP: y=0; break;
   case PAGE_DO: y=Kol-1; break;
  }
 }
}

void Cursor (int Left,int Up,int Right,int Bottom, int Color) {
 CURSOR_OFF();   setcolor (Color);
 rectangle (Left,Up,Right,Bottom);
 CURSOR_ON(); return;
}

void ChangeToPage (char To) {
 if (To) { // С главной на вспомогательную видеостраницу
  CURSOR_OFF(); setvisualpage (1); setactivepage (1); cleardevice();
  CURSOR_ON();
 }
 else { // Обратно
  CURSOR_OFF(); setvisualpage (0); setactivepage (0); CURSOR_ON();
 } return;
}

//////////////////////////////////////////////////////////////////////
void Start689 (void);
void VDTAL (float &),
     VDTP (float &),
     VTEMP (float &,float &,float &),
     VDTC (float &),FF1(void);

static float Tla[24],Tloz[24],Tlvl[24],Tlam[24]; // dimension 24
static float  DTal, DTp,DTc,DTpl,DTmn,DTd, SGZV,F,E; //,DE;
float SGP,SGM;
float DN1=0.,DN2=0.;
static float AL,PRO;
static char far Str0[21], far Str1[12],far Str2[12],far Str3[12],far Str4[16],
	    far Str5[16],far Str6[12],far Str7[12],far Str8[12];

void Tf_Td_count(void) {
 //...Р А С Ч Е Т  1:
 FF1();
 VDTAL(DTal);
 VDTP(DTp);
 VTEMP(DTpl,DTmn,DTd);
 VDTC(DTc);
 Td=DTal+DTp+DTc-DTpl-DTmn-2*DTd;
 Tf=Tmax-Tmin;
 if(Rails_==0x00){KN=21;}
 else{KN=23;}
 ////////////////////
 if (Tf<=Td) Ext_Function=Amplitude;
 else Ext_Function=For_Periods;
 Set_Key (1,START);
 What&=0x3f; // For Ris. 6,8,9
 return;
}

void Amplitude (void) { // Tf<=Td
 extern CASE *Answer;
 CASE Dop_Temp={  158,100,478,270, 0,12,0,"",
  " Уменьшение растягивающих сил в стыках&"
  "зимой уменьшит вероятность их разрыва,&"
  "а уменьшение сжимающих сил летом - ве-&"
  "роятность выброса пути. Увеличение до-&"
  "пуска на содержание  стыковых зазоров&"
  "уменьшит объем работ по их регулировке&"
  "   При отказе  от распределения запаса&" 
  "амплитуды зазоры будут рассчитаны из&"
  "условия передачи на рельсовые стыки зи&"
  "мой максимальных растягивающих сил. То&"
  "есть, весь запас амплитуды будет реали&"
  "зован на уменьшение  сжимающих сил в&" 
  "рельсах летом.&",Nop };
 MODE k;
 HELP wnd = { 32, 80, 608, 270,"", 
 "Фактическая годовая амплитуда температуры рельсов $меньше$ допускаемой&"
 "                    (Тфакт.        <=Тдоп.        )&"
 "Допуск на содержание&"
 "4-х стыков (\xFB )8 мм. (для деревянных шпал)&"
 "1-го стыка (\xFB )2 мм. (для железобетонных шпал)&"
 "У Вас имеется запас температурной амплитуды,который Вы можете&"
 "использовать на:&"
 " уменьшение растягивающих сил в стыках зимой(\x1Et1);&"
 " уменьшение сжимающих сил в рельсах летом(\x1Et2);&"
 " увеличение допуска на содержание стыковых зазоров(\x1Et3).&"
 "При этом необходимо,чтобы&"
 " \x1Et1+\x1Et2+\x1Et3 = Тдоп.- Тфакт.&"
 };
 CASE text = { 136, 215, 500, 265, 0,12,0,"", 
 "Распределить запас температурной амплитуды?"};

 What&=0xFD; // DBF-структура свободна

 bar (32, 80, 608, 270);
 Help_Text (&wnd); 
 Gprintf (282,104,"%-4.1f         %-4.1f",Tf,Td);
 //...Р А С Ч Е Т  2:
 Amp[0]=Td-Tf;
 //////////////////////
 Dop14[0]=2.; Dop14[1]=8.;
 Answer=&Dop_Temp; Thank|=0x20;
 k=Answ_Menu (&text);
 if (Thank&0x08) { // не нажата ESC
  if( !k ) Ext_Function=Ris7; // ДА - Меню распределения запаса
                              // температурной амплитуды 
  else Ext_Function=Ris6;     // НЕТ - Меню с таблицей нормальных зазоров
  Set_Key (1,START);
 }
 else Clr_Scr(); return;
}

extern void Win_Temp(char);

void For_Periods (void) { // Tf<=Td
 int i;
 //...Р А С Ч Е Т  6:
 AL=11.8;
 Sl=fabs_(Sl);
 i=0;
 PRO=Tmin+DTp+DTal-DTpl-DTd;
 while(i<KN+1){
  Tloz[i]=PRO-i/(AL*Sl);i++;
 }
 PRO=Tmax-DTc+DTmn+DTd;
 i=0;
 while(i<KN+1) {
  Tlvl[i]=PRO-i/(AL*Sl);i++;
 }
 // PECH9(KN+1);
 ////////////////////
 Dop14[0]=2.; Dop14[1]=8.;
 What|=0x80; What&=0xbf; // 10xxxxxx
 Win_Info(); //y=145
// Thank|=0x10;
 Win_Temp(0x09); return;
}

/////////////////////////////////////////////////////////////////
//void Ris7_dop(void);
//float dA; MODE Corr;
 static KEY Alt_07[] = { ALT_N, ALT_C, ALT_J, 0 };
 static KEY Alt_7[] = { ALT_N, ALT_P, ALT_K, ALT_L, ALT_C, ALT_J, 0 };
 static char s7[4][11]; 
 static char *h7=
  "По умолчанию предлагается одинаковое&"
  "распределение запаса температур на&" 
  "уменьшение растягивающих сил (\x1Et1),&"
  "сжимающих сил (\x1Et2), и на увеличение&" 
  "допуска (\x1Et3)"; 
 VIDI   opr07 = { 100, 15, 500, 100, 0x01,"",Alt_07 };
 VIDI   opr7 = { 100, 80, 500, 290, 0x03,"",Alt_7 };
 CASEI  tabl07[] = {
  { 15,-5,385,50, 10, 8,0,
    "Общий запас $т$емпературной амплитуды:",
    300,20,70,s7[0], h7, Nop }
 };
 CASEI  tabl7[] = {
  { 15,-5,385,55, 10, 8,0,
    "Запас температурной амплитуды,реализуемый на&"
    "уменьшение растягивающих сил $з$имой (не более)",
    300,20,90,s7[1], h7, Nop},// Ris7_dop },

   { 15,55,385,115, 10, 8,0,
    "Запас температурной амплитуды,реализуемый на&"
    "уменьшение сжимающих сил $л$етом (не более)",
    300,20,90,s7[2], h7, Nop},// Ris7_dop },

  { 15,115,385,180, 10, 8,0,
    "Запас температурной амплитуды,реализуемый на&"
    "увеличение $д$опуска на содержание стыковых&"
    "зазоров (не более)",
    300,20,90,s7[3], h7, Nop},// Ris7_dop }
 };

void Ris7(void) {
 extern void RightMargin (char far *String);
 int i;
INPUT:
 //...Р А С Ч Е Т  4:
 int J1,N;
 Amp[3]=Amp[2]=Amp[1]=(int)(Amp[0]/3.);
 PRO=Amp[1]*3;
 if(PRO==Amp[0]){}
 else{
  J1=Amp[0]-PRO;
  if(J1==1){ (Amp[3])+=1.; }
  else{ (Amp[3])+=1.;(Amp[2])+=1.; }
 }
 // PECH7();
 ////////////////////
// Corr=0x00;
 for (i=0;i<4;i++) {
  sprintf (s7[i],"%-8.1f",Amp[i]); // gcvt(Amp[i],8,s7[i]);
  RightMargin (s7[i]);
 }
 Thank|=0x11; // Запрещаем ввод и сохранение окна
 Set_Key (1,ALT_C);
 Get_Many_Text (&opr07,tabl07);
 bar (opr07.x1,opr07.y2-1,opr07.x2,opr07.y2);
// Thank|=0x12; // Запрещаем сохранение окна и включаем автовыполнение
 Thank|=0x10;
 Get_Many_Text (&opr7,tabl7);
 if ((Thank&0x0C)!=0x0C) {
  Ext_Function=Amplitude;
 }
 else { // Спасибо и ENTER
  for (i=1;i<4;i++) Amp[i]=atof (s7[i]);
  if (fabs_(Amp[0]-(Amp[1]+Amp[2]+Amp[3])) > 0.01) {
   Mistake(21);   goto INPUT;   }
  //...Р А С Ч Е Т  5:
  if(Shpala_==0x00){ N=4; }
  else{ N=1; }
  Sl=fabs_(Sl);
  SGZV=11.8*Sl*Amp[3]*N/2;
  if(Shpala_==0x00){SGP=8;SGM=-8;}
  else{SGP=1;SGM=-1;}
  SGP=SGP+SGZV;
  SGM=SGM+SGZV;
  PRO=Tmin+(DTp-Amp[1])+DTal-(DTpl+0.5*Amp[3])-DTd;
  i=0;AL=11.8;
  Sl=fabs_(Sl);
  while(i<KN+1){ Tla[i]=PRO-i/(AL*Sl);i++;}
  E=0.21;AL=1.18;
  DN1=AL*F*E*Amp[1];
  DN2=AL*F*E*Amp[2];
  // PECH8(KN+1,SGP,SGM,DN1,DN2);
  // KN1 - 21 || 23, SGP= +допуск на 1 зазор SGM= -допуск
  // DN1 , DN2 уменьшение...на...кН...растяг.сил
  ////////////////////
  Dop14[0]=3.; Dop14[1]=12.;
  Ext_Function=Ris8;
 }
 Clr_Scr();Set_Key (1,START); return;
}

float fabs_(float f) { return (f>0.0?f:-f); }
// double !!!

/////////////////////////////////////////////////////////////
extern char far *Segment;
extern int StartKm, StartPk, StartSt, EndKm, EndPk, EndSt;

void Win_Info(void) {
 static KEY Alt_[] = { ALT_E, ALT_Y, ALT_R, ALT_V,
		ALT_B, ALT_T, ALT_I, ALT_H, ALT_L,
		ALT_P, ALT_K, 0 };
 static char *StrHelp=NULL;
 unsigned char Byte[2];int k;
 VIDI   opr = { 40, 15, 610, 225, 0x0B,"",Alt_ };
 CASEI  tabl[] = {
  { 10,-10,220,35, 23, 23,0, "Название участка",
    300,20,70, Str0, StrHelp, Nop },

  { 230,-10,380,35, 12, 10,0,"Участок: (начало)",
    300,20,70,Str2, StrHelp, Nop },

  { 400,-10,550,35, 12, 10,0,"(конец) км/пк/cтык",
    215,20,70, Str3, StrHelp, Nop },

  { 10, 30, 110, 75, 9, 7, 0, "Мин. темп.",
    300,20,70, Str1, StrHelp, Nop },

  { 120,30,220,75, 9, 7, 0, "Макс. темп.",
    300,20,70, Str4, StrHelp, Nop },

  { 230, 30, 330, 75, 13, 9, 0,"Рельсы",
    300,20,70,Rails0[Rails_], StrHelp, Nop },

  { 340, 30, 440, 75, 13, 9, 0,"Шпалы",
    220,20,70, Shpala0[Shpala_], StrHelp, Nop },

  { 450,30, 550, 75, 13, 9, 0,"Радиус",
     130,20,70, Str5, StrHelp, Nop },

  { 10, 70, 200, 115, 9, 7, 0,"Допуск на содержание 4 стыков ",
    300,20,70, "\xFB 8  мм", StrHelp, Nop },

  { 10,110, 140,165,  9, 7, 0,
  "\x1Et1 Уменьшение максимальных&растягивающих сил зимой&"
  "              на      кН",
    300,20,70, Str6, StrHelp, Nop },

  { 290,110,420,165,  9, 7, 0,
  "\x1Et2 Уменьшение максимальных&растягивающих сил летом&"
  "              на      кН",
    300,20,70, Str7, StrHelp, Nop }
 };
 char *f="%4d/%2d/%2d";
 _fstrncpy (Str0,Segment,_fstrlen(Segment));
 sprintf(Str2,f,StartKm, StartPk, StartSt);
 sprintf(Str3,f,EndKm, EndPk, EndSt);
 itoa (Radius0[Radius_],Str5,10);
 sprintf (Str1,"%-d",Tmin); sprintf (Str4,"%-d",Tmax);
 for (k=0;k<2;k++) Byte[k]=Shpala0[Shpala_][5+k];
 Shpala0[Shpala_][5]='.'; Shpala0[Shpala_][6]='\0';
 sprintf (Str6,"%-5.1f",SGP);
 sprintf (Str7,"%-5.1f",SGM);
 if (!(What&0x80)) { // Not Ris 9
  if (Shpala_) { //ж./б.
   strcpy (&(tabl[8].Data[2]),(What&0x40?"3 ":"2 "));
   strcpy (&(tabl[8].name[21]),"1 стыка ");
  }
  else {        //дер.
   strcpy (&(tabl[8].Data[2]),(What&0x40?"12":"8 ")); //Ris 6,8
   strcpy (&(tabl[8].name[21]),"4 стыков");
  }
 }
 else { //!!!
  strcpy (&(tabl[8].Data[2]),"8 ");
  strcpy (&(tabl[8].name[21]),"4 стыков");
 }
 tabl[8].Data[4]=' ';
 Thank|=0x11; // Запрещаем ввод и сохранение окна
 Set_Key (1,ALT_C);
 Get_Many_Text (&opr,tabl);
 for (k=0;k<2;k++) Shpala0[Shpala_][5+k]=Byte[k];
 return;
}

void Ris6(void) {
 //...Р А С Ч Е Т  3:
 int i;
 Sl=fabs_(Sl);
 AL=11.8;i=0;
 PRO=Tmin+DTp+DTal-DTpl-DTd;
 while(i<KN+1){
  Tlam[i]=PRO-i/(AL*Sl);i++;
 }
 //   PECH6();
 ////////////////////
 What&=0x3f; // 00xxxxxx
 Win_Info();
 Win_Temp(0x06); return;
}

void Ris8(void) {
 What|=0x40; What&=0xef; // 01xxxxxx
 Win_Info(); setcolor (BLACK);
 Gprintf (186,175,"%4.0f",DN1);
 Gprintf (466,175,"%4.0f",DN2);
 Win_Temp(0x08); return;
}

void Write68(char *Str,int Len,int Fil,long Num) {
 float Val; int iii; // MODE Byte;
 for (iii=0; iii<Len; iii++) *(Str+iii)=' ';
 if (!(Rails_==0x00 && Num>KN)) {
  if (Fil==0) {
   iii=Num;
   sprintf (Str8,"%-4d",iii);
  }
  else {
   if (What&0x40)  //Ris 8
    Val=Tla[Num];
   else Val=Tlam[Num];
   sprintf (Str8,"%-6.1f",Val); //  gcvt (Val,Len,Str8);
  }
  iii=min(Len,strlen(Str8));
  strncpy (Str,Str8,iii);
 }
 return;
}

void Write9 (char *Str,int Len,int Fil,long Num) {
 float Val; int iii; // MODE Byte;
 for (iii=0;iii<Len;iii++) *(Str+iii)=' ';
 if (!(Rails_==0x00 && Num>KN)) {
  if (Fil==0) {
   iii=Num;
   sprintf (Str8,"%-4d",iii);
  }
  else {
   if (Fil==1) Val=Tloz[Num];
   else Val=Tlvl[Num];
   sprintf (Str8,"%-6.1f",Val); //  gcvt (Val,Len,Str8);
  }
  iii=min(Len,strlen(Str8));
  strncpy (Str,Str8,iii);
 } return;
}

/////////////////////////////////////////////////////////////////
//////////// Ф У Н К Ц И И  Д Л Я  Р А С Ч Е Т А
//////////// нормальных зазоров
//*************************************
void VDTC(float &DTc){
 MODE i;
 float DTc_[4][8]= {                 // Shpala_   Rails_
  {46.,42.,42.,43.,41.,37.,35.,26.}, //    0          0
  {42.,38.,38.,39.,37.,34.,42.,23.}, //    0          1,2
  {52.,48.,48.,49.,47.,42.,40.,30.}, //    1          0
  {48.,43.,43.,44.,42.,39.,35.,26.}  //    1          1,2
 };
 if (Shpala_>0x01 || Rails_>0x02 || Radius_>0x07) Mistake (23);
 else {
  i= (Rails_==0x00 ? 0x00 : 0x01);
  i+=(Shpala_<<1);
  DTc = DTc_ [i] [Radius_];
 }
 return;
}

//***************************************************************
void VDTAL(float &DTal){
 if(Rails_==0x00){ DTal=71.; }
 else {
  if ((Rails_==0x01)||(Rails_==0x02)) DTal=78.;
  else Mistake(24);
 } return;
}

//***************************************************************
void VDTP(float &DTp) {
 if(Rails_==0x00) DTp=22.;
 else {
  if(Rails_==0x01) DTp=17.;
  else {
   if(Rails_==0x02) DTp=15.;
   else Mistake(24);
  }
 } return;
}

//***************************************************************
void VTEMP (float &DTpl,float &DTmn,float &DTd) {
 DTpl=7.;DTmn=7.;DTd=1.; return;
}

void FF1(){
 switch(Rails_){
  case 0x00:  F=66.; break;
  case 0x01:  F=83.; break;
  case 0x02:  F=95.; break;
 } return;
}

void cmes(void) {
 HELP wtmes={100,110,550,140,"",
  "Подождите пожалуйста...Идет $расчет$" };
 Help_Text (&wtmes);
 return;
}

//////////////////////////////////////////////////////////////////
/// Расчет регулировки зазоров
//////////////////////////////////////////////////////////////////

//extern void Start0123 (void);
// Функции для расчета: (см. соотв.файлы)
extern int //main_nnnn1(void), main_nnnn2(void),
 main_nn2(void), main_nnn21(void);
// Функции для записи в БД:
// пишут в строку Str Len байт для записи с номером Num
//extern void Write0 (char *,int ,int, long),Write1(char *,int ,int, long),
//       Write2 (char *,int ,int, long),Write3 (char *,int ,int, long);

//void Ved1(void),Ved2(void),cmes(void),Ved2_Dop(void);
//void Reg_Info(void);
/*
*/
/*
 static KEY Alt_08[] = { ALT_Y, ALT_L, ALT_C, ALT_J, 0 };
 static char s8[4][8],*sh8=
   "Предполагается, что назначенный до-&"
   "пуск на 4 стыка равен $4$ допуска на&"
   "1 стык, это соотношение  автомати-&"
   "чески устанавливается при нажатии&"
   "$ENTER$ в любом из полей ввода. Если&"
   "Вы не нажимали ENTER и соотношение&"
   "1 к 4 не соблюдено, Вам будет пред-&"
   "ложено повторить ввод.&"
   "По окончании перейдите на $Спасибо$";
 VIDI   opr08 = { 140, 15, 510, 90, 0x02,"", Alt_08 };
 CASEI  tabl08[] = {
  { 10,-10,180,45,9,7,0,"   Расчетный допуск на&   $1$ стыка",
    300,20,70,s8[0], sh8, Nop },
  { 186,-10,356,45,9,7,0,"  содержание&   $4$ стыков",
    300,20,70,s8[1], sh8, Nop }
 };
 VIDI   opr8 = { 140, 70, 510, 145, 0x02,"", Alt_08 };
 CASEI  tabl8[] = {
  { 10,-10,180,45,9,7,0," Назначенный допуск на&   $1$ стыка",
    300,20,135,s8[2], sh8, Ved2_Dop },
  { 186,-10, 356,45,9,7,0," содержание&    $4$  стыков",
    300,20,135,s8[3], sh8, Ved2_Dop }
 }; MODE Cont=0x00;

void Ved2(void) {
 float f,f4; int i;
if (!Line) {
 Thank|=0x11; // Запрещаем ввод и сохранение окна
 Set_Key (1,ALT_C);
 for (i=0;i<2;i++) {
  sprintf (s8[i],"%-5.1f",Dop14[i]); sprintf (s8[2+i],"%-5.1f",A14[i]);
  // gcvt (Dop14[i],4,s8[i]); gcvt (A14[i],4,s8[2+i]);
 }
 Get_Many_Text (&opr08,tabl08);
INPUT_VED2:
 bar (opr08.x1,opr08.y2-1,opr08.x2,opr08.y2);
 Thank|=0x10; // Запрещаем сохранение окна
 Clear_Buf_My(); Cont&=0xfe;
 Get_Many_Text (&opr8,tabl8);
 if (Cont&0x01) goto INPUT_VED2; // Был нажат ENTER в одном из полей
 if ((Thank&0x0C)!=0x0C) { Clr_Scr(); return; }
 // Спасибо и ENTER
 f=atof (s8[2]); f4=atof(s8[3])-4.*f; if (f4<0.) f4=-f4;
 if ( (atof(s8[0])<f) || f<=0. || f4>0.1 ) {
  Mistake (28); goto INPUT_VED2; }
 A14[0]=f; f=atof(s8[3]); A14[1]=f;
}
 Clr_Scr();
// Read_Reg();
 if (RegType==255) return;
 cmes();
 i=main_nnnn2();
 if (i) { Mistake(30); return; }
 Reg_Info();
// Win_Reg();
 if (Line==0x00) {  Line=0x01; Ext_Function=Vedomost; Set_Key (1,START); }
 else Line=0x00;
 return;
}

void Ved2_Dop(void) {
 float f; int i1;
 if (tabl8[0].zam) i1=2;
 else i1=3;
 f=atof (s8[i1]); Cont|=0x01;
 if (! ( atof(s8[i1-2])>=f  && f>0. ) ) {
  Thank&=0xef; Mistake (28); Thank|=0x10; }
 else {
  Set_Key (2,ESC,DOWN);
  if (i1==2) { f*=4; i1=3; Set_Key (1,DOWN); }
  else { f/=4; i1=2; }
  sprintf (s8[i1],"%-5.1f",f);
  Set_Key (1,ENTER);
 }
 return;
}
*/

/*

*/
//////////////////////////////////////////////////
// Инициализация печати
//int HowManyPrint;
/*
void Start0123 (void) { // See Reg_Info
 extern FILE *printer;
 static char *vhdr[] = {                    //  vstr vptr
 "Перегон",                                 //   //  [0]
 "Начало участка(км/пк/стык)",              //   [0]
 "Конец участка (км/пк/стык)",              //   [1]
 "Расчетный допуск на содержание 1 стыка", //   [2]
 "Расчетный допуск на содержание 4 стыков", //  [3]
 "Назначенный допуск на содержание 1 стыка",//  [4]
 "Назначенный допуск на содержание 4 стыков", //  [5]
 "Нормальный зазор,мм."                      //  [6]
 };
 static char vPer[8]={0x00,0x10,0x10,0x11,0x11,0x11,0x11,0x10};
 // xxx1 xxxx  - Есть/нет ссылка на массив строк vstr
 // xxxx xxx1  - Есть/нет перевод строки для печати значения
 static char vstr[7][11];
 static char *Lines[2]={"Левая нить","Правая нить"};
 char *vptr;  char *f="%-4d/%-2d/%-2d";
 int vi=0,i;

 vptr=&(Peregon_[0]);
 sprintf(vstr[0],f,km[0],km[1],km[2]);
 sprintf(vstr[1],f,km[3],km[4],km[5]);
 for (i=0;i<2;i++){
  sprintf (vstr[2+i],"%-6.1f",Dop14[i]); sprintf (vstr[4+i],"%-6.1f",A14[i]);
  //gcvt (Dop14[i],6,vstr[2+i]); gcvt (A14[i],6,vstr[4+i]);
 }
 itoa (Norm_Zazor_,vstr[6],10);

 if (RegType/2) { fprintf (printer,
  "\nВедомость регулировки (разгонки) зазоров\n"
  "для приведения их к нормальным\n"); HowManyPrint+=3; }
 else { fprintf (printer,
  "\nВедомость регулировки зазоров по условию\n"
  "превышения допуска на содержание 4 стыков\n"
  "с приведением их к нормальным\n");  HowManyPrint+=4; }
 if ((RegType+0x02)/2) { fprintf (printer,"с учетом допуска\n"); // 0x01,0x03
   HowManyPrint++; }
 fprintf (printer," --- %15s\n",Lines[Line]);
 fprintf (printer,"\n");  HowManyPrint+=2;
 for (i=0; i<8; i++) {
  fflush (printer);
  if ( (RegType==0x00||RegType==0x02) && (i==5 || i==6) ||
       (RegType==0x03 && i==7) ) continue;
  fprintf (printer,"%s",vhdr[i]);
  if ( (vPer[i])&0x01) { fprintf (printer,"\n     ");  HowManyPrint++; }
  else fprintf (printer,"  ");
  if ((vPer[i])&0x10) { fprintf (printer,"%s",vstr[vi]); vi++; }
  else { fprintf (printer,"%s",vptr); }
  if (i>2 && i<7) fprintf (printer," мм. ");
  fprintf (printer,"\n");  HowManyPrint++;
 } return;
}

void Start689 (void) {  // See Win_Info
 extern FILE *printer;

 static char *phdr[] = {                    // pstr  pptr
 "Перегон",                                 //   //  [0]
 "Начало участка(км/пк/стык)",              //   [0]
 "Конец участка(км/пк/стык) ",              //   [1]
 "Макс.температура",                        //   [2]
 "Мин.температура ",                        //   [3]
 "Тип рельсов",                             //   //  [1]
 "Тип шпал   ",                             //   //  [2]
 "Радиус     ",                             //   [4]
 "Допуск на содержание 4 стыков",           //   [5]
 "Уменьшение макс.растягивающих сил зимой", //   [6]
 "Уменьшение макс.растягивающих сил летом"  //   [7]
 };
 static char Per[11]={0x00,0x10,0x10,0x10,0x10,0x00,0x00,0x10,0x10,0x11,0x11};
 // xxx1 xxxx  - Есть/нет ссылка на массив строк pstr
 // xxxx xxx1  - Есть/нет перевод строки для печати значения
 static char pstr[7][11];
 char *pptr[3];
 char *f="%-4d/%-2d/%-2d",*f2="на %-4.0f кН= ";
 int Dop=8,si=0,pi=0,i;
 pptr[0]=&(Peregon_[0]);
 pptr[1]=&(Rails0[Rails_][0]);
 pptr[2]=&(Shpala0[Shpala_][0]);
 sprintf(pstr[0],f,km[0],km[1],km[2]);
 sprintf(pstr[1],f,km[3],km[4],km[5]);
 sprintf (pstr[2],"%-5.1f",Tmax);  sprintf (pstr[3],"%-d",Tmin);
 // gcvt (Tmax,8,pstr[2]); gcvt (Tmin,8,pstr[3]);
 itoa (Radius0[Radius_],pstr[4],10);
 if (!(What&0x80)) { // Not Ris 9
  if (Shpala_) { //ж./б.
   Dop=(What&0x40?3:2); //Ris 8, Ris 6
   strcpy (&phdr[8][21],"1 стыка ");  }
  else {        //дер.
   strcpy (&phdr[8][21],"4 стыков");
   Dop=(What&0x40?12:8); } //Ris 8, Ris 6
 }
 sprintf (pstr[5],"%-4d",Dop); // itoa (Dop,pstr[5],5);
 sprintf (pstr[6],"%-5.1f",SGP); sprintf (pstr[7],"%-5.1f",SGM);
 // gcvt (SGP,5,pstr[6]);  gcvt (SGM,5,pstr[7]);
 if (What&0x80) { fprintf (printer, // Ris 9
  "\nНормальные зазоры для осенне-зимнего"
  "\nи весенне-летнего периода");  HowManyPrint+=2; }
 else { fprintf (printer, // Ris 6,8
  "\nТаблица нормальных зазоров");  HowManyPrint++; }
 if (!(What&0xc0)) { fprintf (printer, // Ris 6
  "\nЗапас температурной амплитуды не использован");  HowManyPrint++; }
 fprintf (printer,"\n");  HowManyPrint++;
 for (i=0; i<11; i++) {
  fprintf (printer,"%s",phdr[i]);
  if ( (Per[i])&0x01) { fprintf (printer,"\n     "); HowManyPrint++; }
  else fprintf (printer,"  ");
  if ((Per[i])&0x10) {
   if (si==6) fprintf (printer,f2,DN1);
   if (si==7) fprintf (printer,f2,DN2);
   fprintf (printer,"%s",pstr[si]); si++;
  }
  else { fprintf (printer,"%s",pptr[pi]); pi++; }
  fprintf (printer,"\n"); HowManyPrint++;
 } return;
}
*/
char RegType;

int Regul_Menu(void) {
 static MODE poit = 0;
 VID  opr = { 30, 22, 608, 82, 0x11, "Выберите $способ$ регулировки зазоров",
  "1!1!4$4/" };
 CASE tabl[] = {
  {70,40,400,120, 14,12,1,
    "Регулировка для приведения к нормальным с учетом допуска на $1$ стык",
    "      Позволяет снизить объем работ по&"
    "регулировке за счет $уменьшения допуска$,&"
    "что приводит к уменьшению стыковых&"
    "зазоров", Esc_Key},
  {70,51,400,131, 14,12,0,
    "Регулировка по условию превышения допуска на содержание $4$ стыков",
    "      Регулировка (разгонка) зазоров&"
    "производится только на участках, где&"
    "текущая $сумма$ 4-х зазоров $превышает$&"
    "допуск на их содержание", Esc_Key }
 };
 Init_Case_Wnd( &opr, tabl, &poit );
 if (!(Thank&0x08)) { Clr_Scr(); return 0xff; } // Отказ-ESC
 return (poit);
}

void Reg_Info(void) {
 extern char far *Segment;
 static KEY Alt_0[] = { 0,0 };
 static char *hlp=NULL;
 static MODE *vtitle[]= {
  "Ведомость регулировки (разгонки) зазоров для приведения их&"
  "к нормальным с учетом допуска на 1 стык",
  "Ведомость регулировки зазоров по условию превышения допуска&"
  "на содержание 4 стыков"
 };
 int k;
 VIDI   opr = { 40, 15, 610, 175, 0x26, vtitle[RegType], Alt_0 };
 CASEI  tabl[] = {
  { 10,-10,260,35, 22,20,0,"Название участка",
    300,20,70,Segment, hlp, Nop },

  { 266,-10,396,35, 12,10,0,"Участок:",
    300,20,70,Str2, hlp, Nop },

  { 402,-10,532,35,12,10,0,"(км/пк/cтык)",
    270,20,70,Str3, hlp, Nop },

  { 10,40,180,95, 19, 16, 0,"Расчетный допуск на&содержание 1/4 стыков",
    300,20,70, Str4, hlp, Nop },

  { 186,40, 356,95, 19, 16,0, "Назначенный допуск на&содержание 1/4 стыков",
    300,20,70, Str5, hlp, Nop },

  { 362,40, 532, 95, 9, 7, 0, "Нормальный зазор,&мм",
    270,20,70, Str6, hlp, Nop },
 };
 char *Bet[2]={"/"," мм"};
 char *f="%4d/%2d/%2d";
 sprintf(Str2,f,StartKm,StartPk,StartSt);
 sprintf(Str3,f,EndKm, EndPk, EndSt);
 itoa (Norm_Zazor_,Str6,10);
 _fmemset (Str4,'\0',16); _fmemset (Str5,'\0',16);
 Str4[0]='\0'; Str5[0]='\0'; // Допуски на 1 и 4
 for (k=0;k<2;k++) {             // расчетный и назначенный
  sprintf (Str7,"%-5.1f",Dop14[k]); // gcvt (Dop14[k],3,Str7);
  strcat (Str4,Str7); strcat (Str4,Bet[k]);
  sprintf (Str8,"%-5.1f",A14[k]);   // gcvt (A14[k],3,Str8);
  strcat (Str5,Str8); strcat (Str5,Bet[k]);
 }
 Thank|=0x11; // Запрещаем ввод и сохранение окна
 Set_Key (1,ALT_C);
 Get_Many_Text (&opr,tabl);
 setfillstyle (SOLID_FILL,BLACK); setcolor (BLACK);
 bar (opr.x1+8,opr.y1+70,opr.x2-8,opr.y1+72);
 rectangle (opr.x1+8,opr.y1+81,opr.x1+366,opr.y1+131);
 return;
}

void Ved1(void) {
 static int ii=0;
 RegType=Regul_Menu();
 if (RegType==255) return;
 cmes();
 Init_Izmer(); //Прочитать Norm_Zazor_
 Read_Reg(); //Прочитать информацию о HLA,SLA,DN,DR и привед.тем-ре Tmp_All

 switch (RegType) {
  case 0x00: ii=main_nnn21(); break;
  case 0x01: ii=main_nn2();   break;
 }
 if (ii) { Mistake(30); return; }
 Reg_Info ();
 Win_Reg  ();
// if (Line==0x00) {  Line=0x01; Ext_Function=Vedomost; Set_Key (1,START); }
// else Line=0x00;
 return;
}
