laba_7_2_del

unit MainUnit;

interface

uses
    Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
    System.Classes, Vcl.Graphics,
    Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Vcl.Buttons,
    Vcl.ExtCtrls,
    Vcl.Samples.Spin, Vcl.Menus, Vcl.Grids, System.RegularExpressions,
    Vcl.Imaging.jpeg, Vcl.ExtDlgs, Math;

type
    TCoords = record
        X: Integer;
        Y: Integer;
    end;

    TArrStr = Array of String;

    TPath = Array of Integer;

    TMatrix = array of array of Integer;

    TMainForm = class(TForm)
        Visualizer: TImage;
        MatrixGrid: TStringGrid;
        OpenDialog: TOpenDialog;
        MainMenu1: TMainMenu;
    About: TMenuItem;
        File1: TMenuItem;
    OpenFile: TMenuItem;
        OrderSpinEdit: TSpinEdit;
        LabelMatrixInput: TLabel;
        LabelSetSize: TLabel;
        LabelGraph: TLabel;
        SaveDialog: TSaveDialog;
        LabelToMeasureScreenOfUser: TLabel;
    LabelFromVertex: TLabel;
    SpinEditFromVertex: TSpinEdit;
    LabelToVetex: TLabel;
    SpinEditToVertex: TSpinEdit;
    NSaveAs: TMenuItem;
    BalloonHint1: TBalloonHint;
    NFileReq: TMenuItem;
        procedure OrderSpinEditChange(Sender: TObject);
        procedure SetSize();
        procedure FormCreate(Sender: TObject);
        procedure OpenFileClick(Sender: TObject);
        procedure DrawVertexes();
        procedure DrawLines();
        procedure DrawGraph();
        procedure ShowGraphButtonClick(Sender: TObject);
        procedure GetMatrixFromGrid();
        procedure DrawShortestWay();
        procedure ClearScreen();
        procedure MatrixGridSetEditText(Sender: TObject; ACol, ARow: Integer;
          const Value: string);
        procedure AboutClick(Sender: TObject);
        procedure FormCloseQuery(Sender: TObject; var CanClose: Boolean);
    procedure SpinEditVertexChange(Sender: TObject);
    procedure NSaveAsClick(Sender: TObject);
    procedure NFileReqClick(Sender: TObject);
    private
        MultPix: Single;
        function MultPixels(PixQuant: Integer): Integer;
        procedure ConvertAllConstants();
        function GetFastestPath(FromU, ToV: Integer): TPath;
        procedure DrawExtraVertexAndLine(X1, Y1, X2, Y2: Integer);
        function GetCoordsOfVertex(VertexNumber, AmountOfVertexes
          : Integer): TCoords;
        procedure CalculateAllPaths();
        procedure DrawWeights();
        procedure DrawEverythingAndCalculateEverything();
    public
        { Public declarations }
    end;

var
    MainForm: TMainForm;
    DEFAULT_WIDTH_Real, POINT_RAD_Real, LINE_WIDTH_Real,
      GRAPH_RAD_Real, VERTEX_RAD_Real, FONT_HEIGHT_Real, PATH_WIDTH_Real: Integer;
    Matrix, FullWeightMatrix: TMatrix;
    PathMatrix: TMatrix;
    DataIsSaved: Boolean;
    PathStr: String;

const
    VERTEXES_COLOR = $00B3B300;
    BACKGROUND_COLOR = $001C1A13;
    WEIGHT_COLOR = $004F009D;
    PATH_COLOR = $004F00FF;
    POINT_RAD = 10;
    LINE_WIDTH = 5;
    GRAPH_RAD = 150;
    VERTEX_RAD = 30;
    FONT_HEIGHT = 20;
    INF = 1000000;
    MAX_ORDER = 10;
    MIN_ORDER = 2;

function FindRegEx(SInput, StrRegEx: String; StrIfNothingFound: String = '')
  : TArrStr; external 'FindRegExes.dll';
procedure MyMessageBoxInfo(Form: TForm; CaptionWindow, TextMessage: String;
  IsWarning: Boolean = False); external 'Dll_MyMessageBox.dll';
function MyMessageBoxYesNo(Form: TForm; CaptionWindow, TextMessage: String;
  IsWarning: Boolean = False): Boolean; external 'Dll_MyMessageBox.dll';

implementation

{$R *.dfm}

function TMainForm.GetFastestPath(FromU, ToV: Integer): TPath;
var
    Path: TPath;
    LengthOfPath, SizeOfMatrix: Integer;

begin
    if FullWeightMatrix[FromU - 1][ToV - 1] < INF then
    begin
        SizeOfMatrix := Length(Matrix);
        SetLength(Path, SizeOfMatrix);
        LengthOfPath := 0;
        PathStr := '';
        while ToV <> FromU do
        begin
            Path[LengthOfPath] := FromU;
            PathStr := PathStr + IntToStr(FromU) + ' -> ';
            Inc(LengthOfPath);
            FromU := PathMatrix[FromU - 1, ToV - 1];
        end;
        Path[LengthOfPath] := FromU;
        PathStr := PathStr + IntToStr(FromU);
        Inc(LengthOfPath);
        SetLength(Path, LengthOfPath);
    end
    else
        SetLength(Path, 0);

    Result := Path;
end;

procedure TMainForm.CalculateAllPaths();
var
    i, U, V: Integer;
    SizeOfMatrix: Integer;

begin
    SizeOfMatrix := Length(Matrix);
    SetLength(PathMatrix, SizeOfMatrix, SizeOfMatrix);
    SetLength(FullWeightMatrix, SizeOfMatrix, SizeOfMatrix);

    for U := 0 to SizeOfMatrix - 1 do
        for V := 0 to SizeOfMatrix - 1 do
        begin
            FullWeightMatrix[U][V] := Matrix[U][V];
            PathMatrix[U][V] := V + 1;
        end;

    for i := 0 to SizeOfMatrix - 1 do
        for U := 0 to SizeOfMatrix - 1 do
            for V := 0 to SizeOfMatrix - 1 do
                if (U <> i) and (V <> i) and (FullWeightMatrix[U, i] + FullWeightMatrix[i, V] < FullWeightMatrix[U, V])
                 and (FullWeightMatrix[U, i] < INF) and (FullWeightMatrix[i, V] < INF) then
                begin
                    FullWeightMatrix[U, V] := FullWeightMatrix[U, i] +
                      FullWeightMatrix[i, V];

                    PathMatrix[U, V] := PathMatrix[U, i];
                end;
end;

procedure TMainForm.DrawVertexes();
var
    i, X, Y, OffsetOfTextYUp, OffsetOfTextYDown, OffsetOfTextX_Real, SizeOfMatrix: Integer;
    CurrCoords: TCoords;

const
    OffsetOfTextX = 5;

begin
    SizeOfMatrix := Length(Matrix);
    OffsetOfTextYUp := VERTEX_RAD_Real + FONT_HEIGHT_Real;
    OffsetOfTextYDown := VERTEX_RAD_Real;
    OffsetOfTextX_Real := MultPixels(OffsetOfTextX);

    with Visualizer.Canvas do
    begin
        Pen.Color := VERTEXES_COLOR;
        Pen.Width := 1;
        Font.Name := 'Segoe UI';
        Font.Style := [fsBold];
        Font.Color := VERTEXES_COLOR;
        Font.Height := FONT_HEIGHT_Real;
        for i := 0 to SizeOfMatrix - 1 do
        begin
            Brush.Color := VERTEXES_COLOR;
            CurrCoords := GetCoordsOfVertex(i + 1, SizeOfMatrix);
            X := CurrCoords.X;
            Y := CurrCoords.Y;
            Ellipse(X - VERTEX_RAD_Real, Y - VERTEX_RAD_Real,
              X + VERTEX_RAD_Real, Y + VERTEX_RAD_Real);
            Brush.Color := BACKGROUND_COLOR;
            if i < SizeOfMatrix / 2 then
                TextOut(X - OffsetOfTextX_Real, Y - OffsetOfTextYUp,
                  IntToStr(i + 1))
            else
                TextOut(X - OffsetOfTextX_Real, Y + OffsetOfTextYDown,
                  IntToStr(i + 1));
        end;
    end;
end;

function TMainForm.GetCoordsOfVertex(VertexNumber, AmountOfVertexes
  : Integer): TCoords;
var
    Coords: TCoords;
    Center: TCoords;
    Phi: Extended;

begin
    Phi := (VertexNumber - 1) * 2 * Pi / AmountOfVertexes;
    Center.X := Visualizer.Width div 2;
    Center.Y := Visualizer.Height div 2;

    Coords.Y := Round(Center.Y - GRAPH_RAD_Real * Sin(Phi));
    Coords.X := Round(Center.X - GRAPH_RAD_Real * Cos(Phi));

    Result := Coords;
end;

procedure TMainForm.DrawLines();
var
    i, J: Byte;
    X1, X2, Y1, Y2: Integer;

begin
    with Visualizer.Canvas do
    begin
        Pen.Color := VERTEXES_COLOR;
        Font.Color := VERTEXES_COLOR;
        Pen.Width := LINE_WIDTH_Real;
        for i := 0 to High(Matrix) do
        begin
            for J := i + 1 to High(Matrix) do
            begin
                if (Matrix[i][j] < INF) then
                begin
                    X1 := GetCoordsOfVertex(i + 1, Length(Matrix)).X;
                    Y1 := GetCoordsOfVertex(i + 1, Length(Matrix)).Y;
                    X2 := GetCoordsOfVertex(j + 1, Length(Matrix)).X;
                    Y2 := GetCoordsOfVertex(j + 1, Length(Matrix)).Y;
                    MoveTo(X1, Y1);
                    LineTo(X2, Y2);
                end;
            end;
        end;
    end;
end;

procedure TMainForm.DrawWeights();
var
    i, J: Byte;
    X1, X2, Y1, Y2, XMid, YMid, ShX, ShY, dY, dX: Integer;
    Diagonal: Extended;

begin
    with Visualizer.Canvas do
    begin
        Pen.Color := WEIGHT_COLOR;
        Font.Color := WEIGHT_COLOR;
        Brush.Color := VERTEXES_COLOR;
        Pen.Width := Max(1, LINE_WIDTH_Real div 3);
        Font.Height := FONT_HEIGHT_Real * 2 div 3;
        for i := 0 to High(Matrix) do
        begin
            for J := i + 1 to High(Matrix) do
            begin
                if (Matrix[i][j] < INF) then
                begin
                    X1 := GetCoordsOfVertex(i + 1, Length(Matrix)).X;
                    Y1 := GetCoordsOfVertex(i + 1, Length(Matrix)).Y;
                    X2 := GetCoordsOfVertex(j + 1, Length(Matrix)).X;
                    Y2 := GetCoordsOfVertex(j + 1, Length(Matrix)).Y;
                    dX := X2 - X1;
                    dY := Y2 - Y1;
                    Diagonal := Sqrt(dy * dy + dx * dx);
                    ShX := Trunc(2 * POINT_RAD_Real * dY / Diagonal);
                    ShY := - Trunc(2 * POINT_RAD_Real * dX / Diagonal);

                    XMid := (X1 + X2) div 2;
                    YMid := (Y1 + Y2) div 2;
                    if dX <> 0 then
                    begin
                        XMid := XMid + dX * 3 div 17;
                        YMid := YMid + dX * 3 div 17 * dY div dX;
                    end
                    else
                    begin
                        YMid := YMid + dY * 3 div 17;
                        XMid := XMid + dY * 3 div 17 * dX div dY;
                    end;


                    MoveTo(XMid, YMid);
                    LineTo(XMid + ShX, YMid + ShY);
                    Ellipse(XMid - LINE_WIDTH_Real div 2, YMid - LINE_WIDTH_Real div 2, XMid + LINE_WIDTH_Real div 2, YMid + LINE_WIDTH_Real div 2);
                    TextOut(XMid + ShX, YMid + ShY - Font.Height div 2, IntToStr(Matrix[i][j]));
                end;
            end;
        end;
    end;
end;

procedure TMainForm.DrawGraph();
begin
    DrawVertexes();
    DrawLines();
    DrawWeights();
end;

procedure TMainForm.DrawShortestWay();
var
    i: Integer;
    Path: TPath;
    FromU, ToV: Integer;

begin
    ClearScreen();
    DrawGraph();

    FromU := SpinEditFromVertex.Value;
    ToV := SpinEditToVertex.Value;

    Path := GetFastestPath(FromU, ToV);
    with Visualizer.Canvas do
        if Length(Path) > 1 then
        begin
            for i := 0 to High(Path) - 1 do
                DrawExtraVertexAndLine(GetCoordsOfVertex(Path[i], Length(Matrix)).X,
                 GetCoordsOfVertex(Path[i], Length(Matrix)).Y,
                 GetCoordsOfVertex(Path[i + 1], Length(Matrix)).X,
                 GetCoordsOfVertex(Path[i + 1], Length(Matrix)).Y);

            Font.Height := POINT_RAD_Real * 2;
            Brush.Color := BACKGROUND_COLOR;
            Font.Color := VERTEXES_COLOR;
            TextOut(POINT_RAD_Real, POINT_RAD_Real, 'Путь из вершины ' + IntToStr(FromU) + ' в вершину ' + IntToStr(ToV) + ' имеет вес ' + IntToStr(FullWeightMatrix[FromU - 1][ToV - 1]));
        end
        else
        begin
            Font.Height := POINT_RAD_Real * 2;
            Brush.Color := BACKGROUND_COLOR;
            Font.Color := WEIGHT_COLOR;
            TextOut(POINT_RAD_Real, POINT_RAD_Real, 'Путь из вершины ' + IntToStr(FromU) + ' в вершину ' + IntToStr(ToV) + ' не найден');
        end;

    DrawWeights();
end;

procedure TMainForm.DrawExtraVertexAndLine(X1, Y1, X2, Y2: Integer);
begin
    with Visualizer.Canvas do
    begin
        Pen.Color := PATH_COLOR;
        Pen.Width := PATH_WIDTH_Real;
        Brush.Color := PATH_COLOR;
        Ellipse(X1 - POINT_RAD_Real, Y1 - POINT_RAD_Real, X1 + POINT_RAD_Real,
          Y1 + POINT_RAD_Real);
        Ellipse(X2 - POINT_RAD_Real, Y2 - POINT_RAD_Real, X2 + POINT_RAD_Real,
          Y2 + POINT_RAD_Real);

        MoveTo(X1, Y1);
        LineTo(X2, Y2);
    end;
end;

procedure TMainForm.FormCloseQuery(Sender: TObject; var CanClose: Boolean);
begin
    CanClose := MyMessageBoxYesNo(MainForm, 'Закрыть программу?',
      'Вы уверены, что хотите выйти из программы?');
end;

procedure TMainForm.FormCreate(Sender: TObject);
begin
    MultPix := LabelToMeasureScreenOfUser.Width / 100;
    ConvertAllConstants();
    DataIsSaved := True;

    OrderSpinEdit.Value := 10;
    ClearScreen();
    MainForm.Width := DEFAULT_WIDTH_Real;

    DrawEverythingAndCalculateEverything();
end;

procedure TMainForm.ConvertAllConstants();
begin
    DEFAULT_WIDTH_Real := MatrixGrid.Left + Visualizer.Width + Visualizer.Left;
    POINT_RAD_Real := MultPixels(POINT_RAD);
    LINE_WIDTH_Real := MultPixels(LINE_WIDTH);
    GRAPH_RAD_Real := MultPixels(GRAPH_RAD);
    VERTEX_RAD_Real := MultPixels(VERTEX_RAD);
    FONT_HEIGHT_Real := MultPixels(FONT_HEIGHT);
    PATH_WIDTH_Real := Max(1, LINE_WIDTH_Real div 2);
end;

procedure TMainForm.ClearScreen();
begin
    with Visualizer.Canvas do
    begin
        Brush.Color := BACKGROUND_COLOR;
        Pen.Color := BACKGROUND_COLOR;
        Rectangle(0, 0, Visualizer.Width, Visualizer.Height);
    end;
end;

procedure TMainForm.OpenFileClick(Sender: TObject);
const
    ErrorDuringInputOccured = 'Возникла ошибка при открытии файла.' + #10#13 +
                'Пожалуйста, выберите файл формата (.txt) с ' +
                'корректными данными.';

var
    FileInput : TextFile;
    PathToFile, String1, RegExString: String;
    i, j, SizeOfMatrix: Integer;
    IsCorrect, SaidNoSaving: Boolean;
    ArrStr: TArrStr;

begin
    IsCorrect := True;
    SaidNoSaving := False;

    if not DataIsSaved then
        if MyMessageBoxYesNo(MainForm, 'Сохранить данные?', 'Вы хотите сохранить текущие данные?' +
        #10#13 + 'Иначе после открытия файла все текущие данные будут утеряны.', True) then
            NSaveAsClick(MainForm)
        else
            SaidNoSaving := True;

    if (DataIsSaved or SaidNoSaving or MyMessageBoxYesNo(MainForm, 'Открыть файл?', 'Вы уверены, что хотите открыть новый файл?' + #10#13 +
        'Все текущие данные будут утеряны.', True))
        and OpenDialog.Execute then
    begin
        PathToFile := OpenDialog.FileName;

        try
            AssignFile(FileInput, PathToFile);
            Reset(FileInput);

            Readln(FileInput, String1);
            RegExString := FindRegEx(String1, '^\s*0*([2-9]|10)\s*$')[0];
            if RegExString <> '' then
            begin
                SizeOfMatrix := StrToInt(RegExString);
                OrderSpinEdit.Value := SizeOfMatrix;
                SetSize();
            end
            else
                IsCorrect := False;

            i := 0;
            while IsCorrect and (i < SizeOfMatrix) do
            begin
                Readln(FileInput, String1);
                RegExString := FindRegEx(String1 + ' ', '^\s*(((0*([1-9]\d{0,2})?)|-)\s+){' + IntToStr(SizeOfMatrix) + '}\s*$')[0];
                if RegExString <> '' then
                begin
                    ArrStr := FindRegEx(RegExString, '([1-9]\d{0,2})|-');
                    j := 0;
                    while j < Length(ArrStr) do
                    begin
                        String1 := ArrStr[j];
                        if String1 = '-' then
                            MatrixGrid.Cells[j + 1, i + 1] := ''
                        else
                            MatrixGrid.Cells[j + 1, i + 1] := String1;

                        MatrixGridSetEditText(Self, j + 1, i + 1, MatrixGrid.Cells[J + 1, i + 1]);
                        Inc(j);
                    end;
                end
                else
                    IsCorrect := False;
                Inc(i);
            end;
        except
            IsCorrect := False;
        end;

        if not IsCorrect then
        begin
            MyMessageBoxInfo(MainForm, 'Ошибка', ErrorDuringInputOccured, True);

            SetSize();
        end;
    end;

    DrawEverythingAndCalculateEverything();
end;

procedure TMainForm.AboutClick(Sender: TObject);
begin
    MyMessageBoxInfo(MainForm, 'Справка',
      'Граф задан матрицей смежности, где числа - весы рёбер. Программа находит самый быстрый путь из одной вершины в другую.');
end;

procedure TMainForm.NFileReqClick(Sender: TObject);
begin
    MyMessageBoxInfo(MainForm, 'Требования к файлу',
      'В первой строке должно быть число - количество N вершин графа. Затем должно следовать N строк по N чисел от 0 до 999.');
end;

procedure TMainForm.OrderSpinEditChange(Sender: TObject);
begin
    DataIsSaved := False;
    SetSize();

    SpinEditFromVertex.MaxValue := OrderSpinEdit.Value;
    SpinEditFromVertex.Value := Min(SpinEditFromVertex.Value, OrderSpinEdit.Value);
    SpinEditToVertex.MaxValue := OrderSpinEdit.Value;
    SpinEditToVertex.Value := Min(SpinEditToVertex.Value, OrderSpinEdit.Value);

    DrawEverythingAndCalculateEverything();
end;

procedure TMainForm.SetSize();
const
    CorrectionOfWidthOfStringGrid = 5;

var
    i: Byte;
    Size: Byte;

begin
    Size := OrderSpinEdit.Value + 1;
    MatrixGrid.ColCount := Size;
    MatrixGrid.RowCount := Size;
    MatrixGrid.DefaultColWidth :=
      (MatrixGrid.Width - MultPixels(CorrectionOfWidthOfStringGrid))
      div Size;
    MatrixGrid.DefaultRowHeight :=
      (MatrixGrid.Height - MultPixels(CorrectionOfWidthOfStringGrid))
      div Size;
    MatrixGrid.Font.Height := Trunc(MatrixGrid.DefaultRowHeight * 2 / 3);
    for i := Size to 10 do
    begin
        MatrixGrid.Rows[i].Clear;
        MatrixGrid.Cols[i].Clear;
    end;
    for i := 0 to Size - 1 do
    begin
        MatrixGrid.Cells[0, i + 1] := IntToStr(i + 1);
        MatrixGrid.Cells[i + 1, 0] := IntToStr(i + 1);
        MatrixGrid.Cells[i + 1, i + 1] := '0';
    end;
end;

procedure TMainForm.ShowGraphButtonClick(Sender: TObject);
begin
    DrawEverythingAndCalculateEverything();
end;

procedure TMainForm.DrawEverythingAndCalculateEverything();
begin
    GetMatrixFromGrid();

    CalculateAllPaths();
    DrawShortestWay();
end;

procedure TMainForm.SpinEditVertexChange(Sender: TObject);
begin
    DataIsSaved := False;
    if SpinEditFromVertex.Value <> SpinEditToVertex.Value then
        DrawShortestWay()
    else
    begin
        ClearScreen();
        DrawGraph();
    end;
end;

procedure TMainForm.MatrixGridSetEditText(Sender: TObject; ACol, ARow: Integer;
  const Value: string);
var
    FoundRegEx: String;

begin
    DataIsSaved := False;
    if ACol <> ARow then
    begin
        FoundRegEx := FindRegEx(Value.Trim,
          '\d{1,3}')[0];
        if FoundRegEx <> Value then
            MatrixGrid.Cells[ACol, ARow] := FindRegEx(Value.Trim, '\d{1,3}')[0];

        MatrixGrid.Cells[ARow, ACol] := MatrixGrid.Cells[ACol, ARow];
    end
    else
        MatrixGrid.Cells[ACol, ARow] := '0';

    DrawEverythingAndCalculateEverything();
end;

procedure TMainForm.GetMatrixFromGrid();
var
    i, J, SizeOfMatrix: Byte;

begin
    SizeOfMatrix := OrderSpinEdit.Value;
    SetLength(Matrix, SizeOfMatrix, SizeOfMatrix);

    for i := 0 to High(Matrix) do
        for J := 0 to High(Matrix) do
        begin
            if MatrixGrid.Cells[J + 1, i + 1] <> '' then
                Matrix[i][J] := StrToInt(MatrixGrid.Cells[J + 1, i + 1])
            else
                Matrix[i][J] := INF;
        end;
end;

function TMainForm.MultPixels(PixQuant: Integer): Integer;
begin
    Result := Round(PixQuant * MultPix);
end;

procedure TMainForm.NSaveAsClick(Sender: TObject);
var
    FileOutput : TextFile;
    StrFilePath: String;
    ShouldNotRepeat, TimerGoes: Boolean;
    Point: TPoint;
    i, j ,k, ii: Integer;

begin
    try
        repeat
            ShouldNotRepeat := True;
            SaveDialog.FileName := 'Путь в графе ' + DateTimeToStr(Date) + ' ' + TimeToStr(Time).Replace(':', '-', [rfReplaceAll]) + '.txt';

            if SaveDialog.Execute then
            begin
                StrFilePath := SaveDialog.FileName;
                StrFilePath := FindRegEx(StrFilePath, '.+\.txt', StrFilePath + '.txt')[0];

                if FileExists(StrFilePath) then
                    if MyMessageBoxYesNo(MainForm, 'Перезаписать файл?', 'Такой файл уже существует.' +
                        #10#13 + 'Вы хотите перезаписать файл? Это действие невозможно отменить.', True)
                    then
                        ShouldNotRepeat := True
                    else
                        ShouldNotRepeat := False
                else
                    ShouldNotRepeat := True;

                if ShouldNotRepeat then
                begin
                    AssignFile(FileOutput, StrFilePath);
                    Rewrite(FileOutput);

                    Writeln(FileOutput, 'Матрица весов рёбер:');
                    i := 0;
                    while i < Length(Matrix) do
                    begin
                        j := 0;
                        while j < Length(Matrix) do
                        begin
                            if Matrix[i][j] <> INF then
                                Write(FileOutput, IntToStr(Matrix[i][j]) + ' ')
                            else
                                Write(FileOutput, '- ');
                            Inc(j);
                        end;
                        Writeln(FileOutput);

                        Inc(i);
                    end;

                    if FullWeightMatrix[SpinEditFromVertex.Value - 1][SpinEditToVertex.Value - 1] < Inf then
                    begin
                        Writeln(FileOutput, 'Путь из вершины ' + SpinEditFromVertex.Text + ' в вершину ' + SpinEditToVertex.Text + ' имеет вес ' + IntToStr(FullWeightMatrix[SpinEditFromVertex.Value - 1][SpinEditToVertex.Value - 1]) + '.');
                        Writeln(FileOutput, PathStr);
                    end
                    else
                        Writeln(FileOutput, 'Путь из вершины ' + SpinEditFromVertex.Text + ' в вершину ' + SpinEditToVertex.Text + ' не найден.');

                    CloseFile(FileOutput);
                    DataIsSaved := True;
                    BalloonHint1.Title := 'Готово';
                    BalloonHint1.Description := 'Партия успешно сохранена в файл.';
                    Point.X := MultPixels(20);
                    Point.Y := 0;
                    Balloonhint1.ShowHint(ClientToScreen(Point));
                end;
            end;
        until ShouldNotRepeat;
    except
        MyMessageBoxInfo(MainForm, 'Ошибка', 'Не удается открыть файл для вывода данных или записать в него данные.');
    end;
end;

end.