unit MCAD_MI1201_FileOutput;

interface
  USES  SysUtils, Classes, MITypes, Registry,MCAD_MI1201_Thread_Types;

type
  tMsDataFileType=(msdftText);
  tMsDataFileFlag=(msdffOverride, msdffCommentAtBegin, msdffAddAutoComment,
                   msdffAddComment, msdffWriteStrings);
  tMsDataFileFlags=set of tMsDataFileFlag;

  tMsDataTextFileFormat=record
    Format: TFloatFormat;
    Precision, Digits: word;
    ColumnWidth:integer;
    NumberSeparator,
    CommentBegin,CommentEnd,
    CommentLineBegin{,CommentLineEnd}:String;
  end;

  tMsDataFileFormat=class(TObject)
    private
      prStream:TStream;
      prComment:tStringList;
      prMassMin,prMassMax:tMass;
      function MassMinGet:tMass;
      function MassMaxGet:tMass;
      procedure WriteSeriesTitleLineForStrings;
      procedure WriteSeriesTitleLineForColumns;
    public
      FileType:tMsDataFileType;
      Flags:tMsDataFileFlags;
      FileName:string;
      TextFile:tMsDataTextFileFormat;
      Series:tSeriesSet;
      WriteMassSeries:tSeriesSet;
      property Comment:tStringList read prComment;
      property MassMin:tMass read MassMinGet write prMassMin;
      property MassMax:tMass read MassMaxGet write prMassMax;
      function FullMassRange:boolean;
      constructor Create;
      destructor Destroy; override;
      procedure WriteComment;
      procedure WriteSeriesTitleLine;
      procedure WriteString(AString:string);
      procedure WritelnString(AString:string);
      procedure WriteStringLen(AString:string; ALength:integer);
      procedure WriteCommentString(AString:string);
      procedure WriteCommentBegin;
      procedure WriteCommentEnd;
      procedure WritelnCommentString(AString:string);
      procedure WriteON_OFF(AState:boolean);
      procedure Writeln;
      function  LineComment:boolean;
      function  NoLineComment:boolean;
      function  Open:TFileStream;
      procedure Close;
      function  Stream:TStream;
      procedure Assign(ADFF:tMsDataFileFormat);
      procedure WriteToRegistry(ARegstry:tRegistry);
      procedure ReadFromRegistry(ARegstry:tRegistry);
      procedure FlagSetState(AFlag:tMsDataFileFlag; AState:boolean);
  end;

implementation
  USES Windows;

constructor tMsDataFileFormat.Create;
begin
  Inherited;
  prComment:=tStringList.Create;
end;

destructor tMsDataFileFormat.Destroy;
begin
  Comment.Free;
  prStream.Free;
  Inherited;
end;

function tMsDataFileFormat.Open:TFileStream;
  resourcestring
    rcFile='Ôàéë: ';
    rcExists=' óæå ñóùåñòâóåò';
begin
  Close;
  if not (msdffOverride in Flags) and FileExists(FileName) then begin
    raise Exception.Create(rcFile+FileName+rcExists);
  end;
  Result:=TFileStream.Create(FileName, fmCreate or fmShareDenyWrite);
  prStream:=Result;
end;

procedure tMsDataFileFormat.Close;
begin
  FreeAndNil(prStream);
end;

function  tMsDataFileFormat.Stream:TStream;
begin
  Result:=prStream;
end;

function tMsDataFileFormat.NoLineComment:boolean;
begin
   Result:= not LineComment;
end;

function tMsDataFileFormat.LineComment:boolean;
begin
   Result:= (Length(TextFile.CommentBegin)=0)
        and (Length(TextFile.CommentEnd)=0);
end;

procedure tMsDataFileFormat.WriteComment;
  var i:integer; //lc:boolean;
begin
  if (Comment.Count>0) then begin
    WriteCommentBegin;
    if NoLineComment then begin
      WriteString(Comment.Text);
//      Writeln;
    end else begin
      for i:=0 to Pred(Comment.Count) do begin
        WriteString(TextFile.CommentLineBegin);
        WriteString(Comment[i]);
        Writeln;
      end;
    end;
    WriteCommentEnd;
  end;
end;

procedure tMsDataFileFormat.WriteString(AString:string);
begin
  if (Length(AString)>0) then begin
    Stream.Write(AString[1],Length(AString));
  end;
end;

procedure tMsDataFileFormat.WritelnString(AString:string);
begin
  WriteString(AString);
  Writeln;
end;

procedure tMsDataFileFormat.WriteStringLen(AString:string; ALength:integer);
begin
  if (Length(AString)<ALength) then begin
    WriteString(AString);
  end else if (ALength>0) then begin
    Stream.Write(AString[1],ALength);
  end;
end;

procedure tMsDataFileFormat.Assign(ADFF:tMsDataFileFormat);
  var i:integer;
begin
  if ADFF=Self then Exit;
  Flags:=ADFF.Flags;
  FileName:=ADFF.FileName;
  Series:=ADFF.Series;
  MassMin:=ADFF.MassMin;
  MassMax:=ADFF.MassMax;

  TextFile.CommentBegin:=ADFF.TextFile.CommentBegin;
  TextFile.CommentEnd:=ADFF.TextFile.CommentEnd;
  TextFile.CommentLineBegin:=ADFF.TextFile.CommentLineBegin;
{  TextFile.CommentLineEnd:=ADFF.TextFile.CommentLineEnd;}
  TextFile.NumberSeparator:=ADFF.TextFile.NumberSeparator;
  TextFile.ColumnWidth:=ADFF.TextFile.ColumnWidth;
  TextFile.Format:=ADFF.TextFile.Format;
  TextFile.Precision:=ADFF.TextFile.Precision;
  TextFile.Digits:=ADFF.TextFile.Digits;

  prComment.Clear;
  for i:=0 to Pred(ADFF.prComment.Count) do begin
    prComment.Add(ADFF.prComment.Strings[i]);
  end;
end;

procedure tMsDataFileFormat.WriteToRegistry(ARegstry:tRegistry);
begin
  ARegstry.WriteBinaryData('Flags',Flags,SizeOf(Flags));
  ARegstry.WriteString('FileName',FileName);
  with TextFile do begin
    ARegstry.WriteString('CommentBegin',CommentBegin);
    ARegstry.WriteString('CommentEnd',CommentEnd);
    ARegstry.WriteString('CommentLineBegin',CommentLineBegin);
//    ARegstry.WriteString('CommentLineEnd',CommentLineEnd);
    ARegstry.WriteString('NumberSeparator',NumberSeparator);
    ARegstry.WriteBinaryData('Format',Format,SizeOf(Format));
    ARegstry.WriteInteger('ColumnWidth',ColumnWidth);
    ARegstry.WriteInteger('Precision',Precision);
    ARegstry.WriteInteger('Digits',Digits);
    ARegstry.WriteString('CommentText',Comment.Text);
  end;
  ARegstry.WriteBinaryData('Series',Series,SizeOf(Series));
  ARegstry.WriteFloat('MassMin',MassMin);
  ARegstry.WriteFloat('MassMax',MassMax);
end;

procedure tMsDataFileFormat.ReadFromRegistry(ARegstry:tRegistry);
begin
  ARegstry.ReadBinaryData('Flags',Flags,SizeOf(Flags));
  FileName:=ARegstry.ReadString('FileName');
  with TextFile do begin
    CommentBegin:=ARegstry.ReadString('CommentBegin');
    CommentEnd:=ARegstry.ReadString('CommentEnd');
    CommentLineBegin:=ARegstry.ReadString('CommentLineBegin');
//    CommentLineEnd:=ARegstry.ReadString('CommentLineEnd');
    NumberSeparator:=ARegstry.ReadString('NumberSeparator');
    ARegstry.ReadBinaryData('Format',Format,SizeOf(Format));
    ColumnWidth:=ARegstry.ReadInteger('ColumnWidth');
    Precision:=ARegstry.ReadInteger('Precision');
    Digits:=ARegstry.ReadInteger('Digits');
    Comment.Text:=ARegstry.ReadString('CommentText');
  end;
  ARegstry.ReadBinaryData('Series',Series,SizeOf(Series));
  MassMin:=ARegstry.ReadFloat('MassMin');
  MassMax:=ARegstry.ReadFloat('MassMax');
end;

function CenterStr(const AString:string; ALength:cardinal):string;
  var len,di,dj:cardinal;
begin
  Result:=AString;
  len:=Length(Result);
  if len<ALength then begin
    SetLength(Result, ALength);
    di:=(ALength-len);
    dj:=di div 2;
    Dec(di,dj);
    Move(Result[1],Result[Succ(di)],Len);
    FillMemory(@Result[1],di,Ord(' '));
    FillMemory(@Result[Succ(di)+Len],dj,Ord(' '));
 end;
end;

procedure tMsDataFileFormat.WriteSeriesTitleLineForColumns;
  var ss,s0:string; s:tSeries; l:cardinal;
begin
  if LineComment then
    ss:=TextFile.CommentLineBegin
  else
    ss:='';
  l:=TextFile.ColumnWidth;
  for s:=Low(s) to High(s) do begin
    if s in Series then begin
      s0:=cMSSeriesTitles[s];
      if s in WriteMassSeries then
        ss:=ss+CenterStr(s0+'.M ', l)+CenterStr(s0+'.Y', l)
      else
        ss:=ss+CenterStr(s0+'.Y', l);
    end;
  end;
  ss:=ss+cEOL;
  WriteString(ss);
end;

procedure tMsDataFileFormat.WriteSeriesTitleLineForStrings;
  var lc, ss,s0:string; s:tSeries;
begin
  if LineComment then
    lc:=TextFile.CommentLineBegin
  else
    lc:='';
  ss:='';
  for s:=Low(s) to High(s) do if s in Series then begin
    s0:=cMSSeriesTitles[s];
    if s in WriteMassSeries then
      ss:=ss+lc+s0+'.M '+cEOL
            +lc+s0+'.Y'+cEOL
    else
      ss:=ss+lc+s0+'.Y'+cEOL;
  end;
  WriteString(ss);
end;

procedure tMsDataFileFormat.WriteSeriesTitleLine;
begin
  if (msdffWriteStrings in Flags) then begin
    WriteSeriesTitleLineForStrings;
  end else begin
    WriteSeriesTitleLineForColumns;
  end;
end;

procedure tMsDataFileFormat.WriteCommentString(AString:string);
begin
  if Not NoLineComment then
    WriteString(TextFile.CommentLineBegin);
  WriteString(AString);
end;

procedure tMsDataFileFormat.WritelnCommentString(AString:string);
begin
  WriteCommentString(AString);
  Writeln;
end;

procedure tMsDataFileFormat.Writeln;
begin
  WriteString(cEOL);
end;

procedure tMsDataFileFormat.WriteON_OFF(AState:boolean);
begin
  if AState then
    WriteString('ÂÊË.')
  else
    WriteString('ÎÒÊË.');
end;

procedure tMsDataFileFormat.WriteCommentBegin;
begin
  if NoLineComment then begin
    WriteString(TextFile.CommentBegin);
    Writeln;
  end;
end;

procedure tMsDataFileFormat.WriteCommentEnd;
begin
  if NoLineComment then begin
    WriteString(TextFile.CommentEnd);
    Writeln;
  end;
end;

function tMsDataFileFormat.MassMinGet:tMass;
begin
  if prMassMin<=prMassMax then
    Result:=prMassMin
  else
    Result:=prMassMax;
end;

function tMsDataFileFormat.MassMaxGet:tMass;
begin
  if prMassMin<=prMassMax then
    Result:=prMassMax
  else
    Result:=prMassMin;
end;

function tMsDataFileFormat.FullMassRange:boolean;
begin
  Result:=(prMassMin=0) and (prMassMax=0);
end;

procedure tMsDataFileFormat.FlagSetState(AFlag:tMsDataFileFlag; AState:boolean);
begin
  if AState then
    Include(Flags, AFlag)
  else
    Exclude(Flags, AFlag)
end;

END.